UPD: Update to latest NumPy changes

Docstring changes from upstream
Ensure lock used whenever a random number is generated
Change boolean types
Fix bug in dSFMT raw which returned pointer instead of value

Author: Sheppard, Kevin

randomstate/array_utilities.pxi

@@ -254,14 +254,15 @@ cdef object cont(aug_state* state, void* func, object size, object lock, int nar
             check_constraint(_c, c_name, c_constraint)
 
     if size is None:
-        if narg == 0:
-            return (<random_double_0>func)(state)
-        elif narg == 1:
-            return (<random_double_1>func)(state, _a)
-        elif narg == 2:
-            return (<random_double_2>func)(state, _a, _b)
-        elif narg == 3:
-            return (<random_double_3>func)(state, _a, _b, _c)
+        with lock:
+            if narg == 0:
+                return (<random_double_0>func)(state)
+            elif narg == 1:
+                return (<random_double_1>func)(state, _a)
+            elif narg == 2:
+                return (<random_double_2>func)(state, _a, _b)
+            elif narg == 3:
+                return (<random_double_3>func)(state, _a, _b, _c)
 
     cdef np.npy_intp i, n = compute_numel(size)
     cdef np.ndarray randoms = np.empty(n, np.double)
@@ -541,20 +542,21 @@ cdef object disc(aug_state* state, void* func, object size, object lock,
                 check_constraint(<double>_ic, c_name, c_constraint)
 
     if size is None:
-        if narg_long == 0:
-            if narg_double == 0:
-                return (<random_uint_0>func)(state)
-            elif narg_double == 1:
-                return (<random_uint_d>func)(state, _da)
-            elif narg_double == 2:
-                return (<random_uint_dd>func)(state, _da, _db)
-        elif narg_long == 1:
-            if narg_double == 0:
-                return (<random_uint_i>func)(state, _ia)
-            if narg_double == 1:
-                return (<random_uint_di>func)(state, _da, _ib)
-        else:
-            return (<random_uint_iii>func)(state, _ia, _ib, _ic)
+        with lock:
+            if narg_long == 0:
+                if narg_double == 0:
+                    return (<random_uint_0>func)(state)
+                elif narg_double == 1:
+                    return (<random_uint_d>func)(state, _da)
+                elif narg_double == 2:
+                    return (<random_uint_dd>func)(state, _da, _db)
+            elif narg_long == 1:
+                if narg_double == 0:
+                    return (<random_uint_i>func)(state, _ia)
+                if narg_double == 1:
+                    return (<random_uint_di>func)(state, _da, _ib)
+            else:
+                return (<random_uint_iii>func)(state, _ia, _ib, _ic)
 
     cdef np.npy_intp i, n = compute_numel(size)
     cdef np.int_t [::1] randoms = np.empty(n, np.int)

randomstate/bounded_integers.pxi

@@ -207,23 +207,22 @@ cdef object _rand_uint8(low, high, size, aug_state *state, lock):
             random_bounded_uint8_fill(state, off, rng, cnt, out)
         return array
 
-# TODO: Needs to change types
 cdef object _rand_bool(low, high, size, aug_state *state, lock):
-    cdef int8_t off, rng, buf
-    cdef int8_t *out
+    cdef np.npy_bool off, rng, buf
+    cdef np.npy_bool *out
     cdef np.ndarray array
     cdef np.npy_intp cnt
 
-    rng = <uint8_t>(high - low)
-    off = <uint8_t>low
+    rng = <np.npy_bool>(high - low)
+    off = <np.npy_bool>low
     if size is None:
         with lock:
             random_bool_fill(state, off, rng, 1, &buf)
         return np.bool_(<np.npy_bool>buf)
     else:
         array = <np.ndarray>np.empty(size, np.bool)
         cnt = np.PyArray_SIZE(array)
-        out = <int8_t *>np.PyArray_DATA(array)
+        out = <np.npy_bool *>np.PyArray_DATA(array)
         with lock, nogil:
             random_bool_fill(state, off, rng, cnt, out)
         return array

randomstate/distributions.c

@@ -1579,8 +1579,7 @@ void random_bounded_uint8_fill(aug_state *state, uint8_t off, uint8_t rng, npy_i
  * Fills an array with cnt random npy_bool between off and off + rng
  * inclusive.
  */
-/* TODO: This needs to use bools. See original */
-void random_bool_fill(aug_state *state, int8_t off, int8_t rng, npy_intp cnt, int8_t *out)
+void random_bool_fill(aug_state *state, npy_bool off, npy_bool rng, npy_intp cnt, npy_bool *out)
 {
     int i;
     uint32_t buf = 0;

randomstate/distributions.h

@@ -134,7 +134,7 @@ extern void random_bounded_uint16_fill(aug_state *state, uint16_t off, uint16_t
 
 extern void random_bounded_uint8_fill(aug_state *state, uint8_t off, uint8_t rng, npy_intp cnt, uint8_t *out);
 
-extern void random_bool_fill(aug_state *state, int8_t off, int8_t rng, npy_intp cnt, int8_t *out);
+extern void random_bool_fill(aug_state *state, npy_bool off, npy_bool rng, npy_intp cnt, npy_bool *out);
 
 extern void random_uniform_fill(aug_state* state, npy_intp count, double *out);
 

randomstate/interface/dSFMT/dSFMT-shim.h

@@ -67,7 +67,7 @@ static inline double random_double(aug_state* state)
 static inline uint64_t random_raw_values(aug_state* state)
 {
     double d = random_double_from_buffer(state);
-    return (uint64_t *)&d;
+    return *((uint64_t *)&d);
 }
 
 

randomstate/randomstate.pyx

@@ -111,7 +111,7 @@ cdef extern from "distributions.h":
     cdef void random_bounded_uint32_fill(aug_state *state, uint32_t off, uint32_t rng, intptr_t cnt,uint32_t *out) nogil
     cdef void random_bounded_uint16_fill(aug_state *state, uint16_t off, uint16_t rng, intptr_t cnt, uint16_t *out) nogil
     cdef void random_bounded_uint8_fill(aug_state *state, uint8_t off, uint8_t rng, intptr_t cnt, uint8_t *out) nogil
-    cdef void random_bool_fill(aug_state *state, int8_t off, int8_t rng, intptr_t cnt, int8_t *out) nogil
+    cdef void random_bool_fill(aug_state *state, np.npy_bool off, np.npy_bool rng, intptr_t cnt, np.npy_bool *out) nogil
     cdef void random_uniform_fill(aug_state *state, intptr_t cnt, double *out) nogil
     cdef void random_standard_exponential_fill(aug_state* state, intptr_t count, double *out) nogil
     cdef void random_gauss_fill(aug_state* state, intptr_t count, double *out) nogil
@@ -580,24 +580,28 @@ cdef class RandomState:
         """
         cdef uint32_t [:] randoms32
         cdef uint64_t [:] randoms64
+        cdef aug_state* rng_state
         cdef Py_ssize_t i, n
+        rng_state = &self.rng_state
         if bits == 64:
             if size is None:
-                return random_uint64(&self.rng_state)
+                with self.lock:
+                    return random_uint64(rng_state)
             n = compute_numel(size)
             randoms64 = np.empty(n, np.uint64)
             with self.lock, nogil:
                 for i in range(n):
-                    randoms64[i] = random_uint64(&self.rng_state)
+                    randoms64[i] = random_uint64(rng_state)
             return np.asarray(randoms64).reshape(size)
         elif bits == 32:
             if size is None:
-                return random_uint32(&self.rng_state)
+                with self.lock:
+                    return random_uint32(rng_state)
             n = compute_numel(size)
             randoms32 = np.empty(n, np.uint32)
             with self.lock, nogil:
                 for i in range(n):
-                    randoms32[i] = random_uint32(&self.rng_state)
+                    randoms32[i] = random_uint32(rng_state)
             return np.asarray(randoms32).reshape(size)
         else:
             raise ValueError('Unknown value of bits.  Must be either 32 or 64.')
@@ -631,17 +635,20 @@ cdef class RandomState:
         cdef np.ndarray randoms
         cdef uint64_t *randoms_data
         cdef Py_ssize_t i, n
+        cdef aug_state* rng_state
+        rng_state = &self.rng_state
 
         if size is None:
-            return random_raw_values(&self.rng_state)
+            with self.lock:
+                return random_raw_values(rng_state)
 
         randoms = <np.ndarray>np.empty(size, np.uint64)
         randoms_data = <uint64_t*>np.PyArray_DATA(randoms)
         n = np.PyArray_SIZE(randoms)
 
         with self.lock, nogil:
             for i in range(n):
-                randoms_data[i] = random_raw_values(&self.rng_state)
+                randoms_data[i] = random_raw_values(rng_state)
         return randoms
 
     # Pickling support:
@@ -749,16 +756,20 @@ cdef class RandomState:
         cdef np.npy_intp n
         cdef np.ndarray randoms
         cdef long *randoms_data
+        cdef aug_state* rng_state
+        rng_state = &self.rng_state
 
         if size is None:
-            return random_positive_int(&self.rng_state)
+            with self.lock:
+                return random_positive_int(rng_state)
 
         randoms = <np.ndarray>np.empty(size, dtype=np.int)
         randoms_data = <long*>np.PyArray_DATA(randoms)
         n = np.PyArray_SIZE(randoms)
 
         for i in range(n):
-            randoms_data[i] = random_positive_int(&self.rng_state)
+            with self.lock, nogil:
+                randoms_data[i] = random_positive_int(rng_state)
         return randoms
 
     def randint(self, low, high=None, size=None, dtype=int):
@@ -4239,6 +4250,10 @@ cdef class RandomState:
 
         Modify a sequence in-place by shuffling its contents.
 
+        This function only shuffles the array along the first axis of a
+        multi-dimensional array. The order of sub-arrays is changed but
+        their contents remains the same.
+
         Parameters
         ----------
         x : array_like
@@ -4255,8 +4270,7 @@ cdef class RandomState:
         >>> arr
         [1 7 5 2 9 4 3 6 0 8]
 
-        This function only shuffles the array along the first index of a
-        multi-dimensional array:
+        Multi-dimensional arrays are only shuffled along the first axis:
 
         >>> arr = np.arange(9).reshape((3, 3))
         >>> np.random.shuffle(arr)