TST: Add tests for 32-bit generators and raw data

Add smoke tests for 32 bit uniforms and normals

Author: bashtage

.travis.yml

@@ -53,4 +53,4 @@ install:
 script:
   - nosetests randomstate
   - cd $BUILD_DIR/randomstate
-  - if [ ${PYTHON} = "2.7" ]; then python performance.py; fi
+  - if [ ${PYTHON} = "3.5" ]; then python performance.py; fi

README.rst

@@ -88,7 +88,6 @@ New Functions
 
 -  ``random_entropy`` - Read from the system entropy provider, which is
    commonly used in cryptographic applications
--  ``random_uintegers`` - unsigned integers ``[0, 2**64-1]``
 -  ``random_raw`` - Direct access to the values produced by the
    underlying PRNG. The range of the values returned depends on the
    specifics of the PRNG implementation.

randomstate/performance.py

@@ -3,11 +3,13 @@
 import timeit
 
 import pandas as pd
+import numpy as np
 from numpy.random import RandomState
 
 rs = RandomState()
 
 SETUP = '''
+import numpy as np
 import {mod}.{rng}
 rs = {mod}.{rng}.RandomState()
 rs.random_sample()
@@ -70,6 +72,26 @@ def timer_uniform():
     run_timer(dist, command, None, SETUP, 'Uniforms')
 
 
+def timer_32bit():
+    info = np.iinfo(np.uint32)
+    min, max = info.min, info.max
+    dist = 'randint'
+    command = 'rs.{dist}({min}, {max}+1, 1000000, dtype=np.uint64)'
+    command = command.format(dist='{dist}', min=min, max=max)
+    command_numpy = command
+    run_timer(dist, command, None, SETUP, '32-bit unsigned integers')
+
+
+def timer_64bit():
+    info = np.iinfo(np.uint64)
+    min, max = info.min, info.max
+    dist = 'randint'
+    command = 'rs.{dist}({min}, {max}+1, 1000000, dtype=np.uint64)'
+    command = command.format(dist='{dist}', min=min, max=max)
+    command_numpy = command
+    run_timer(dist, command, None, SETUP, '64-bit unsigned integers')
+
+
 def timer_normal():
     command = 'rs.{dist}(1000000, method="bm")'
     command_numpy = 'rs.{dist}(1000000)'

randomstate/tests/test_direct.py

@@ -14,7 +14,7 @@
 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
+from numpy.testing import assert_equal, assert_allclose, assert_array_equal
 
 if (sys.version_info > (3, 0)):
     long = int
@@ -142,18 +142,14 @@ def _read_csv(cls, filename):
                 data.append(long(line.split(',')[-1]))
             return {'seed': seed, 'data': np.array(data, dtype=cls.dtype)}
 
-    def test_double(self):
+    def test_raw(self):
         rs = self.RandomState(*self.data1['seed'])
-        vals = uniform_from_uint(self.data1['data'], self.bits)
-        uniforms = rs.random_sample(len(vals))
-        assert_allclose(uniforms, vals)
-        assert_equal(uniforms.dtype, np.float64)
+        uints = rs.random_raw(1000)
+        assert_equal(uints, self.data1['data'])
 
         rs = self.RandomState(*self.data2['seed'])
-        vals = uniform_from_uint(self.data2['data'], self.bits)
-        uniforms = rs.random_sample(len(vals))
-        assert_allclose(uniforms, vals)
-        assert_equal(uniforms.dtype, np.float64)
+        uints = rs.random_raw(1000)
+        assert_equal(uints, self.data2['data'])
 
     def test_gauss_inv(self):
         n = 25
@@ -167,7 +163,20 @@ def test_gauss_inv(self):
         assert_allclose(gauss,
                         gauss_from_uint(self.data2['data'], n, self.bits))
 
-    def test_32bit_uniform(self):
+    def test_uniform_double(self):
+        rs = self.RandomState(*self.data1['seed'])
+        vals = uniform_from_uint(self.data1['data'], self.bits)
+        uniforms = rs.random_sample(len(vals))
+        assert_allclose(uniforms, vals)
+        assert_equal(uniforms.dtype, np.float64)
+
+        rs = self.RandomState(*self.data2['seed'])
+        vals = uniform_from_uint(self.data2['data'], self.bits)
+        uniforms = rs.random_sample(len(vals))
+        assert_allclose(uniforms, vals)
+        assert_equal(uniforms.dtype, np.float64)
+
+    def test_uniform_float(self):
         rs = self.RandomState(*self.data1['seed'])
         vals = uniform32_from_uint(self.data1['data'], self.bits)
         uniforms = rs.random_sample(len(vals), dtype=np.float32)
@@ -261,6 +270,17 @@ def setUpClass(cls):
         cls.data1 = cls._read_csv(join(pwd, './data/mlfg-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/mlfg-testset-2.csv'))
 
+    def test_raw(self):
+        rs = self.RandomState(*self.data1['seed'])
+        mod_data = self.data1['data'] >> np.uint64(1)
+        uints = rs.random_raw(1000)
+        assert_equal(uints, mod_data)
+
+        rs = self.RandomState(*self.data2['seed'])
+        mod_data = self.data2['data'] >> np.uint64(1)
+        uints = rs.random_raw(1000)
+        assert_equal(uints, mod_data)
+
 
 class TestDSFMT(Base, TestCase):
     @classmethod
@@ -271,10 +291,11 @@ def setUpClass(cls):
         cls.data1 = cls._read_csv(join(pwd, './data/dSFMT-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/dSFMT-testset-2.csv'))
 
-    def test_double(self):
+    def test_uniform_double(self):
         rs = self.RandomState(*self.data1['seed'])
-        assert_equal(uniform_from_dsfmt(self.data1['data']),
-                     rs.random_sample(1000))
+        aa = uniform_from_dsfmt(self.data1['data'])
+        assert_array_equal(uniform_from_dsfmt(self.data1['data']),
+                           rs.random_sample(1000))
 
         rs = self.RandomState(*self.data2['seed'])
         assert_equal(uniform_from_dsfmt(self.data2['data']),

randomstate/tests/test_smoke.py

@@ -19,7 +19,7 @@
 from randomstate.prng.xorshift128 import xorshift128
 from randomstate.prng.xoroshiro128plus import xoroshiro128plus
 from randomstate.prng.dsfmt import dsfmt
-from numpy.testing import assert_almost_equal, assert_equal, assert_raises, assert_
+from numpy.testing import assert_almost_equal, assert_equal, assert_raises, assert_, assert_array_equal
 
 from nose import SkipTest
 
@@ -84,6 +84,19 @@ def comp_state(state1, state2):
     return identical
 
 
+def warmup(rs, n=None):
+    if n is None:
+        n = 11 + np.random.randint(0, 20)
+    rs.standard_normal(n, method='bm')
+    rs.standard_normal(n, method='zig')
+    rs.standard_normal(n, method='bm', dtype=np.float32)
+    rs.randint(0, 2 ** 24, n, dtype=np.uint64)
+    rs.randint(0, 2 ** 48, n, dtype=np.uint64)
+    rs.standard_gamma(11, n)
+    rs.random_sample(n, dtype=np.float64)
+    rs.random_sample(n, dtype=np.float32)
+
+
 class RNG(object):
     @classmethod
     def _extra_setup(cls):
@@ -121,7 +134,7 @@ def test_jump(self):
 
     def test_random_raw(self):
         assert_(len(self.rs.random_raw(10)) == 10)
-        assert_(self.rs.random_raw((10,10)).shape == (10,10))
+        assert_(self.rs.random_raw((10, 10)).shape == (10, 10))
 
     def test_uniform(self):
         r = self.rs.uniform(-1.0, 0.0, size=10)
@@ -202,17 +215,17 @@ def test_reset_state_gauss(self):
         rs2 = self.mod.RandomState()
         rs2.set_state(state)
         n2 = rs2.standard_normal(size=10)
-        assert_((n1 == n2).all())
+        assert_array_equal(n1, n2)
 
     def test_reset_state_uint32(self):
         rs = self.mod.RandomState(*self.seed)
-        rs.randint(0, 2 ** 24, dtype=np.uint32)
+        rs.randint(0, 2 ** 24, 120, dtype=np.uint32)
         state = rs.get_state()
-        n1 = rs.randint(0, 2**24, 10, dtype=np.uint32)
+        n1 = rs.randint(0, 2 ** 24, 10, dtype=np.uint32)
         rs2 = self.mod.RandomState()
         rs2.set_state(state)
-        n2 = rs.randint(0, 2**24, 10, dtype=np.uint32)
-        assert_((n1 == n2).all())
+        n2 = rs2.randint(0, 2 ** 24, 10, dtype=np.uint32)
+        assert_array_equal(n1, n2)
 
     def test_shuffle(self):
         original = np.arange(200, 0, -1)
@@ -487,10 +500,10 @@ def test_seed_array(self):
     def test_seed_array_error(self):
         if self.seed_vector_bits == 32:
             dtype = np.uint32
-            out_of_bounds = 2**32
+            out_of_bounds = 2 ** 32
         else:
             dtype = np.uint64
-            out_of_bounds = 2**64
+            out_of_bounds = 2 ** 64
 
         seed = -1
         assert_raises(ValueError, self.rs.seed, seed)
@@ -504,6 +517,32 @@ def test_seed_array_error(self):
         seed = np.array([1, 2, 3, out_of_bounds])
         assert_raises(ValueError, self.rs.seed, seed)
 
+    def test_uniform_float(self):
+        rs = self.mod.RandomState(12345)
+        warmup(rs)
+        state = rs.get_state()
+        r1 = rs.random_sample(11, dtype=np.float32)
+        rs2 = self.mod.RandomState()
+        warmup(rs2)
+        rs2.set_state(state)
+        r2 = rs2.random_sample(11, dtype=np.float32)
+        assert_array_equal(r1, r2)
+        assert_equal(r1.dtype, np.float32)
+        assert_(comp_state(rs.get_state(), rs2.get_state()))
+
+    def test_normal_floats(self):
+        rs = self.mod.RandomState()
+        warmup(rs)
+        state = rs.get_state()
+        r1 = rs.standard_normal(11, method='bm', dtype=np.float32)
+        rs2 = self.mod.RandomState()
+        warmup(rs2)
+        rs2.set_state(state)
+        r2 = rs2.standard_normal(11, method='bm', dtype=np.float32)
+        assert_array_equal(r1, r2)
+        assert_equal(r1.dtype, np.float32)
+        assert_(comp_state(rs.get_state(), rs2.get_state()))
+
 
 class TestMT19937(RNG):
     @classmethod
@@ -642,9 +681,3 @@ def test_fallback(self):
         time.sleep(0.1)
         e2 = entropy.random_entropy(source='fallback')
         assert_((e1 != e2))
-
-
-if __name__ == '__main__':
-    import nose
-
-    nose.run(argv=[__file__, '-vv'])