REF: Final cleanup

Remove unused code paths and rename from _combined

Author: bashtage

randomstate/bounded_integers.pxi.in

@@ -11,79 +11,6 @@ _randint_type = {'bool': (0, 2),
 
 ctypedef np.npy_bool bool_t
 
-{{
-py:
-ctypes = (('int64', 'uint64'),
-          ('int32', 'uint32'),
-          ('int16', 'uint16'),
-          ('int8', 'uint8'),
-          ('uint64', 'uint64'),
-          ('uint32', 'uint32'),
-          ('uint16', 'uint16'),
-          ('uint8', 'uint8'),
-          ('bool','bool'),
-)}}
-
-{{for  nptype, utype in ctypes}}
-
-{{ py: otype = nptype + '_' if nptype == 'bool' else nptype }}
-
-cdef object _rand_{{nptype}}(low, high, size, aug_state *state, lock):
-    """
-    _rand_{{nptype}}(self, low, high, size, rngstate)
-
-    Return random np.{{nptype}} integers between `low` and `high`, inclusive.
-
-    Return random integers from the "discrete uniform" distribution in the
-    closed interval [`low`, `high`).  If `high` is None (the default),
-    then results are from [0, `low`). On entry the arguments are presumed
-    to have been validated for size and order for the np.{{nptype}} type.
-
-    Parameters
-    ----------
-    low : int
-        Lowest (signed) integer to be drawn from the distribution (unless
-        ``high=None``, in which case this parameter is the *highest* such
-        integer).
-    high : int
-        If provided, the largest (signed) integer to be drawn from the
-        distribution (see above for behavior if ``high=None``).
-    size : int or tuple of ints
-        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
-        single value is returned.
-    rngstate : encapsulated pointer to rk_state
-        The specific type depends on the python version. In Python 2 it is
-        a PyCObject, in Python 3 a PyCapsule object.
-
-    Returns
-    -------
-    out : python scalar or ndarray of np.{{nptype}}
-          `size`-shaped array of random integers from the appropriate
-          distribution, or a single such random int if `size` not provided.
-
-    """
-    cdef {{utype}}_t off, rng, buf
-    cdef {{utype}}_t *out
-    cdef np.ndarray array
-    cdef np.npy_intp cnt
-
-    rng = <{{utype}}_t>(high - low)
-    off = <{{utype}}_t>(<{{nptype}}_t>low)
-    if size is None:
-        with lock:
-            random_bounded_{{utype}}_fill(state, off, rng, 1, &buf)
-        return np.{{otype}}(<{{nptype}}_t>buf)
-    else:
-        array = <np.ndarray>np.empty(size, np.{{nptype}})
-        cnt = np.PyArray_SIZE(array)
-        out = <{{utype}}_t *>np.PyArray_DATA(array)
-        with lock, nogil:
-            random_bounded_{{utype}}_fill(state, off, rng, cnt, out)
-        return array
-
-{{endfor}}
-
 cdef inline uint64_t _gen_mask(uint64_t max_val) nogil:
     # Smallest bit mask >= max
     cdef uint64_t mask = max_val
@@ -110,9 +37,9 @@ bc_ctypes = (('uint32', 'uint32', 'uint64', 'NPY_UINT64', 0, 0, 0, '0X100000000U
 
 {{ py: otype = nptype + '_' if nptype == 'bool' else nptype }}
 
-cdef object _rand_{{nptype}}_combined(object low, object high, object size, aug_state *state, object lock):
+cdef object _rand_{{nptype}}(object low, object high, object size, aug_state *state, object lock):
     """
-    _rand_{{nptype}}_combined(low, high, size, *state, lock)
+    _rand_{{nptype}}(low, high, size, *state, lock)
 
     Return random np.{{nptype}} integers between `low` and `high`, inclusive.
 
@@ -225,223 +152,6 @@ cdef object _rand_{{nptype}}_combined(object low, object high, object size, aug_
 {{endfor}}
 
 
-{{
-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'),
-          ('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' ),
-)}}
-
-{{for  nptype, utype, nptype_up, npctype, remaining, bitshift, lb, ub in bc_ctypes}}
-
-{{ py: otype = nptype + '_' if nptype == 'bool' else nptype }}
-
-cdef object _rand_{{nptype}}_broadcast(object low, object high, object size, aug_state *state, object lock):
-    """
-    Generate bounded random {{nptype}} values using broadcasting
-
-    Parameters
-    ----------
-    low : int or array-like
-        Array containing the lowest (signed) integers to be drawn from the
-        distribution.
-    high : int or array-like
-        Array containing the the open interval bound for the distribution.
-    size : int or tuple of ints
-        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
-        the output shape is determined by the broadcast shapes of low and
-        high
-    state : augmented random state
-        State to use in the core random number generators
-    lock : threading.Lock
-        Lock to prevent multiple using a single RandomState simultaneously
-
-    Returns
-    -------
-    out : ndarray of np.{{nptype}}
-          array of random integers from the appropriate distribution where the
-          size is determined by size if provided or the broadcast shape of low
-          and high
-    """
-    cdef np.ndarray low_arr, high_arr, out_arr
-    cdef np.npy_intp i
-    cdef np.broadcast it
-    cdef int buf_rem = 0
-
-    cdef {{utype}}_t *out_data
-    cdef {{utype}}_t val, mask, off
-    cdef {{nptype_up}}_t rng, last_rng, low_v, high_v
-    cdef uint32_t buf
-
-    # TODO: Direct error check? Probably not
-    # TODO: Make constant?
-    low_arr = <np.ndarray>low
-    high_arr = <np.ndarray>high
-    if np.any(np.less(low_arr, {{lb}})):
-        raise ValueError('low is out of bounds for {{nptype}}')
-    if np.any(np.greater(high_arr, {{ub}})):
-        raise ValueError('high is out of bounds for {{nptype}}')
-    if np.any(np.greater_equal(low_arr, high_arr)):
-        raise ValueError('low >= high')
-
-    low_arr = <np.ndarray>np.PyArray_FROM_OTF(low, np.{{npctype}}, np.NPY_ALIGNED | np.NPY_FORCECAST)
-    high_arr = <np.ndarray>np.PyArray_FROM_OTF(high, np.{{npctype}}, np.NPY_ALIGNED | np.NPY_FORCECAST)
-
-    if size is not None:
-        out_arr = <np.ndarray>np.empty(size, np.{{otype}})
-    else:
-        it = np.PyArray_MultiIterNew2(low_arr, high_arr)
-        out_arr = <np.ndarray>np.empty(it.shape, np.{{otype}})
-
-    it = np.PyArray_MultiIterNew3(low_arr, high_arr, out_arr)
-    out_data = <{{utype}}_t *>np.PyArray_DATA(out_arr)
-    n = np.PyArray_SIZE(out_arr)
-    mask = last_rng = 0
-    with lock, nogil:
-        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
-            off = <{{utype}}_t>(<{{nptype_up}}_t>low_v)
-            if rng == 0:
-                out_data[i] = 0
-                continue
-
-            if rng != last_rng:
-                # TODO: Is this too much of an optimization?  is it worth it?
-                # Smallest bit mask >= max
-                mask = <{{utype}}_t>_gen_mask(rng)
-
-            while True:
-                if not buf_rem:
-                    buf = random_uint32(state)
-                    buf_rem = {{remaining}}
-                else:
-                    buf >>= {{bitshift}}
-                    buf_rem -= 1
-                val = <{{utype}}_t>buf & mask
-                if val <= rng:
-                    break
-            out_data[i] = off + val
-
-            np.PyArray_MultiIter_NEXT(it)
-
-    return out_arr
-
-{{endfor}}
-
-
-{{
-py:
-big_bc_ctypes = (('uint64', 'uint64', 'NPY_UINT64', '0x0ULL', '0xFFFFFFFFFFFFFFFFULL'),
-                 ('int64', 'uint64', 'NPY_INT64', '-0x8000000000000000LL', '0x7FFFFFFFFFFFFFFFLL' )
-)}}
-
-{{for  nptype, utype, npctype, lb, ub in big_bc_ctypes}}
-
-{{ py: otype = nptype}}
-
-cdef object _rand_{{nptype}}_broadcast(object low, object high, object size, aug_state *state, object lock):
-    """
-    Generate bounded random {{nptype}} values using broadcasting
-
-    Parameters
-    ----------
-    low : int or array-like
-        Array containing the lowest (signed) integers to be drawn from the
-        distribution.
-    high : int or array-like
-        Array containing the the open interval bound for the distribution.
-    size : int or tuple of ints
-        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
-        the output shape is determined by the broadcast shapes of low and
-        high
-    state : augmented random state
-        State to use in the core random number generators
-    lock : threading.Lock
-        Lock to prevent multiple using a single RandomState simultaneously
-
-    Returns
-    -------
-    out : ndarray of np.{{nptype}}
-          array of random integers from the appropriate distribution where the
-          size is determined by size if provided or the broadcast shape of low
-          and high
-    """
-    cdef np.ndarray low_arr, high_arr, out_arr, highm1_arr
-    cdef np.npy_intp i
-    cdef np.broadcast it
-    cdef int buf_rem = 0
-    cdef object closed_upper
-
-    cdef uint64_t *out_data
-    cdef {{nptype}}_t *highm1_data
-    cdef {{nptype}}_t low_v, high_v
-    cdef uint64_t rng, last_rng, val, mask, off
-
-    low_arr = <np.ndarray>low
-    high_arr = <np.ndarray>high
-
-    if np.any(np.less(low_arr, {{lb}})):
-        raise ValueError('low is out of bounds for {{nptype}}')
-
-    highm1_arr = <np.ndarray>np.empty_like(high_arr, dtype=np.{{nptype}})
-    highm1_data = <{{nptype}}_t *>np.PyArray_DATA(highm1_arr)
-    n = np.PyArray_SIZE(high_arr)
-    flat = high_arr.flat
-    for i in range(n):
-        closed_upper = int(flat[i]) - 1
-        if closed_upper > {{ub}}:
-            raise ValueError('high is out of bounds for {{nptype}}')
-        if closed_upper < {{lb}}:
-            raise ValueError('low >= high')
-
-        highm1_data[i] = <{{nptype}}_t>closed_upper
-
-    if np.any(np.greater(low_arr, highm1_arr)):
-        raise ValueError('low >= high')
-
-    high_arr = highm1_arr
-    low_arr = <np.ndarray>np.PyArray_FROM_OTF(low, np.{{npctype}}, np.NPY_ALIGNED | np.NPY_FORCECAST)
-
-    if size is not None:
-        out_arr = <np.ndarray>np.empty(size, np.{{nptype}})
-    else:
-        it = np.PyArray_MultiIterNew2(low_arr, high_arr)
-        out_arr = <np.ndarray>np.empty(it.shape, np.{{nptype}})
-
-    it = np.PyArray_MultiIterNew3(low_arr, high_arr, out_arr)
-    out_data = <uint64_t *>np.PyArray_DATA(out_arr)
-    n = np.PyArray_SIZE(out_arr)
-    mask = last_rng = 0
-    with lock, nogil:
-        for i in range(n):
-            low_v = (<{{nptype}}_t*>np.PyArray_MultiIter_DATA(it, 0))[0]
-            high_v = (<{{nptype}}_t*>np.PyArray_MultiIter_DATA(it, 1))[0]
-            rng = <{{nptype}}_t>(high_v - low_v) # No -1 here since implemented above
-            off = low_v
-            if rng == 0:
-                out_data[i] = 0
-                continue
-
-            if rng != last_rng:
-                mask = _gen_mask(rng)
-            out_data[i] = random_bounded_uint64(state, off, rng, mask)
-
-            np.PyArray_MultiIter_NEXT(it)
-
-    return out_arr
-
-{{endfor}}
-
-
-
 {{
 py:
 big_bc_ctypes = (('uint64', 'uint64', 'NPY_UINT64', '0x0ULL', '0xFFFFFFFFFFFFFFFFULL'),
@@ -452,9 +162,9 @@ big_bc_ctypes = (('uint64', 'uint64', 'NPY_UINT64', '0x0ULL', '0xFFFFFFFFFFFFFFF
 
 {{ py: otype = nptype}}
 
-cdef object _rand_{{nptype}}_combined(object low, object high, object size, aug_state *state, object lock):
+cdef object _rand_{{nptype}}(object low, object high, object size, aug_state *state, object lock):
     """
-    Generate bounded random {{nptype}} values using broadcasting
+    Generate bounded random {{nptype}} values
 
     Parameters
     ----------

randomstate/distributions.c

@@ -1536,15 +1536,13 @@ 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    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] =  bounded_uint32(state, off, rng, mask, &bcnt, &buf);
+        out[i] =  bounded_uint32(state, off, rng, mask);
     }
 }
 

randomstate/randomstate.pyx

@@ -1024,25 +1024,24 @@ cdef class RandomState:
             raise TypeError('Unsupported dtype "%s" for randint' % key)
 
         if key == 'int32':
-            ret =  _rand_int32_combined(low, high, size, &self.rng_state, self.lock)
+            ret =  _rand_int32(low, high, size, &self.rng_state, self.lock)
         elif key == 'int64':
-            ret =  _rand_int64_combined(low, high, size, &self.rng_state, self.lock)
+            ret =  _rand_int64(low, high, size, &self.rng_state, self.lock)
         elif key == 'int16':
-            ret =  _rand_int16_combined(low, high, size, &self.rng_state, self.lock)
+            ret =  _rand_int16(low, high, size, &self.rng_state, self.lock)
         elif key == 'int8':
-            ret =  _rand_int8_combined(low, high, size, &self.rng_state, self.lock)
+            ret =  _rand_int8(low, high, size, &self.rng_state, self.lock)
         elif key == 'uint64':
-            ret =  _rand_uint64_combined(low, high, size, &self.rng_state, self.lock)
+            ret =  _rand_uint64(low, high, size, &self.rng_state, self.lock)
         elif key == 'uint32':
-            ret =  _rand_uint32_combined(low, high, size, &self.rng_state, self.lock)
+            ret =  _rand_uint32(low, high, size, &self.rng_state, self.lock)
         elif key == 'uint16':
-            ret =  _rand_uint16_combined(low, high, size, &self.rng_state, self.lock)
+            ret =  _rand_uint16(low, high, size, &self.rng_state, self.lock)
         elif key == 'uint8':
-            ret =  _rand_uint8_combined(low, high, size, &self.rng_state, self.lock)
+            ret =  _rand_uint8(low, high, size, &self.rng_state, self.lock)
         elif key == 'bool':
-            ret =  _rand_bool_combined(low, high, size, &self.rng_state, self.lock)
+            ret =  _rand_bool(low, high, size, &self.rng_state, self.lock)
 
-
         if size is None and dtype in (np.bool, np.int, np.long):
                 if np.array(ret).shape == ():
                     return dtype(ret)