REF: Update to include bool in combined generator

Add bool to combined generator

Author: bashtage

randomstate/bounded_integers.pxi.in

@@ -100,7 +100,7 @@ py:
 bc_ctypes = (('uint32', 'uint32', 'uint64', 'NPY_UINT64', 0, 0, 0, '0X100000000ULL'),
           ('uint16', 'uint16', 'uint32', 'NPY_UINT32', 1, 16, 0, '0X10000UL'),
           ('uint8', 'uint8', 'uint16', 'NPY_UINT16', 3, 8, 0, '0X100UL'),
-          ('bool','uint8', 'uint8', 'NPY_UINT8', 31, 1, 0, '0x2UL'),
+          ('bool','bool', 'uint8', 'NPY_UINT8', 31, 1, 0, '0x2UL'),
           ('int32', 'uint32', 'uint64', 'NPY_INT64', 0, 0, '-0x80000000LL', '0x80000000LL'),
           ('int16', 'uint16', 'uint32', 'NPY_INT32', 1, 16, '-0x8000LL', '0x8000LL' ),
           ('int8', 'uint8', 'uint16', 'NPY_INT16', 3, 8, '-0x80LL', '0x80LL' ),
@@ -145,11 +145,11 @@ cdef object _rand_{{nptype}}_combined(object low, object high, object size, aug_
           distribution, or a single such random int if `size` not provided.
 
     """
-    cdef {{utype}}_t off, val, mask
+    cdef {{utype}}_t rng, last_rng, off, val, mask, out_val
     cdef uint32_t buf
     cdef {{utype}}_t *out
     cdef {{utype}}_t *out_data
-    cdef {{nptype_up}}_t rng, last_rng, low_v, high_v
+    cdef {{nptype_up}}_t low_v, high_v
     cdef np.ndarray low_arr, high_arr, out_arr
     cdef np.npy_intp i, cnt
     cdef np.broadcast it
@@ -174,8 +174,8 @@ cdef object _rand_{{nptype}}_combined(object low, object high, object size, aug_
         off = <{{utype}}_t>(<{{nptype}}_t>low)
         if size is None:
             with lock:
-                random_bounded_{{utype}}_fill(state, off, rng, 1, out)
-            return np.{{otype}}(<{{nptype}}_t>out[0])
+                random_bounded_{{utype}}_fill(state, off, rng, 1, &out_val)
+            return np.{{otype}}(<{{nptype}}_t>out_val)
         else:
             out_arr = <np.ndarray>np.empty(size, np.{{nptype}})
             cnt = np.PyArray_SIZE(out_arr)
@@ -211,14 +211,14 @@ cdef object _rand_{{nptype}}_combined(object low, object high, object size, aug_
         for i in range(n):
             low_v = (<{{nptype_up}}_t*>np.PyArray_MultiIter_DATA(it, 0))[0]
             high_v = (<{{nptype_up}}_t*>np.PyArray_MultiIter_DATA(it, 1))[0]
-            rng = (high_v - 1) - low_v
+            rng = <{{utype}}_t>((high_v - 1) - low_v)
             off = <{{utype}}_t>(<{{nptype_up}}_t>low_v)
 
             if rng != last_rng:
                 # Smallest bit mask >= max
                 mask = <{{utype}}_t>_gen_mask(rng)
 
-            out[i] = random_buffered_bounded_{{utype}}(state, off, rng, mask, &buf_rem, &buf)
+            out_data[i] = random_buffered_bounded_{{utype}}(state, off, rng, mask, &buf_rem, &buf)
 
             np.PyArray_MultiIter_NEXT(it)
 

randomstate/distributions.c

@@ -1403,7 +1403,7 @@ static inline uint64_t gen_mask(uint64_t max)
  */
 
 
-inline uint64_t random_bounded_uint64(aug_state *state, uint64_t off, uint64_t rng, uint64_t mask)
+static inline uint64_t bounded_uint64(aug_state *state, uint64_t off, uint64_t rng, uint64_t mask)
 {
     uint64_t val;
     if (rng == 0)
@@ -1418,8 +1418,13 @@ inline uint64_t random_bounded_uint64(aug_state *state, uint64_t off, uint64_t r
     return  off + val;
 }
 
+uint64_t random_bounded_uint64(aug_state *state, uint64_t off, uint64_t rng, uint64_t mask)
+{
+    return bounded_uint64(state, off, rng, mask);
+}
 
-inline uint32_t random_buffered_bounded_uint32(aug_state *state, uint32_t off, uint32_t rng, uint32_t mask, int *bcnt, uint32_t *buf)
+
+static inline uint32_t bounded_uint32(aug_state *state, uint32_t off, uint32_t rng, uint32_t mask)
 {
     /*
      * The buffer and buffer count are not used here but are included to allow
@@ -1435,7 +1440,15 @@ inline uint32_t random_buffered_bounded_uint32(aug_state *state, uint32_t off, u
     return off + val;
 }
 
-inline uint16_t random_buffered_bounded_uint16(aug_state *state, uint16_t off, uint16_t rng, uint16_t mask, int *bcnt, uint32_t *buf)
+uint32_t random_buffered_bounded_uint32(aug_state *state, uint32_t off, uint32_t rng, uint32_t mask, int *bcnt, uint32_t *buf)
+{
+    /*
+     *  Unused bcnt and buf are here only to allow templating with other uint generators
+     */
+    return bounded_uint32(state, off, rng, mask);
+}
+
+static inline buffered_bounded_uint16(aug_state *state, uint16_t off, uint16_t rng, uint16_t mask, int *bcnt, uint32_t *buf)
 {
     uint16_t val;
     if (rng == 0)
@@ -1455,7 +1468,12 @@ inline uint16_t random_buffered_bounded_uint16(aug_state *state, uint16_t off, u
     return  off + val;
 }
 
-inline uint8_t random_buffered_bounded_uint8(aug_state *state, uint8_t off, uint8_t rng, uint8_t mask, int *bcnt, uint32_t *buf)
+uint16_t random_buffered_bounded_uint16(aug_state *state, uint16_t off, uint16_t rng, uint16_t mask, int *bcnt, uint32_t *buf)
+{
+    return buffered_bounded_uint16(state, off, rng, mask, bcnt, buf);
+}
+
+static inline uint8_t buffered_bounded_uint8(aug_state *state, uint8_t off, uint8_t rng, uint8_t mask, int *bcnt, uint32_t *buf)
 {
     uint8_t val;
     if (rng == 0)
@@ -1474,6 +1492,31 @@ inline uint8_t random_buffered_bounded_uint8(aug_state *state, uint8_t off, uint
     return  off + val;
 }
 
+uint8_t random_buffered_bounded_uint8(aug_state *state, uint8_t off, uint8_t rng, uint8_t mask, int *bcnt, uint32_t *buf)
+{
+    return buffered_bounded_uint8(state, off, rng, mask, bcnt, buf);
+}
+
+static inline npy_bool buffered_bounded_bool(aug_state *state, npy_bool off, npy_bool rng, npy_bool mask, int *bcnt, uint32_t *buf)
+{
+    if (rng == 0)
+        return off;
+    if (!(bcnt[0])) {
+        buf[0] = random_uint32(state);
+        bcnt[0] = 31;
+    }
+    else {
+        buf[0] >>= 1;
+        bcnt[0] -= 1;
+    }
+    return (buf[0] & 0x00000001UL) != 0;
+}
+
+npy_bool random_buffered_bounded_bool(aug_state *state, npy_bool off, npy_bool rng, npy_bool mask, int *bcnt, uint32_t *buf)
+{
+    return buffered_bounded_bool(state, off, rng, mask, bcnt, buf);
+}
+
 void random_bounded_uint64_fill(aug_state *state, uint64_t off, uint64_t rng, npy_intp cnt, uint64_t *out)
 {
     uint64_t mask;
@@ -1482,7 +1525,7 @@ void random_bounded_uint64_fill(aug_state *state, uint64_t off, uint64_t rng, np
     /* Smallest bit mask >= max */
     mask = gen_mask(rng);
     for (i = 0; i < cnt; i++) {
-        out[i] = random_bounded_uint64(state, off, rng, mask);
+        out[i] = bounded_uint64(state, off, rng, mask);
     }
 }
 
@@ -1493,15 +1536,15 @@ void random_bounded_uint64_fill(aug_state *state, uint64_t off, uint64_t rng, np
  */
 void random_bounded_uint32_fill(aug_state *state, uint32_t off, uint32_t rng, npy_intp cnt, uint32_t *out)
 {
-    uint32_t val, mask;
+    uint32_t    mask;
     npy_intp i;
     uint32_t buf = 0;
     int bcnt = 0;
 
     /* Smallest bit mask >= max */
     mask = (uint32_t)gen_mask(rng);
     for (i = 0; i < cnt; i++) {
-        out[i] =  random_buffered_bounded_uint32(state, off, rng, mask, &bcnt, &buf);
+        out[i] =  bounded_uint32(state, off, rng, mask, &bcnt, &buf);
     }
 }
 
@@ -1520,7 +1563,7 @@ void random_bounded_uint16_fill(aug_state *state, uint16_t off, uint16_t rng, np
     /* Smallest bit mask >= max */
     mask = (uint16_t)gen_mask(rng);
     for (i = 0; i < cnt; i++) {
-        out[i] = random_buffered_bounded_uint16(state, off, rng, mask, &bcnt, &buf);
+        out[i] = buffered_bounded_uint16(state, off, rng, mask, &bcnt, &buf);
     }
 }
 
@@ -1538,7 +1581,7 @@ void random_bounded_uint8_fill(aug_state *state, uint8_t off, uint8_t rng, npy_i
     /* Smallest bit mask >= max */
     mask = (uint8_t)gen_mask(rng);
     for (i = 0; i < cnt; i++) {
-        out[i] = random_buffered_bounded_uint8(state, off, rng, mask, &bcnt, &buf);
+        out[i] = buffered_bounded_uint8(state, off, rng, mask, &bcnt, &buf);
     }
 
 }
@@ -1550,27 +1593,13 @@ void random_bounded_uint8_fill(aug_state *state, uint8_t off, uint8_t rng, npy_i
  */
 void random_bounded_bool_fill(aug_state *state, npy_bool off, npy_bool rng, npy_intp cnt, npy_bool *out)
 {
+    npy_bool mask = 0;
     npy_intp i;
     uint32_t buf = 0;
     int bcnt = 0;
 
-    if (rng == 0) {
-        for (i = 0; i < cnt; i++) {
-            out[i] = off;
-        }
-        return;
-    }
-
     for (i = 0; i < cnt; i++) {
-        if (!bcnt) {
-            buf = random_uint32(state);
-            bcnt = 31;
-        }
-        else {
-            buf >>= 1;
-            bcnt--;
-        }
-        out[i] = (buf & 0x00000001) != 0;
+        out[i] = buffered_bounded_bool(state, off, rng, mask, &bcnt, &buf);
     }
 }
 

randomstate/distributions.h

@@ -176,8 +176,12 @@ extern double random_standard_gamma_zig_double(aug_state* state, double shape);
 
 extern float random_standard_gamma_zig_float(aug_state* state, float shape);
 
-inline uint32_t random_buffered_bounded_uint32(aug_state *state, uint32_t off, uint32_t rng, uint32_t mask, int *bcnt, uint32_t *buf);
+extern uint64_t random_bounded_uint64(aug_state *state, uint64_t off, uint64_t rng, uint64_t mask);
 
-inline uint16_t random_buffered_bounded_uint16(aug_state *state, uint16_t off, uint16_t rng, uint16_t mask, int *bcnt, uint32_t *buf);
+extern uint32_t random_buffered_bounded_uint32(aug_state *state, uint32_t off, uint32_t rng, uint32_t mask, int *bcnt, uint32_t *buf);
 
-inline uint8_t random_buffered_bounded_uint8(aug_state *state, uint8_t off, uint8_t rng, uint8_t mask, int *bcnt, uint32_t *buf);
+extern uint16_t random_buffered_bounded_uint16(aug_state *state, uint16_t off, uint16_t rng, uint16_t mask, int *bcnt, uint32_t *buf);
+
+extern uint8_t random_buffered_bounded_uint8(aug_state *state, uint8_t off, uint8_t rng, uint8_t mask, int *bcnt, uint32_t *buf);
+
+extern npy_bool random_buffered_bounded_bool(aug_state *state, npy_bool off, npy_bool rng, npy_bool mask, int *bcnt, uint32_t *buf);

randomstate/randomstate.pyx

@@ -68,7 +68,8 @@ cdef extern from "distributions.h":
     cdef uint32_t random_buffered_bounded_uint32(aug_state *state, uint32_t off, uint32_t rng, uint32_t mask, int *bcnt, uint32_t *buf) nogil
     cdef uint16_t random_buffered_bounded_uint16(aug_state *state, uint16_t off, uint16_t rng, uint16_t mask, int *bcnt, uint32_t *buf) nogil
     cdef uint8_t random_buffered_bounded_uint8(aug_state *state, uint8_t off, uint8_t rng, uint8_t mask, int *bcnt, uint32_t *buf) nogil
-
+    cdef np.npy_bool random_buffered_bounded_bool(aug_state *state, np.npy_bool off, np.npy_bool rng, np.npy_bool mask, int *bcnt, uint32_t *buf) nogil
+    
     cdef long random_positive_int(aug_state* state) nogil
     cdef unsigned long random_uint(aug_state* state) nogil
     cdef unsigned long random_interval(aug_state* state, unsigned long max) nogil
@@ -1021,6 +1022,27 @@ cdef class RandomState:
         if not key in _randint_type:
             raise TypeError('Unsupported dtype "%s" for randint' % key)
 
+        if key == 'int32':
+            ret =  _rand_int32_combined(low, high, size, &self.rng_state, self.lock)
+        elif key == 'int16':
+            ret =  _rand_int16_combined(low, high, size, &self.rng_state, self.lock)
+        elif key == 'int8':
+            ret =  _rand_int8_combined(low, high, size, &self.rng_state, self.lock)
+        elif key == 'uint32':
+            ret =  _rand_uint32_combined(low, high, size, &self.rng_state, self.lock)
+        elif key == 'uint16':
+            ret =  _rand_uint16_combined(low, high, size, &self.rng_state, self.lock)
+        elif key == 'uint8':
+            ret =  _rand_uint8_combined(low, high, size, &self.rng_state, self.lock)
+        elif key == 'bool':
+            ret =  _rand_bool_combined(low, high, size, &self.rng_state, self.lock)
+        
+        if key != 'int64' and key != 'uint64':
+            if size is None and dtype in (np.bool, np.int, np.long):
+                    if np.array(ret).shape == ():
+                        return dtype(ret)
+            return ret
+
         lowbnd, highbnd = _randint_type[key]
 
         low = np.asarray(low)
@@ -1042,22 +1064,10 @@ cdef class RandomState:
             if ilow >= ihigh:
                 raise ValueError("low >= high")
 
-            if key == 'int32':
-                ret = _rand_int32(ilow, ihigh - 1, size, &self.rng_state, self.lock)
-            elif key == 'int64':
+            if key == 'int64':
                 ret = _rand_int64(ilow, ihigh - 1, size, &self.rng_state, self.lock)
-            elif key == 'int16':
-                ret = _rand_int16(ilow, ihigh - 1, size, &self.rng_state, self.lock)
-            elif key == 'int8':
-                ret = _rand_int8(ilow, ihigh - 1, size, &self.rng_state, self.lock)
             elif key == 'uint64':
                 ret = _rand_uint64(ilow, ihigh - 1, size, &self.rng_state, self.lock)
-            elif key == 'uint32':
-                ret = _rand_uint32(ilow, ihigh - 1, size, &self.rng_state, self.lock)
-            elif key == 'uint16':
-                ret = _rand_uint16(ilow, ihigh - 1, size, &self.rng_state, self.lock)
-            elif key == 'uint8':
-                ret = _rand_uint8(ilow, ihigh - 1, size, &self.rng_state, self.lock)
             elif key == 'bool':
                 ret = _rand_bool(ilow, ihigh - 1, size, &self.rng_state, self.lock)
 
@@ -1066,22 +1076,10 @@ cdef class RandomState:
                     return dtype(ret)
             return ret
 
-        if key == 'int32':
-            ret = _rand_int32_broadcast(low, high, size, &self.rng_state, self.lock)
-        elif key == 'int64':
+        if key == 'int64':
             ret = _rand_int64_broadcast(low, high, size, &self.rng_state, self.lock)
-        elif key == 'int16':
-            ret = _rand_int16_broadcast(low, high, size, &self.rng_state, self.lock)
-        elif key == 'int8':
-            ret = _rand_int8_broadcast(low, high, size, &self.rng_state, self.lock)
         elif key == 'uint64':
             ret = _rand_uint64_broadcast(low, high, size, &self.rng_state, self.lock)
-        elif key == 'uint32':
-            ret = _rand_uint32_broadcast(low, high, size, &self.rng_state, self.lock)
-        elif key == 'uint16':
-            ret = _rand_uint16_broadcast(low, high, size, &self.rng_state, self.lock)
-        elif key == 'uint8':
-            ret = _rand_uint8_broadcast(low, high, size, &self.rng_state, self.lock)
         elif key == 'bool':
             ret = _rand_bool_broadcast(low, high, size, &self.rng_state, self.lock)
 

setup.py

@@ -34,7 +34,7 @@
         'RNG_PCG32', 'RNG_PCG64', 'RNG_XORSHIFT128', 'RNG_XOROSHIRO128PLUS',
         'RNG_XORSHIFT1024', 'RNG_SFMT']
 
-compile_rngs = rngs[:1]
+compile_rngs = rngs[:]
 
 extra_defs = [('_CRT_SECURE_NO_WARNINGS', '1')] if os.name == 'nt' else []
 extra_link_args = ['/LTCG', 'Advapi32.lib', 'Kernel32.lib'] if os.name == 'nt' else []