Merge pull request #83 from bashtage/fix-test-input-shape

TST: Fix test input shape

Author: bashtage

randomstate/interface/pcg-64/pcg-64-emulated.pxi

@@ -41,7 +41,7 @@ ctypedef pcg64_random_t rng_t
 cdef object pcg128_to_pylong(pcg128_t x):
     return PyLong_FromUnsignedLongLong(x.high) * 2**64 + PyLong_FromUnsignedLongLong(x.low)
 
-cdef pcg128_t pcg128_from_pylong(object x):
+cdef pcg128_t pcg128_from_pylong(object x) except *:
     cdef pcg128_t out
     out.high = PyLong_AsUnsignedLongLong(x // (2 ** 64))
     out.low = PyLong_AsUnsignedLongLong(x % (2 ** 64))

randomstate/randomstate.pyx

@@ -275,6 +275,13 @@ cdef class RandomState:
             ----------
             seed : int, optional
                 Seed for ``RandomState``.
+            
+            Raises
+            ------
+            ValueError
+                If seed values are out of range for the PRNG.
+            TypeError
+                If seed values are not integers.
 
             Notes
             -----
@@ -287,38 +294,49 @@ cdef class RandomState:
             --------
             RandomState
             """
-            try:
-                if seed is not None:
-                    if hasattr(seed, 'squeeze'):
-                        seed = seed.squeeze()
-                    idx = operator.index(seed)
-                    if idx < 0:
-                        raise ValueError('seed < 0')
-                else:
-                    self.__seed = seed = _generate_seed(RS_SEED_NBYTES)
+            if seed is None:
+                self.__seed = seed = _generate_seed(RS_SEED_NBYTES)
                 set_seed(&self.rng_state, seed)
-            except TypeError:
+                self._reset_state_variables()
+                return
+
+            if hasattr(seed, 'squeeze'):
+                seed = seed.squeeze()
+            IF RS_SEED_ARRAY_BITS == 32:
+                seed = np.asarray(seed).astype(np.object, casting='safe')
+                if np.any((seed // 1) != seed):
+                    raise TypeError("Seed values must be integers between "
+                                    "0 and 4294967295 (2**32-1)")
+                if np.any((seed < int(0)) | (seed > int(2**32-1))):
+                    raise ValueError("Seed values must be integers between "
+                                    "0 and 4294967295 (2**32-1)")
+                seed = np.asarray(seed).astype(np.uint32, casting='unsafe')
+            ELSE:
+                seed = np.asarray(seed).astype(np.object, casting='safe')
+                if np.any((seed // 1) != seed):
+                    raise TypeError("Seed values must be integers between 0 and "
+                                    "18446744073709551616 (2**64-1)")
+                if np.any((seed < int(0)) | (seed > int(2**64-1))):
+                    raise ValueError("Seed values must be integers between 0 and "
+                                     "18446744073709551616 (2**64-1)")
+                seed = np.asarray(seed).astype(np.uint64, casting='unsafe')
+
+            if seed.ndim == 0:
                 IF RS_SEED_ARRAY_BITS == 32:
-                    seed = np.asarray(seed).astype(np.int64, casting='safe')
-                    if ((seed > int(2**32 - 1)) | (seed < 0)).any():
-                        raise ValueError("Seed values must be between 0 and "
-                                         "4294967295  (2**32-1)")
-                    seed = seed.astype(np.uint32, casting='unsafe')
-                    with self.lock:
-                        set_seed_by_array(&self.rng_state,
-                                          <uint32_t *>np.PyArray_DATA(seed),
-                                          np.PyArray_DIM(seed, 0))
+                    seed = <uint32_t> seed
                 ELSE:
-                    seed = np.asarray(seed).astype(np.object, casting='safe')
-                    if ((seed > int(2**64 - 1)) | (seed < 0)).any():
-                        raise ValueError("Seed values must be between 0 and "
-                                         "18446744073709551616 (2**64-1)")
-                    seed = seed.astype(np.uint64, casting='unsafe')
-                    with self.lock:
-                        set_seed_by_array(&self.rng_state,
-                                          <uint64_t *>np.PyArray_DATA(seed),
-                                          np.PyArray_DIM(seed, 0))
-                self.__seed = seed
+                    seed = <uint64_t> seed
+                set_seed(&self.rng_state, seed)
+            else:
+                IF RS_SEED_ARRAY_BITS == 32:
+                    set_seed_by_array(&self.rng_state,
+                                      <uint32_t *>np.PyArray_DATA(seed),
+                                      np.PyArray_DIM(seed, 0))
+                ELSE:
+                    set_seed_by_array(&self.rng_state,
+                                      <uint64_t *>np.PyArray_DATA(seed),
+                                      np.PyArray_DIM(seed, 0))
+            self.__seed = seed
             self._reset_state_variables()
 
     ELSE:
@@ -338,18 +356,41 @@ cdef class RandomState:
             stream : int, optional
                 Generator stream to use
 
+            Raises
+            ------
+            ValueError
+                If seed values are out of range for the PRNG.
+            TypeError
+                If seed values are not scalar integers.
+
             See Also
             --------
             RandomState
             """
-            if seed is None:
+            ub =  2 ** (32 * RS_SEED_NBYTES)
+            if seed is not None:
+                error_msg = 'seed must be a scalar integer 0<=seed<{0}'.format(ub)
+                _seed = np.asarray(seed, dtype=np.object)
+                if _seed.ndim > 0:
+                    raise TypeError(error_msg)
+                elif seed // 1 != seed:
+                    raise TypeError(error_msg)
+                elif seed < 0 or seed >= ub:
+                    raise ValueError(error_msg)
+            else:
                 self.__seed = seed = _generate_seed(RS_SEED_NBYTES)
-            elif seed < 0:
-                raise ValueError('seed < 0')
-            if stream is None:
+
+            if stream is not None:
+                error_msg = 'stream must be a scalar integer 0<=stream<{0}'.format(ub)
+                _stream= np.asarray(stream, dtype=np.object)
+                if _stream.ndim > 0:
+                    raise TypeError(error_msg)
+                elif stream // 1 != stream:
+                    raise TypeError(error_msg)
+                elif stream < 0 or stream >= ub:
+                    raise ValueError(error_msg)
+            else:
                 self.__stream = stream = 1
-            elif stream < 0:
-                raise ValueError('stream < 0')
 
             IF RS_RNG_MOD_NAME == 'pcg64':
                 IF RS_PCG128_EMULATED:
@@ -359,7 +400,7 @@ cdef class RandomState:
                 ELSE:
                     set_seed(&self.rng_state, seed, stream)
             ELSE:
-                set_seed(&self.rng_state, seed, stream)
+                set_seed(&self.rng_state, <uint64_t>seed, <uint64_t>stream)
             self._reset_state_variables()
 
     def _reset_state_variables(self):

randomstate/tests/test_against_numpy.py

@@ -38,17 +38,19 @@ def compare_2_input(f1, f2, is_np=False, is_scalar=False):
               ((np.array([a] * 10), b), {}),
               ((a, np.array([b] * 10)), {}),
               ((a, np.array([b] * 10)), {'size': 10}),
-              ((np.array([[[a]] * 100]), np.array([b] * 10)), {'size': (100, 10)}),
+              ((np.reshape(np.array([[a] * 100]), (100,1)), np.array([b] * 10)), {'size': (100, 10)}),
               ((np.ones((7, 31), dtype=dtype) * a, np.array([b] * 31)), {'size': (7, 31)}),
               ((np.ones((7, 31), dtype=dtype) * a, np.array([b] * 31)), {'size': (10, 7, 31)})]
 
     if is_scalar:
         inputs = inputs[:3]
 
     for i in inputs:
+        print(i[0], i[1])
         v1 = f1(*i[0], **i[1])
         v2 = f2(*i[0], **i[1])
         assert_allclose(v1, v2)
+        print('OK!'*20)
 
 
 def compare_3_input(f1, f2, is_np=False):

randomstate/tests/test_direct.py

@@ -14,7 +14,8 @@
 from randomstate.prng.xorshift128 import xorshift128
 from randomstate.prng.xoroshiro128plus import xoroshiro128plus
 from randomstate.prng.dsfmt import dsfmt
-from numpy.testing import assert_equal, assert_allclose, assert_array_equal
+from numpy.testing import assert_equal, assert_allclose, assert_array_equal, \
+    assert_raises
 
 if (sys.version_info > (3, 0)):
     long = int
@@ -126,10 +127,11 @@ class Base(object):
     data2 = data1 = {}
 
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.RandomState = xorshift128.RandomState
         cls.bits = 64
         cls.dtype = np.uint64
+        cls.seed_error_type = TypeError
 
     @classmethod
     def _read_csv(cls, filename):
@@ -189,86 +191,163 @@ def test_uniform_float(self):
         assert_allclose(uniforms, vals)
         assert_equal(uniforms.dtype, np.float32)
 
+    def test_seed_float(self):
+        # GH #82
+        rs = self.RandomState(*self.data1['seed'])
+        assert_raises(self.seed_error_type, rs.seed, np.pi)
+        assert_raises(self.seed_error_type, rs.seed, -np.pi)
+
+    def test_seed_float_array(self):
+        # GH #82
+        rs = self.RandomState(*self.data1['seed'])
+        assert_raises(self.seed_error_type, rs.seed, np.array([np.pi]))
+        assert_raises(self.seed_error_type, rs.seed, np.array([-np.pi]))
+        assert_raises(self.seed_error_type, rs.seed, np.array([np.pi, -np.pi]))
+        assert_raises(self.seed_error_type, rs.seed, np.array([0, np.pi]))
+        assert_raises(self.seed_error_type, rs.seed, [np.pi])
+        assert_raises(self.seed_error_type, rs.seed, [0, np.pi])
+
+    def test_seed_out_of_range(self):
+        # GH #82
+        rs = self.RandomState(*self.data1['seed'])
+        assert_raises(ValueError, rs.seed, 2 ** (2 * self.bits+1))
+        assert_raises(ValueError, rs.seed, -1)
+
+    def test_seed_out_of_range_array(self):
+        # GH #82
+        rs = self.RandomState(*self.data1['seed'])
+        assert_raises(ValueError, rs.seed, [2 ** (2 * self.bits+1)])
+        assert_raises(ValueError, rs.seed, [-1])
 
 class TestXorshift128(Base, TestCase):
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.RandomState = xorshift128.RandomState
         cls.bits = 64
         cls.dtype = np.uint64
         cls.data1 = cls._read_csv(join(pwd, './data/xorshift128-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/xorshift128-testset-2.csv'))
         cls.uniform32_func = uniform32_from_uint64
+        cls.seed_error_type = TypeError
 
 
 class TestXoroshiro128plus(Base, TestCase):
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.RandomState = xoroshiro128plus.RandomState
         cls.bits = 64
         cls.dtype = np.uint64
         cls.data1 = cls._read_csv(join(pwd, './data/xoroshiro128plus-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/xoroshiro128plus-testset-2.csv'))
-
+        cls.seed_error_type = TypeError
 
 class TestXorshift1024(Base, TestCase):
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.RandomState = xorshift1024.RandomState
         cls.bits = 64
         cls.dtype = np.uint64
         cls.data1 = cls._read_csv(join(pwd, './data/xorshift1024-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/xorshift1024-testset-2.csv'))
-
+        cls.seed_error_type = TypeError
 
 class TestMT19937(Base, TestCase):
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.RandomState = mt19937.RandomState
         cls.bits = 32
         cls.dtype = np.uint32
         cls.data1 = cls._read_csv(join(pwd, './data/randomkit-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/randomkit-testset-2.csv'))
+        cls.seed_error_type = ValueError
+
+    def test_seed_out_of_range(self):
+        # GH #82
+        rs = self.RandomState(*self.data1['seed'])
+        assert_raises(ValueError, rs.seed, 2 ** (self.bits + 1))
+        assert_raises(ValueError, rs.seed, -1)
+        assert_raises(ValueError, rs.seed, 2 ** (2 * self.bits+1))
+
+    def test_seed_out_of_range_array(self):
+        # GH #82
+        rs = self.RandomState(*self.data1['seed'])
+        assert_raises(ValueError, rs.seed, [2 ** (self.bits + 1)])
+        assert_raises(ValueError, rs.seed, [-1])
+        assert_raises(TypeError, rs.seed, [2 ** (2 * self.bits+1)])
+
+    def test_seed_float(self):
+        # GH #82
+        rs = self.RandomState(*self.data1['seed'])
+        assert_raises(TypeError, rs.seed, np.pi)
+        assert_raises(TypeError, rs.seed, -np.pi)
+
+    def test_seed_float_array(self):
+        # GH #82
+        rs = self.RandomState(*self.data1['seed'])
+        assert_raises(TypeError, rs.seed, np.array([np.pi]))
+        assert_raises(TypeError, rs.seed, np.array([-np.pi]))
+        assert_raises(TypeError, rs.seed, np.array([np.pi, -np.pi]))
+        assert_raises(TypeError, rs.seed, np.array([0, np.pi]))
+        assert_raises(TypeError, rs.seed, [np.pi])
+        assert_raises(TypeError, rs.seed, [0, np.pi])
 
 
 class TestPCG32(Base, TestCase):
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.RandomState = pcg32.RandomState
         cls.bits = 32
         cls.dtype = np.uint32
         cls.data1 = cls._read_csv(join(pwd, './data/pcg32-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/pcg32-testset-2.csv'))
+        cls.seed_error_type = TypeError
+
+    def test_seed_out_of_range_array(self):
+        # GH #82
+        rs = self.RandomState(*self.data1['seed'])
+        assert_raises(TypeError, rs.seed, [2 ** (self.bits + 1)])
+        assert_raises(TypeError, rs.seed, [-1])
+        assert_raises(TypeError, rs.seed, [2 ** (2 * self.bits+1)])
 
 
 class TestPCG64(Base, TestCase):
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.RandomState = pcg64.RandomState
         cls.bits = 64
         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
+
+    def test_seed_out_of_range_array(self):
+        # GH #82
+        rs = self.RandomState(*self.data1['seed'])
+        assert_raises(TypeError, rs.seed, [2 ** (self.bits + 1)])
+        assert_raises(TypeError, rs.seed, [-1])
+        assert_raises(TypeError, rs.seed, [2 ** (2 * self.bits+1)])
 
 
 class TestMRG32K3A(Base, TestCase):
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.RandomState = mrg32k3a.RandomState
         cls.bits = 32
         cls.dtype = np.uint32
         cls.data1 = cls._read_csv(join(pwd, './data/mrg32k3a-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/mrg32k3a-testset-2.csv'))
+        cls.seed_error_type = TypeError
 
 
 class TestMLFG(Base, TestCase):
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.RandomState = mlfg_1279_861.RandomState
         cls.bits = 63
         cls.dtype = np.uint64
         cls.data1 = cls._read_csv(join(pwd, './data/mlfg-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/mlfg-testset-2.csv'))
+        cls.seed_error_type = TypeError
 
     def test_raw(self):
         rs = self.RandomState(*self.data1['seed'])
@@ -284,12 +363,13 @@ def test_raw(self):
 
 class TestDSFMT(Base, TestCase):
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.RandomState = dsfmt.RandomState
         cls.bits = 53
         cls.dtype = np.uint64
         cls.data1 = cls._read_csv(join(pwd, './data/dSFMT-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/dSFMT-testset-2.csv'))
+        cls.seed_error_type = TypeError
 
     def test_uniform_double(self):
         rs = self.RandomState(*self.data1['seed'])