STY: Clean up code

Pep8 fixes
Remove unused imports
Fix name error

benchmarks/benchmarks/bench_random.py

@@ -89,37 +89,37 @@ class RNG(Benchmark):
     params = ['DSFMT', 'PCG64', 'PCG32', 'MT19937', 'Xoshiro256',
               'Xoshiro512', 'Philox', 'ThreeFry', 'numpy']
 
-    def setup(self, brng):
-        if brng == 'numpy':
+    def setup(self, bitgen):
+        if bitgen == 'numpy':
             self.rg = np.random.RandomState()
         else:
-            self.rg = Generator(getattr(np.random, brng)())
+            self.rg = Generator(getattr(np.random, bitgen)())
         self.rg.random()
         self.int32info = np.iinfo(np.int32)
         self.uint32info = np.iinfo(np.uint32)
         self.uint64info = np.iinfo(np.uint64)
 
-    def time_raw(self, brng):
-        if brng == 'numpy':
+    def time_raw(self, bitgen):
+        if bitgen == 'numpy':
             self.rg.random_integers(self.int32info.max, size=nom_size)
         else:
             self.rg.integers(self.int32info.max, size=nom_size, endpoint=True)
 
-    def time_32bit(self, brng):
+    def time_32bit(self, bitgen):
         min, max = self.uint32info.min, self.uint32info.max
-        if brng == 'numpy':
+        if bitgen == 'numpy':
             self.rg.randint(min, max + 1, nom_size, dtype=np.uint32)
         else:
             self.rg.integers(min, max + 1, nom_size, dtype=np.uint32)
 
-    def time_64bit(self, brng):
+    def time_64bit(self, bitgen):
         min, max = self.uint64info.min, self.uint64info.max
-        if brng == 'numpy':
+        if bitgen == 'numpy':
             self.rg.randint(min, max + 1, nom_size, dtype=np.uint64)
         else:
             self.rg.integers(min, max + 1, nom_size, dtype=np.uint64)
 
-    def time_normal_zig(self, brng):
+    def time_normal_zig(self, bitgen):
         self.rg.standard_normal(nom_size)
 
 class Bounded(Benchmark):
@@ -146,14 +146,14 @@ class Bounded(Benchmark):
                [u64, 2047],  # Best case for legacy
              ]]
 
-    def setup(self, brng, args):
-        if brng == 'numpy':
+    def setup(self, bitgen, args):
+        if bitgen == 'numpy':
             self.rg = np.random.RandomState()
         else:
-            self.rg = Generator(getattr(np.random, brng)())
+            self.rg = Generator(getattr(np.random, bitgen)())
         self.rg.random()
 
-    def time_bounded(self, brng, args):
+    def time_bounded(self, bitgen, args):
             """
             Timer for 8-bit bounded values.
 
@@ -165,7 +165,7 @@ def time_bounded(self, brng, args):
                 Upper bound for range. Lower is always 0.  Must be <= 2**bits.
             """
             dt, max = args
-            if brng == 'numpy':
+            if bitgen == 'numpy':
                 self.rg.randint(0, max + 1, nom_size, dtype=dt)
             else:
                 self.rg.integers(0, max + 1, nom_size, dtype=dt)

numpy/random/__init__.py

@@ -173,13 +173,14 @@
 from .xoshiro512 import Xoshiro512
 from .mtrand import RandomState
 
-__all__ += ['Generator', 'DSFMT', 'MT19937', 'Philox','PCG64', 'PCG32',
-           'ThreeFry', 'Xoshiro256', 'Xoshiro512', 'RandomState']
+__all__ += ['Generator', 'DSFMT', 'MT19937', 'Philox', 'PCG64', 'PCG32',
+            'ThreeFry', 'Xoshiro256', 'Xoshiro512', 'RandomState']
 
 # Some aliases:
 ranf = random = sample = random_sample
 __all__.extend(['ranf', 'random', 'sample'])
 
+
 def __RandomState_ctor():
     """Return a RandomState instance.
 
@@ -195,6 +196,7 @@ def __RandomState_ctor():
     """
     return RandomState(seed=0)
 
+
 from numpy._pytesttester import PytestTester
 test = PytestTester(__name__)
 del PytestTester

numpy/random/_pickle.py

@@ -38,7 +38,8 @@ def __generator_ctor(bit_generator_name='mt19937'):
     if bit_generator_name in BitGenerators:
         bit_generator = BitGenerators[bit_generator_name]
     else:
-        raise ValueError(str(bit_generator_name) + ' is not a known BitGenerator module.')
+        raise ValueError(str(bit_generator_name) + ' is not a known '
+                                                   'BitGenerator module.')
 
     return Generator(bit_generator())
 
@@ -60,10 +61,12 @@ def __bit_generator_ctor(bit_generator_name='mt19937'):
     if bit_generator_name in BitGenerators:
         bit_generator = BitGenerators[bit_generator_name]
     else:
-        raise ValueError(str(bit_generator_name) + ' is not a known BitGenerator module.')
+        raise ValueError(str(bit_generator_name) + ' is not a known '
+                                                   'BitGenerator module.')
 
     return bit_generator()
 
+
 def __randomstate_ctor(bit_generator_name='mt19937'):
     """
     Pickling helper function that returns a legacy RandomState-like object
@@ -81,6 +84,7 @@ def __randomstate_ctor(bit_generator_name='mt19937'):
     if bit_generator_name in BitGenerators:
         bit_generator = BitGenerators[bit_generator_name]
     else:
-        raise ValueError(str(bit_generator_name) + ' is not a known BitGenerator module.')
+        raise ValueError(str(bit_generator_name) + ' is not a known '
+                                                   'BitGenerator module.')
 
     return RandomState(bit_generator())

numpy/random/common.pyx

@@ -45,6 +45,10 @@ cdef object random_raw(bitgen_t *bitgen, object lock, object size, object output
 
     Parameters
     ----------
+    bitgen : BitGenerator
+        Address of the bit generator struct
+    lock : Threading.Lock
+        Lock provided by the bit generator
     size : int or tuple of ints, optional
         Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
         ``m * n * k`` samples are drawn.  Default is None, in which case a

numpy/random/distributions.pxd

@@ -1,7 +1,7 @@
 #cython: language_level=3
 
 from libc.stdint cimport (uint8_t, uint16_t, uint32_t, uint64_t,
-                          int8_t, int16_t, int32_t, int64_t, intptr_t)
+                          int32_t, int64_t)
 import numpy as np
 cimport numpy as np
 

numpy/random/dsfmt.pyx

@@ -1,6 +1,5 @@
 import operator
 from cpython.pycapsule cimport PyCapsule_New
-from libc.string cimport memcpy
 
 try:
     from threading import Lock

numpy/random/examples/numba/extending_distributions.py

@@ -5,7 +5,8 @@
     ${PYTHON_HOME}/include/python${PYTHON_VERSION}m
 export NUMPY_INCLUDE=#path to numpy's include folder, usually \
     ${PYTHON_HOME}/lib/python${PYTHON_VERSION}/site-packages/numpy/core/include
-gcc -shared -o libdistributions.so -fPIC distributions.c -I${NUMPY_INCLUDE} -I${PYTHON_INCLUDE}
+gcc -shared -o libdistributions.so -fPIC distributions.c \
+    -I${NUMPY_INCLUDE} -I${PYTHON_INCLUDE}
 mv libdistributions.so ../../examples/numba/
 
 On Windows

numpy/random/generator.pyx

@@ -3872,7 +3872,7 @@ cdef class Generator:
                [3, 4, 5]])
 
         """
-        if isinstance(x, (int, long, np.integer)):
+        if isinstance(x, (int, np.integer)):
             arr = np.arange(x)
             self.shuffle(arr)
             return arr

numpy/random/mtrand.pyx

@@ -3704,7 +3704,7 @@ cdef class RandomState:
         cov = np.array(cov)
         if size is None:
             shape = []
-        elif isinstance(size, (int, long, np.integer)):
+        elif isinstance(size, (int, np.integer)):
             shape = [size]
         else:
             shape = size
@@ -4134,7 +4134,7 @@ cdef class RandomState:
                [3, 4, 5]])
 
         """
-        if isinstance(x, (int, long, np.integer)):
+        if isinstance(x, (int, np.integer)):
             arr = np.arange(x)
             self.shuffle(arr)
             return arr

numpy/random/tests/test_direct.py

@@ -1,14 +1,13 @@
 import os
-import sys
 from os.path import join
 
 import numpy as np
 from numpy.testing import (assert_equal, assert_allclose, assert_array_equal,
-                           assert_raises, assert_warns)
+                           assert_raises)
 import pytest
 
-from numpy.random import (Generator, MT19937, DSFMT, ThreeFry,
-    PCG32, PCG64, Philox, Xoshiro256, Xoshiro512, RandomState)
+from numpy.random import (Generator, MT19937, DSFMT, ThreeFry, PCG32, PCG64,
+                          Philox, Xoshiro256, Xoshiro512, RandomState)
 from numpy.random.common import interface
 
 try:
@@ -25,9 +24,6 @@
 except ImportError:
     MISSING_CTYPES = False
 
-if (sys.version_info > (3, 0)):
-    long = int
-
 pwd = os.path.dirname(os.path.abspath(__file__))
 
 
@@ -102,7 +98,7 @@ def gauss_from_uint(x, n, bits):
         doubles = uniform_from_uint64(x)
     elif bits == 32:
         doubles = uniform_from_uint32(x)
-    elif bits == 'dsfmt':
+    else:  # bits == 'dsfmt'
         doubles = uniform_from_dsfmt(x)
     gauss = []
     loc = 0
@@ -140,10 +136,10 @@ def _read_csv(cls, filename):
         with open(filename) as csv:
             seed = csv.readline()
             seed = seed.split(',')
-            seed = [long(s.strip(), 0) for s in seed[1:]]
+            seed = [int(s.strip(), 0) for s in seed[1:]]
             data = []
             for line in csv:
-                data.append(long(line.split(',')[-1].strip(), 0))
+                data.append(int(line.split(',')[-1].strip(), 0))
             return {'seed': seed, 'data': np.array(data, dtype=cls.dtype)}
 
     def test_raw(self):
@@ -213,23 +209,28 @@ def test_seed_float(self):
     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(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,
+                      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,
+                      [2 ** (2 * self.bits + 1)])
         assert_raises(ValueError, rs.bit_generator.seed, [-1])
 
     def test_repr(self):
@@ -248,8 +249,8 @@ def test_pickle(self):
 
         bit_generator = self.bit_generator(*self.data1['seed'])
         state = bit_generator.state
-        brng_pkl = pickle.dumps(bit_generator)
-        reloaded = pickle.loads(brng_pkl)
+        bitgen_pkl = pickle.dumps(bit_generator)
+        reloaded = pickle.loads(bitgen_pkl)
         reloaded_state = reloaded.state
         assert_array_equal(Generator(bit_generator).standard_normal(1000),
                            Generator(reloaded).standard_normal(1000))
@@ -264,7 +265,7 @@ def test_invalid_state_type(self):
     def test_invalid_state_value(self):
         bit_generator = self.bit_generator(*self.data1['seed'])
         state = bit_generator.state
-        state['bit_generator'] = 'otherBRNG'
+        state['bit_generator'] = 'otherBitGenerator'
         with pytest.raises(ValueError):
             bit_generator.state = state
 
@@ -359,7 +360,7 @@ def test_set_key(self):
         bit_generator = self.bit_generator(*self.data1['seed'])
         state = bit_generator.state
         keyed = self.bit_generator(counter=state['state']['counter'],
-                          key=state['state']['key'])
+                                   key=state['state']['key'])
         assert_state_equal(bit_generator.state, keyed.state)
 
 
@@ -382,11 +383,10 @@ def test_set_key(self):
         bit_generator = self.bit_generator(*self.data1['seed'])
         state = bit_generator.state
         keyed = self.bit_generator(counter=state['state']['counter'],
-                          key=state['state']['key'])
+                                   key=state['state']['key'])
         assert_state_equal(bit_generator.state, keyed.state)
 
 
-
 class TestPCG64(Base):
     @classmethod
     def setup_class(cls):
@@ -453,14 +453,17 @@ def test_seed_out_of_range(self):
         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))
+        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,
+                      [2 ** (self.bits + 1)])
         assert_raises(ValueError, rs.bit_generator.seed, [-1])
-        assert_raises(TypeError, rs.bit_generator.seed, [2 ** (2 * self.bits + 1)])
+        assert_raises(TypeError, rs.bit_generator.seed,
+                      [2 ** (2 * self.bits + 1)])
 
     def test_seed_float(self):
         # GH #82
@@ -484,7 +487,8 @@ def test_state_tuple(self):
         bit_generator = rs.bit_generator
         state = bit_generator.state
         desired = rs.integers(2 ** 16)
-        tup = (state['bit_generator'], state['state']['key'], state['state']['pos'])
+        tup = (state['bit_generator'], state['state']['key'],
+               state['state']['pos'])
         bit_generator.state = tup
         actual = rs.integers(2 ** 16)
         assert_equal(actual, desired)
@@ -531,9 +535,11 @@ def test_gauss_inv(self):
     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,
+                      [2 ** (self.bits + 1)])
         assert_raises(ValueError, rs.bit_generator.seed, [-1])
-        assert_raises(TypeError, rs.bit_generator.seed, [2 ** (2 * self.bits + 1)])
+        assert_raises(TypeError, rs.bit_generator.seed,
+                      [2 ** (2 * self.bits + 1)])
 
     def test_seed_float(self):
         # GH #82
@@ -546,7 +552,8 @@ def test_seed_float_array(self):
         rs = Generator(self.bit_generator(*self.data1['seed']))
         assert_raises(TypeError, rs.bit_generator.seed, np.array([np.pi]))
         assert_raises(TypeError, rs.bit_generator.seed, np.array([-np.pi]))
-        assert_raises(TypeError, rs.bit_generator.seed, np.array([np.pi, -np.pi]))
+        assert_raises(TypeError, 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])