Merge pull request #79 from bashtage/refactor-uintegers

REF: Refactor uintegers

Author: bashtage

randomstate/performance.py

@@ -2,8 +2,8 @@
 import struct
 import timeit
 
-import pandas as pd
 import numpy as np
+import pandas as pd
 from numpy.random import RandomState
 
 rs = RandomState()
@@ -44,7 +44,7 @@ def run_timer(dist, command, numpy_command=None, setup='', random_type=''):
         mod = 'randomstate.prng' if rng != 'random' else 'numpy'
         key = '-'.join((mod, rng, dist)).replace('"', '')
         command = numpy_command if 'numpy' in mod else command
-        res[key] = timer(command.format(dist=dist), setup=setup.format(mod=mod, rng=rng))
+        res[key] = timer(command, setup=setup.format(mod=mod, rng=rng))
 
     s = pd.Series(res)
     t = s.apply(lambda x: '{0:0.2f} ms'.format(x))
@@ -68,41 +68,41 @@ def run_timer(dist, command, numpy_command=None, setup='', random_type=''):
 
 def timer_uniform():
     dist = 'random_sample'
-    command = 'rs.{dist}(1000000)'
+    command = 'rs.random_sample(1000000)'
     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')
+    dist = 'random_uintegers'
+    command = 'rs.random_uintegers(1000000, 32)'
+    command_numpy = 'rs.randint({min}, {max}+1, 1000000, dtype=np.uint32)'
+    command_numpy = command_numpy.format(min=min, max=max)
+    run_timer(dist, command, command_numpy, 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')
+    dist = 'random_uintegers'
+    command = 'rs.random_uintegers(1000000)'
+    command_numpy = 'rs.randint({min}, {max}+1, 1000000, dtype=np.uint64)'
+    command_numpy = command_numpy.format(min=min, max=max)
+    run_timer(dist, command, command_numpy, SETUP, '64-bit unsigned integers')
 
 
 def timer_normal():
-    command = 'rs.{dist}(1000000, method="bm")'
-    command_numpy = 'rs.{dist}(1000000)'
     dist = 'standard_normal'
+    command = 'rs.standard_normal(1000000, method="bm")'
+    command_numpy = 'rs.standard_normal(1000000)'
     run_timer(dist, command, command_numpy, SETUP, 'Box-Muller normals')
 
 
 def timer_normal_zig():
-    command = 'rs.{dist}(1000000, method="zig")'
-    command_numpy = 'rs.{dist}(1000000)'
     dist = 'standard_normal'
+    command = 'rs.standard_normal(1000000, method="zig")'
+    command_numpy = 'rs.standard_normal(1000000)'
     run_timer(dist, command, command_numpy, SETUP, 'Standard normals (Ziggurat)')
 
 

randomstate/randomstate.pyx

@@ -633,34 +633,36 @@ cdef class RandomState:
         These should not be used to produce bounded random numbers by
         simple truncation.
         """
-        cdef uint32_t [:] randoms32
-        cdef uint64_t [:] randoms64
-        cdef aug_state* rng_state
-        cdef Py_ssize_t i, n
-        rng_state = &self.rng_state
+        cdef np.npy_intp i, n
+        cdef np.ndarray array
+        cdef uint32_t* data32
+        cdef uint64_t* data64
+        cdef aug_state* rng_state = &self.rng_state
         if bits == 64:
             if size is None:
                 with self.lock:
                     return random_uint64(rng_state)
-            n = compute_numel(size)
-            randoms64 = np.empty(n, np.uint64)
+            array = <np.ndarray>np.empty(size, np.uint64)
+            n = np.PyArray_SIZE(array)
+            data64 = <uint64_t *>np.PyArray_DATA(array)
             with self.lock, nogil:
                 for i in range(n):
-                    randoms64[i] = random_uint64(rng_state)
-            return np.asarray(randoms64).reshape(size)
+                    data64[i] = random_uint64(rng_state)
         elif bits == 32:
             if size is None:
                 with self.lock:
                     return random_uint32(rng_state)
-            n = compute_numel(size)
-            randoms32 = np.empty(n, np.uint32)
+            array = <np.ndarray>np.empty(size, np.uint32)
+            n = np.PyArray_SIZE(array)
+            data32 = <uint32_t *>np.PyArray_DATA(array)
             with self.lock, nogil:
                 for i in range(n):
-                    randoms32[i] = random_uint32(rng_state)
-            return np.asarray(randoms32).reshape(size)
+                    data32[i] = random_uint32(rng_state)
         else:
             raise ValueError('Unknown value of bits.  Must be either 32 or 64.')
 
+        return array
+
     def random_raw(self, size=None):
         """
         random_raw(self, size=None)