BENCH: convert bencmarks to asv format

remove files that were part of the origal repo
rework randomgen docs to integrate with numpy and fix some links
remove convenience functions, require explicit call to gen.brng
move code out of numpy.random.randomgen into numpy.random

176 files changed, 508 insertions, 1102 deletions

diff --git a/numpy/random/randomgen/LICENSE.md b/numpy/random/LICENSE.md
index caa665373..caa665373 100644
--- a/numpy/random/randomgen/LICENSE.md
+++ b/numpy/random/LICENSE.md
diff --git a/numpy/random/__init__.py b/numpy/random/__init__.py
index 53e947797..89015d6a2 100644
--- a/numpy/random/__init__.py
+++ b/numpy/random/__init__.py
@@ -83,6 +83,22 @@ get_state            Get tuple representing internal state of generator.
 set_state            Set state of generator.
 ==================== =========================================================
 
+==================== =========================================================
+Random Number Streams that work with RandomGenerator
+==============================================================================
+MT19937
+DSFMT
+PCG32
+PCG64
+Philox
+ThreeFry
+ThreeFry32
+Xoroshiro128
+Xoroshift1024
+Xoshiro256StarStar
+Xoshiro512StarStar
+==================== =========================================================
+
 """
 from __future__ import division, absolute_import, print_function
 
@@ -136,8 +152,24 @@ __all__ = [
     'zipf'
 ]
 
-from .randomgen import mtrand
-from .randomgen.mtrand import *
+from . import mtrand
+from .mtrand import *
+from .dsfmt import DSFMT
+from .generator import RandomGenerator
+from .mt19937 import MT19937
+from .pcg32 import PCG32
+from .pcg64 import PCG64
+from .philox import Philox
+from .threefry import ThreeFry
+from .threefry32 import ThreeFry32
+from .xoroshiro128 import Xoroshiro128
+from .xorshift1024 import Xorshift1024
+from .xoshiro256starstar import Xoshiro256StarStar
+from .xoshiro512starstar import Xoshiro512StarStar
+from .mtrand import RandomState
+__all__ += ['RandomGenerator', 'DSFMT', 'MT19937', 'PCG64', 'PCG32', 'Philox',
+           'ThreeFry', 'ThreeFry32', 'Xoroshiro128', 'Xorshift1024',
+           'Xoshiro256StarStar', 'Xoshiro512StarStar', 'RandomState']
 
 # Some aliases:
 ranf = random = sample = random_sample
diff --git a/numpy/random/mtrand/Python.pxi b/numpy/random/_mtrand/Python.pxi
index 08aadbaa1..08aadbaa1 100644
--- a/numpy/random/mtrand/Python.pxi
+++ b/numpy/random/_mtrand/Python.pxi
diff --git a/numpy/random/mtrand/distributions.c b/numpy/random/_mtrand/distributions.c
index 1b410db57..1b410db57 100644
--- a/numpy/random/mtrand/distributions.c
+++ b/numpy/random/_mtrand/distributions.c
diff --git a/numpy/random/mtrand/distributions.h b/numpy/random/_mtrand/distributions.h
index 0b42bc794..0b42bc794 100644
--- a/numpy/random/mtrand/distributions.h
+++ b/numpy/random/_mtrand/distributions.h
diff --git a/numpy/random/_mtrand/generate_mtrand_c.py b/numpy/random/_mtrand/generate_mtrand_c.py
new file mode 100644
index 000000000..ec935e6dd
--- /dev/null
+++ b/numpy/random/_mtrand/generate_mtrand_c.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+from __future__ import division, absolute_import, print_function
+
+import sys
+import re
+import os
+
+unused_internal_funcs = ['__Pyx_PrintItem',
+                         '__Pyx_PrintNewline',
+                         '__Pyx_ReRaise',
+                         #'__Pyx_GetExcValue',
+                         '__Pyx_ArgTypeTest',
+                         '__Pyx_SetVtable',
+                         '__Pyx_GetVtable',
+                         '__Pyx_CreateClass']
+
+if __name__ == '__main__':
+    # Use cython here so that long docstrings are broken up.
+    # This is needed for some VC++ compilers.
+    os.system('cython mtrand.pyx')
+    mtrand_c = open('mtrand.c', 'r')
+    processed = open('mtrand_pp.c', 'w')
+    unused_funcs_str = '(' + '|'.join(unused_internal_funcs) + ')'
+    uifpat = re.compile(r'static \w+ \*?'+unused_funcs_str+r'.*/\*proto\*/')
+    linepat = re.compile(r'/\* ".*/mtrand.pyx":')
+    for linenum, line in enumerate(mtrand_c):
+        m = re.match(r'^(\s+arrayObject\w*\s*=\s*[(])[(]PyObject\s*[*][)]',
+                     line)
+        if m:
+            line = '%s(PyArrayObject *)%s' % (m.group(1), line[m.end():])
+        m = uifpat.match(line)
+        if m:
+            line = ''
+        m = re.search(unused_funcs_str, line)
+        if m:
+            print("%s was declared unused, but is used at line %d" % (m.group(),
+                                                                    linenum+1), file=sys.stderr)
+        line = linepat.sub(r'/* "mtrand.pyx":', line)
+        processed.write(line)
+    mtrand_c.close()
+    processed.close()
+    os.rename('mtrand_pp.c', 'mtrand.c')
diff --git a/numpy/random/mtrand/initarray.c b/numpy/random/_mtrand/initarray.c
index beff78510..beff78510 100644
--- a/numpy/random/mtrand/initarray.c
+++ b/numpy/random/_mtrand/initarray.c
diff --git a/numpy/random/mtrand/initarray.h b/numpy/random/_mtrand/initarray.h
index f5e5e5332..f5e5e5332 100644
--- a/numpy/random/mtrand/initarray.h
+++ b/numpy/random/_mtrand/initarray.h
diff --git a/numpy/random/mtrand/mtrand.pyx b/numpy/random/_mtrand/mtrand.pyx
index 329d5cd68..329d5cd68 100644
--- a/numpy/random/mtrand/mtrand.pyx
+++ b/numpy/random/_mtrand/mtrand.pyx
diff --git a/numpy/random/mtrand/mtrand_py_helper.h b/numpy/random/_mtrand/mtrand_py_helper.h
index 266847cbe..266847cbe 100644
--- a/numpy/random/mtrand/mtrand_py_helper.h
+++ b/numpy/random/_mtrand/mtrand_py_helper.h
diff --git a/numpy/random/mtrand/numpy.pxd b/numpy/random/_mtrand/numpy.pxd
index e146054b1..e146054b1 100644
--- a/numpy/random/mtrand/numpy.pxd
+++ b/numpy/random/_mtrand/numpy.pxd
diff --git a/numpy/random/mtrand/randint_helpers.pxi.in b/numpy/random/_mtrand/randint_helpers.pxi.in
index 894a25167..894a25167 100644
--- a/numpy/random/mtrand/randint_helpers.pxi.in
+++ b/numpy/random/_mtrand/randint_helpers.pxi.in
diff --git a/numpy/random/mtrand/randomkit.c b/numpy/random/_mtrand/randomkit.c
index 6371ebe33..6371ebe33 100644
--- a/numpy/random/mtrand/randomkit.c
+++ b/numpy/random/_mtrand/randomkit.c
diff --git a/numpy/random/mtrand/randomkit.h b/numpy/random/_mtrand/randomkit.h
index a24dabebf..a24dabebf 100644
--- a/numpy/random/mtrand/randomkit.h
+++ b/numpy/random/_mtrand/randomkit.h
diff --git a/numpy/random/randomgen/_pickle.py b/numpy/random/_pickle.py
index 1c365b0c7..1c365b0c7 100644
--- a/numpy/random/randomgen/_pickle.py
+++ b/numpy/random/_pickle.py
diff --git a/numpy/random/randomgen/bounded_integers.pxd.in b/numpy/random/bounded_integers.pxd.in
index 4ab389fd9..4ab389fd9 100644
--- a/numpy/random/randomgen/bounded_integers.pxd.in
+++ b/numpy/random/bounded_integers.pxd.in
diff --git a/numpy/random/randomgen/bounded_integers.pyx.in b/numpy/random/bounded_integers.pyx.in
index 03068a8fd..03068a8fd 100644
--- a/numpy/random/randomgen/bounded_integers.pyx.in
+++ b/numpy/random/bounded_integers.pyx.in
diff --git a/numpy/random/randomgen/common.pxd b/numpy/random/common.pxd
index f6748e5aa..f6748e5aa 100644
--- a/numpy/random/randomgen/common.pxd
+++ b/numpy/random/common.pxd
diff --git a/numpy/random/randomgen/common.pyx b/numpy/random/common.pyx
index ebd2e60d1..ebd2e60d1 100644
--- a/numpy/random/randomgen/common.pyx
+++ b/numpy/random/common.pyx
diff --git a/numpy/random/randomgen/distributions.pxd b/numpy/random/distributions.pxd
index ddb7a84bf..ddb7a84bf 100644
--- a/numpy/random/randomgen/distributions.pxd
+++ b/numpy/random/distributions.pxd
diff --git a/numpy/random/randomgen/dsfmt.pyx b/numpy/random/dsfmt.pyx
index 9a7199e85..9a7199e85 100644
--- a/numpy/random/randomgen/dsfmt.pyx
+++ b/numpy/random/dsfmt.pyx
diff --git a/numpy/random/randomgen/entropy.pyx b/numpy/random/entropy.pyx
index 0e429e9f2..0e429e9f2 100644
--- a/numpy/random/randomgen/entropy.pyx
+++ b/numpy/random/entropy.pyx
diff --git a/numpy/random/randomgen/examples/cython/extending.pyx b/numpy/random/examples/cython/extending.pyx
index b472312b4..b472312b4 100644
--- a/numpy/random/randomgen/examples/cython/extending.pyx
+++ b/numpy/random/examples/cython/extending.pyx
diff --git a/numpy/random/randomgen/examples/cython/extending_distributions.pyx b/numpy/random/examples/cython/extending_distributions.pyx
index 26d749b10..26d749b10 100644
--- a/numpy/random/randomgen/examples/cython/extending_distributions.pyx
+++ b/numpy/random/examples/cython/extending_distributions.pyx
diff --git a/numpy/random/randomgen/examples/cython/setup.py b/numpy/random/examples/cython/setup.py
index d7a04f75a..d7a04f75a 100644
--- a/numpy/random/randomgen/examples/cython/setup.py
+++ b/numpy/random/examples/cython/setup.py
diff --git a/numpy/random/randomgen/examples/numba/extending.py b/numpy/random/examples/numba/extending.py
index 72e903b1f..72e903b1f 100644
--- a/numpy/random/randomgen/examples/numba/extending.py
+++ b/numpy/random/examples/numba/extending.py
diff --git a/numpy/random/randomgen/examples/numba/extending_distributions.py b/numpy/random/examples/numba/extending_distributions.py
index 17ba2704c..17ba2704c 100644
--- a/numpy/random/randomgen/examples/numba/extending_distributions.py
+++ b/numpy/random/examples/numba/extending_distributions.py
diff --git a/numpy/random/randomgen/generator.pyx b/numpy/random/generator.pyx
index a244bca57..e68edb98a 100644
--- a/numpy/random/randomgen/generator.pyx
+++ b/numpy/random/generator.pyx
@@ -49,7 +49,7 @@ cdef class RandomGenerator:
 
     Notes
     -----
-    The Python stdlib module "random" contains pseudo-random number generator
+    The Python stdlib module `random` contains pseudo-random number generator
     with a number of methods that are similar to the ones available in
     ``RandomGenerator``. It uses Mersenne Twister, and this basic RNG can be
     accessed using ``MT19937``. ``RandomGenerator``, besides being
@@ -72,7 +72,7 @@ cdef class RandomGenerator:
     >>> rg = MT19937().generator
     >>> rg.standard_normal()
     """
-    cdef public object _basicrng
+    cdef public object brng
     cdef brng_t *_brng
     cdef binomial_t *_binomial
     cdef object lock
@@ -81,7 +81,7 @@ cdef class RandomGenerator:
     def __init__(self, brng=None):
         if brng is None:
             brng = Xoroshiro128()
-        self._basicrng = brng
+        self.brng = brng
 
         capsule = brng.capsule
         cdef const char *name = "BasicRNG"
@@ -99,79 +99,21 @@ cdef class RandomGenerator:
 
     def __str__(self):
         _str = self.__class__.__name__
-        _str += '(' + self._basicrng.__class__.__name__ + ')'
+        _str += '(' + self.brng.__class__.__name__ + ')'
         return _str
 
     # Pickling support:
     def __getstate__(self):
-        return self.state
+        return self.brng.state
 
     def __setstate__(self, state):
-        self.state = state
+        self.brng.state = state
 
     def __reduce__(self):
         from ._pickle import __generator_ctor
         return (__generator_ctor,
-                (self.state['brng'],),
-                self.state)
-
-    def seed(self, *args, **kwargs):
-        """
-        Reseed the basic RNG.
-
-        Parameters depend on the basic RNG used.
-
-        Notes
-        -----
-        Arguments are directly passed to the basic RNG. This is a convenience
-        function.
-
-        The best method to access seed is to directly use a basic RNG instance.
-        This example demonstrates this best practice.
-
-        >>> from numpy.random.randomgen import RandomGenerator, PCG64
-        >>> brng = PCG64(1234567891011)
-        >>> rg = brng.generator
-        >>> brng.seed(1110987654321)
-
-        The method used to create the generator is not important.
-
-        >>> brng = PCG64(1234567891011)
-        >>> rg = RandomGenerator(brng)
-        >>> brng.seed(1110987654321)
-
-        These best practice examples are equivalent to
-
-        >>> rg = RandomGenerator(PCG64(1234567891011))
-        >>> rg.seed(1110987654321)
-
-        """
-        # TODO: Should this remain
-        self._basicrng.seed(*args, **kwargs)
-        return self
-
-    @property
-    def state(self):
-        """
-        Get or set the Basic RNG's state
-
-        Returns
-        -------
-        state : dict
-            Dictionary containing the information required to describe the
-            state of the Basic RNG
-
-        Notes
-        -----
-        This is a trivial pass-through function.  RandomGenerator does not
-        directly contain or manipulate the basic RNG's state.
-
-        """
-        return self._basicrng.state
-
-    @state.setter
-    def state(self, value):
-        self._basicrng.state = value
+                (self.brng.state['brng'],),
+                self.brng.state)
 
     def random_sample(self, size=None, dtype=np.float64, out=None):
         """
diff --git a/numpy/random/randomgen/legacy/__init__.py b/numpy/random/legacy/__init__.py
index 9ce1f665d..9ce1f665d 100644
--- a/numpy/random/randomgen/legacy/__init__.py
+++ b/numpy/random/legacy/__init__.py
diff --git a/numpy/random/randomgen/legacy/legacy_distributions.pxd b/numpy/random/legacy/legacy_distributions.pxd
index bc00994db..bc00994db 100644
--- a/numpy/random/randomgen/legacy/legacy_distributions.pxd
+++ b/numpy/random/legacy/legacy_distributions.pxd
diff --git a/numpy/random/randomgen/mt19937.pyx b/numpy/random/mt19937.pyx
index 306ce23e2..306ce23e2 100644
--- a/numpy/random/randomgen/mt19937.pyx
+++ b/numpy/random/mt19937.pyx
diff --git a/numpy/random/randomgen/mtrand.pyx b/numpy/random/mtrand.pyx
index b5d6ff9bc..b5d6ff9bc 100644
--- a/numpy/random/randomgen/mtrand.pyx
+++ b/numpy/random/mtrand.pyx
diff --git a/numpy/random/randomgen/pcg32.pyx b/numpy/random/pcg32.pyx
index 5f2b34807..5f2b34807 100644
--- a/numpy/random/randomgen/pcg32.pyx
+++ b/numpy/random/pcg32.pyx
diff --git a/numpy/random/randomgen/pcg64.pyx b/numpy/random/pcg64.pyx
index f67d9623c..f67d9623c 100644
--- a/numpy/random/randomgen/pcg64.pyx
+++ b/numpy/random/pcg64.pyx
diff --git a/numpy/random/randomgen/philox.pyx b/numpy/random/philox.pyx
index 70afd55ab..70afd55ab 100644
--- a/numpy/random/randomgen/philox.pyx
+++ b/numpy/random/philox.pyx
diff --git a/numpy/random/randomgen/__init__.py b/numpy/random/randomgen/__init__.py
deleted file mode 100644
index 1af2fc3b2..000000000
--- a/numpy/random/randomgen/__init__.py
+++ /dev/null
@@ -1,21 +0,0 @@
-from .dsfmt import DSFMT
-from .generator import RandomGenerator
-from .mt19937 import MT19937
-from .pcg32 import PCG32
-from .pcg64 import PCG64
-from .philox import Philox
-from .threefry import ThreeFry
-from .threefry32 import ThreeFry32
-from .xoroshiro128 import Xoroshiro128
-from .xorshift1024 import Xorshift1024
-from .xoshiro256starstar import Xoshiro256StarStar
-from .xoshiro512starstar import Xoshiro512StarStar
-from .mtrand import RandomState
-__all__ = ['RandomGenerator', 'DSFMT', 'MT19937', 'PCG64', 'PCG32', 'Philox',
-           'ThreeFry', 'ThreeFry32', 'Xoroshiro128', 'Xorshift1024',
-           'Xoshiro256StarStar', 'Xoshiro512StarStar', 'RandomState']
-
-#from ._version import get_versions
-
-#__version__ = get_versions()['version']
-#del get_versions
diff --git a/numpy/random/randomgen/_version.py b/numpy/random/randomgen/_version.py
deleted file mode 100644
index e400e3efb..000000000
--- a/numpy/random/randomgen/_version.py
+++ /dev/null
@@ -1,520 +0,0 @@
-
-# This file helps to compute a version number in source trees obtained from
-# git-archive tarball (such as those provided by githubs download-from-tag
-# feature). Distribution tarballs (built by setup.py sdist) and build
-# directories (produced by setup.py build) will contain a much shorter file
-# that just contains the computed version number.
-
-# This file is released into the public domain. Generated by
-# versioneer-0.18 (https://github.com/warner/python-versioneer)
-
-"""Git implementation of _version.py."""
-
-import errno
-import os
-import re
-import subprocess
-import sys
-
-
-def get_keywords():
-    """Get the keywords needed to look up the version information."""
-    # these strings will be replaced by git during git-archive.
-    # setup.py/versioneer.py will grep for the variable names, so they must
-    # each be defined on a line of their own. _version.py will just call
-    # get_keywords().
-    git_refnames = "$Format:%d$"
-    git_full = "$Format:%H$"
-    git_date = "$Format:%ci$"
-    keywords = {"refnames": git_refnames, "full": git_full, "date": git_date}
-    return keywords
-
-
-class VersioneerConfig:
-    """Container for Versioneer configuration parameters."""
-
-
-def get_config():
-    """Create, populate and return the VersioneerConfig() object."""
-    # these strings are filled in when 'setup.py versioneer' creates
-    # _version.py
-    cfg = VersioneerConfig()
-    cfg.VCS = "git"
-    cfg.style = "pep440"
-    cfg.tag_prefix = ""
-    cfg.parentdir_prefix = "randomgen-"
-    cfg.versionfile_source = "randomgen/_version.py"
-    cfg.verbose = False
-    return cfg
-
-
-class NotThisMethod(Exception):
-    """Exception raised if a method is not valid for the current scenario."""
-
-
-LONG_VERSION_PY = {}
-HANDLERS = {}
-
-
-def register_vcs_handler(vcs, method):  # decorator
-    """Decorator to mark a method as the handler for a particular VCS."""
-    def decorate(f):
-        """Store f in HANDLERS[vcs][method]."""
-        if vcs not in HANDLERS:
-            HANDLERS[vcs] = {}
-        HANDLERS[vcs][method] = f
-        return f
-    return decorate
-
-
-def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
-                env=None):
-    """Call the given command(s)."""
-    assert isinstance(commands, list)
-    p = None
-    for c in commands:
-        try:
-            dispcmd = str([c] + args)
-            # remember shell=False, so use git.cmd on windows, not just git
-            p = subprocess.Popen([c] + args, cwd=cwd, env=env,
-                                 stdout=subprocess.PIPE,
-                                 stderr=(subprocess.PIPE if hide_stderr
-                                         else None))
-            break
-        except EnvironmentError:
-            e = sys.exc_info()[1]
-            if e.errno == errno.ENOENT:
-                continue
-            if verbose:
-                print("unable to run %s" % dispcmd)
-                print(e)
-            return None, None
-    else:
-        if verbose:
-            print("unable to find command, tried %s" % (commands,))
-        return None, None
-    stdout = p.communicate()[0].strip()
-    if sys.version_info[0] >= 3:
-        stdout = stdout.decode()
-    if p.returncode != 0:
-        if verbose:
-            print("unable to run %s (error)" % dispcmd)
-            print("stdout was %s" % stdout)
-        return None, p.returncode
-    return stdout, p.returncode
-
-
-def versions_from_parentdir(parentdir_prefix, root, verbose):
-    """Try to determine the version from the parent directory name.
-
-    Source tarballs conventionally unpack into a directory that includes both
-    the project name and a version string. We will also support searching up
-    two directory levels for an appropriately named parent directory
-    """
-    rootdirs = []
-
-    for i in range(3):
-        dirname = os.path.basename(root)
-        if dirname.startswith(parentdir_prefix):
-            return {"version": dirname[len(parentdir_prefix):],
-                    "full-revisionid": None,
-                    "dirty": False, "error": None, "date": None}
-        else:
-            rootdirs.append(root)
-            root = os.path.dirname(root)  # up a level
-
-    if verbose:
-        print("Tried directories %s but none started with prefix %s" %
-              (str(rootdirs), parentdir_prefix))
-    raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
-
-
-@register_vcs_handler("git", "get_keywords")
-def git_get_keywords(versionfile_abs):
-    """Extract version information from the given file."""
-    # the code embedded in _version.py can just fetch the value of these
-    # keywords. When used from setup.py, we don't want to import _version.py,
-    # so we do it with a regexp instead. This function is not used from
-    # _version.py.
-    keywords = {}
-    try:
-        f = open(versionfile_abs, "r")
-        for line in f.readlines():
-            if line.strip().startswith("git_refnames ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["refnames"] = mo.group(1)
-            if line.strip().startswith("git_full ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["full"] = mo.group(1)
-            if line.strip().startswith("git_date ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["date"] = mo.group(1)
-        f.close()
-    except EnvironmentError:
-        pass
-    return keywords
-
-
-@register_vcs_handler("git", "keywords")
-def git_versions_from_keywords(keywords, tag_prefix, verbose):
-    """Get version information from git keywords."""
-    if not keywords:
-        raise NotThisMethod("no keywords at all, weird")
-    date = keywords.get("date")
-    if date is not None:
-        # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant
-        # datestamp. However we prefer "%ci" (which expands to an "ISO-8601
-        # -like" string, which we must then edit to make compliant), because
-        # it's been around since git-1.5.3, and it's too difficult to
-        # discover which version we're using, or to work around using an
-        # older one.
-        date = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
-    refnames = keywords["refnames"].strip()
-    if refnames.startswith("$Format"):
-        if verbose:
-            print("keywords are unexpanded, not using")
-        raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
-    refs = set([r.strip() for r in refnames.strip("()").split(",")])
-    # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
-    # just "foo-1.0". If we see a "tag: " prefix, prefer those.
-    TAG = "tag: "
-    tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
-    if not tags:
-        # Either we're using git < 1.8.3, or there really are no tags. We use
-        # a heuristic: assume all version tags have a digit. The old git %d
-        # expansion behaves like git log --decorate=short and strips out the
-        # refs/heads/ and refs/tags/ prefixes that would let us distinguish
-        # between branches and tags. By ignoring refnames without digits, we
-        # filter out many common branch names like "release" and
-        # "stabilization", as well as "HEAD" and "master".
-        tags = set([r for r in refs if re.search(r'\d', r)])
-        if verbose:
-            print("discarding '%s', no digits" % ",".join(refs - tags))
-    if verbose:
-        print("likely tags: %s" % ",".join(sorted(tags)))
-    for ref in sorted(tags):
-        # sorting will prefer e.g. "2.0" over "2.0rc1"
-        if ref.startswith(tag_prefix):
-            r = ref[len(tag_prefix):]
-            if verbose:
-                print("picking %s" % r)
-            return {"version": r,
-                    "full-revisionid": keywords["full"].strip(),
-                    "dirty": False, "error": None,
-                    "date": date}
-    # no suitable tags, so version is "0+unknown", but full hex is still there
-    if verbose:
-        print("no suitable tags, using unknown + full revision id")
-    return {"version": "0+unknown",
-            "full-revisionid": keywords["full"].strip(),
-            "dirty": False, "error": "no suitable tags", "date": None}
-
-
-@register_vcs_handler("git", "pieces_from_vcs")
-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
-    """Get version from 'git describe' in the root of the source tree.
-
-    This only gets called if the git-archive 'subst' keywords were *not*
-    expanded, and _version.py hasn't already been rewritten with a short
-    version string, meaning we're inside a checked out source tree.
-    """
-    GITS = ["git"]
-    if sys.platform == "win32":
-        GITS = ["git.cmd", "git.exe"]
-
-    out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
-                          hide_stderr=True)
-    if rc != 0:
-        if verbose:
-            print("Directory %s not under git control" % root)
-        raise NotThisMethod("'git rev-parse --git-dir' returned error")
-
-    # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
-    # if there isn't one, this yields HEX[-dirty] (no NUM)
-    describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",
-                                          "--always", "--long",
-                                          "--match", "%s*" % tag_prefix],
-                                   cwd=root)
-    # --long was added in git-1.5.5
-    if describe_out is None:
-        raise NotThisMethod("'git describe' failed")
-    describe_out = describe_out.strip()
-    full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
-    if full_out is None:
-        raise NotThisMethod("'git rev-parse' failed")
-    full_out = full_out.strip()
-
-    pieces = {}
-    pieces["long"] = full_out
-    pieces["short"] = full_out[:7]  # maybe improved later
-    pieces["error"] = None
-
-    # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
-    # TAG might have hyphens.
-    git_describe = describe_out
-
-    # look for -dirty suffix
-    dirty = git_describe.endswith("-dirty")
-    pieces["dirty"] = dirty
-    if dirty:
-        git_describe = git_describe[:git_describe.rindex("-dirty")]
-
-    # now we have TAG-NUM-gHEX or HEX
-
-    if "-" in git_describe:
-        # TAG-NUM-gHEX
-        mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
-        if not mo:
-            # unparseable. Maybe git-describe is misbehaving?
-            pieces["error"] = ("unable to parse git-describe output: '%s'"
-                               % describe_out)
-            return pieces
-
-        # tag
-        full_tag = mo.group(1)
-        if not full_tag.startswith(tag_prefix):
-            if verbose:
-                fmt = "tag '%s' doesn't start with prefix '%s'"
-                print(fmt % (full_tag, tag_prefix))
-            pieces["error"] = ("tag '%s' doesn't start with prefix '%s'"
-                               % (full_tag, tag_prefix))
-            return pieces
-        pieces["closest-tag"] = full_tag[len(tag_prefix):]
-
-        # distance: number of commits since tag
-        pieces["distance"] = int(mo.group(2))
-
-        # commit: short hex revision ID
-        pieces["short"] = mo.group(3)
-
-    else:
-        # HEX: no tags
-        pieces["closest-tag"] = None
-        count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
-                                    cwd=root)
-        pieces["distance"] = int(count_out)  # total number of commits
-
-    # commit date: see ISO-8601 comment in git_versions_from_keywords()
-    date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"],
-                       cwd=root)[0].strip()
-    pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
-
-    return pieces
-
-
-def plus_or_dot(pieces):
-    """Return a + if we don't already have one, else return a ."""
-    if "+" in pieces.get("closest-tag", ""):
-        return "."
-    return "+"
-
-
-def render_pep440(pieces):
-    """Build up version string, with post-release "local version identifier".
-
-    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
-    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty
-
-    Exceptions:
-    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]
-    """
-    if pieces["closest-tag"]:
-        rendered = pieces["closest-tag"]
-        if pieces["distance"] or pieces["dirty"]:
-            rendered += plus_or_dot(pieces)
-            rendered += "%d.g%s" % (pieces["distance"], pieces["short"])
-            if pieces["dirty"]:
-                rendered += ".dirty"
-    else:
-        # exception #1
-        rendered = "0+untagged.%d.g%s" % (pieces["distance"],
-                                          pieces["short"])
-        if pieces["dirty"]:
-            rendered += ".dirty"
-    return rendered
-
-
-def render_pep440_pre(pieces):
-    """TAG[.post.devDISTANCE] -- No -dirty.
-
-    Exceptions:
-    1: no tags. 0.post.devDISTANCE
-    """
-    if pieces["closest-tag"]:
-        rendered = pieces["closest-tag"]
-        if pieces["distance"]:
-            rendered += ".post.dev%d" % pieces["distance"]
-    else:
-        # exception #1
-        rendered = "0.post.dev%d" % pieces["distance"]
-    return rendered
-
-
-def render_pep440_post(pieces):
-    """TAG[.postDISTANCE[.dev0]+gHEX] .
-
-    The ".dev0" means dirty. Note that .dev0 sorts backwards
-    (a dirty tree will appear "older" than the corresponding clean one),
-    but you shouldn't be releasing software with -dirty anyways.
-
-    Exceptions:
-    1: no tags. 0.postDISTANCE[.dev0]
-    """
-    if pieces["closest-tag"]:
-        rendered = pieces["closest-tag"]
-        if pieces["distance"] or pieces["dirty"]:
-            rendered += ".post%d" % pieces["distance"]
-            if pieces["dirty"]:
-                rendered += ".dev0"
-            rendered += plus_or_dot(pieces)
-            rendered += "g%s" % pieces["short"]
-    else:
-        # exception #1
-        rendered = "0.post%d" % pieces["distance"]
-        if pieces["dirty"]:
-            rendered += ".dev0"
-        rendered += "+g%s" % pieces["short"]
-    return rendered
-
-
-def render_pep440_old(pieces):
-    """TAG[.postDISTANCE[.dev0]] .
-
-    The ".dev0" means dirty.
-
-    Eexceptions:
-    1: no tags. 0.postDISTANCE[.dev0]
-    """
-    if pieces["closest-tag"]:
-        rendered = pieces["closest-tag"]
-        if pieces["distance"] or pieces["dirty"]:
-            rendered += ".post%d" % pieces["distance"]
-            if pieces["dirty"]:
-                rendered += ".dev0"
-    else:
-        # exception #1
-        rendered = "0.post%d" % pieces["distance"]
-        if pieces["dirty"]:
-            rendered += ".dev0"
-    return rendered
-
-
-def render_git_describe(pieces):
-    """TAG[-DISTANCE-gHEX][-dirty].
-
-    Like 'git describe --tags --dirty --always'.
-
-    Exceptions:
-    1: no tags. HEX[-dirty]  (note: no 'g' prefix)
-    """
-    if pieces["closest-tag"]:
-        rendered = pieces["closest-tag"]
-        if pieces["distance"]:
-            rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
-    else:
-        # exception #1
-        rendered = pieces["short"]
-    if pieces["dirty"]:
-        rendered += "-dirty"
-    return rendered
-
-
-def render_git_describe_long(pieces):
-    """TAG-DISTANCE-gHEX[-dirty].
-
-    Like 'git describe --tags --dirty --always -long'.
-    The distance/hash is unconditional.
-
-    Exceptions:
-    1: no tags. HEX[-dirty]  (note: no 'g' prefix)
-    """
-    if pieces["closest-tag"]:
-        rendered = pieces["closest-tag"]
-        rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
-    else:
-        # exception #1
-        rendered = pieces["short"]
-    if pieces["dirty"]:
-        rendered += "-dirty"
-    return rendered
-
-
-def render(pieces, style):
-    """Render the given version pieces into the requested style."""
-    if pieces["error"]:
-        return {"version": "unknown",
-                "full-revisionid": pieces.get("long"),
-                "dirty": None,
-                "error": pieces["error"],
-                "date": None}
-
-    if not style or style == "default":
-        style = "pep440"  # the default
-
-    if style == "pep440":
-        rendered = render_pep440(pieces)
-    elif style == "pep440-pre":
-        rendered = render_pep440_pre(pieces)
-    elif style == "pep440-post":
-        rendered = render_pep440_post(pieces)
-    elif style == "pep440-old":
-        rendered = render_pep440_old(pieces)
-    elif style == "git-describe":
-        rendered = render_git_describe(pieces)
-    elif style == "git-describe-long":
-        rendered = render_git_describe_long(pieces)
-    else:
-        raise ValueError("unknown style '%s'" % style)
-
-    return {"version": rendered, "full-revisionid": pieces["long"],
-            "dirty": pieces["dirty"], "error": None,
-            "date": pieces.get("date")}
-
-
-def get_versions():
-    """Get version information or return default if unable to do so."""
-    # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
-    # __file__, we can work backwards from there to the root. Some
-    # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which
-    # case we can only use expanded keywords.
-
-    cfg = get_config()
-    verbose = cfg.verbose
-
-    try:
-        return git_versions_from_keywords(get_keywords(), cfg.tag_prefix,
-                                          verbose)
-    except NotThisMethod:
-        pass
-
-    try:
-        root = os.path.realpath(__file__)
-        # versionfile_source is the relative path from the top of the source
-        # tree (where the .git directory might live) to this file. Invert
-        # this to find the root from __file__.
-        for i in cfg.versionfile_source.split('/'):
-            root = os.path.dirname(root)
-    except NameError:
-        return {"version": "0+unknown", "full-revisionid": None,
-                "dirty": None,
-                "error": "unable to find root of source tree",
-                "date": None}
-
-    try:
-        pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)
-        return render(pieces, cfg.style)
-    except NotThisMethod:
-        pass
-
-    try:
-        if cfg.parentdir_prefix:
-            return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)
-    except NotThisMethod:
-        pass
-
-    return {"version": "0+unknown", "full-revisionid": None,
-            "dirty": None,
-            "error": "unable to compute version", "date": None}
diff --git a/numpy/random/randomgen/setup.py b/numpy/random/randomgen/setup.py
deleted file mode 100644
index 5b7be4559..000000000
--- a/numpy/random/randomgen/setup.py
+++ /dev/null
@@ -1,191 +0,0 @@
-from os.path import join
-import sys
-import os
-import platform
-import struct
-from distutils.dep_util import newer
-from distutils.msvccompiler import get_build_version as get_msvc_build_version
-
-def needs_mingw_ftime_workaround():
-    # We need the mingw workaround for _ftime if the msvc runtime version is
-    # 7.1 or above and we build with mingw ...
-    # ... but we can't easily detect compiler version outside distutils command
-    # context, so we will need to detect in randomkit whether we build with gcc
-    msver = get_msvc_build_version()
-    if msver and msver >= 8:
-        return True
-
-    return False
-
-
-def configuration(parent_package='',top_path=None):
-    from numpy.distutils.misc_util import Configuration, get_mathlibs
-    config = Configuration('randomgen', parent_package, top_path)
-
-    def generate_libraries(ext, build_dir):
-        config_cmd = config.get_config_cmd()
-        libs = get_mathlibs()
-        if sys.platform == 'win32':
-            libs.append('Advapi32')
-        ext.libraries.extend(libs)
-        return None
-
-    # enable unix large file support on 32 bit systems
-    # (64 bit off_t, lseek -> lseek64 etc.)
-    if sys.platform[:3] == "aix":
-        defs = [('_LARGE_FILES', None)]
-    else:
-        defs = [('_FILE_OFFSET_BITS', '64'),
-                ('_LARGEFILE_SOURCE', '1'),
-                ('_LARGEFILE64_SOURCE', '1')]
-    if needs_mingw_ftime_workaround():
-        defs.append(("NPY_NEEDS_MINGW_TIME_WORKAROUND", None))
-
-    libs = []
-    defs.append(('NPY_NO_DEPRECATED_API', 0))
-    config.add_data_dir('tests')
-
-    ##############################
-    # randomgen
-    ##############################
-
-    # Make a guess as to whether SSE2 is present for now, TODO: Improve
-    USE_SSE2 = False
-    for k in platform.uname():
-        for val in ('x86', 'i686', 'i386', 'amd64'):
-            USE_SSE2 = USE_SSE2 or val in k.lower()
-    print('Building with SSE?: {0}'.format(USE_SSE2))
-    if '--no-sse2' in sys.argv:
-        USE_SSE2 = False
-        sys.argv.remove('--no-sse2')
-
-    DEBUG = False
-    PCG_EMULATED_MATH = False
-    EXTRA_LINK_ARGS = []
-    EXTRA_LIBRARIES = ['m'] if os.name != 'nt' else []
-    EXTRA_COMPILE_ARGS = [] if os.name == 'nt' else [
-        '-std=c99', '-U__GNUC_GNU_INLINE__']
-    if os.name == 'nt':
-        EXTRA_LINK_ARGS = ['/LTCG', '/OPT:REF', 'Advapi32.lib', 'Kernel32.lib']
-        if DEBUG:
-            EXTRA_LINK_ARGS += ['-debug']
-            EXTRA_COMPILE_ARGS += ["-Zi", "/Od"]
-        if sys.version_info < (3, 0):
-            EXTRA_INCLUDE_DIRS += [join(MOD_DIR, 'src', 'common')]
-
-    PCG64_DEFS = []
-    # TODO: remove the unconditional forced emulation, move code from pcg64.pyx
-    # to an #ifdef
-    if 1 or sys.maxsize < 2 ** 32 or os.name == 'nt':
-        # Force emulated mode here
-        PCG_EMULATED_MATH = True
-        PCG64_DEFS += [('PCG_FORCE_EMULATED_128BIT_MATH', '1')]
-    
-    if struct.calcsize('P') < 8:
-        PCG_EMULATED_MATH = True
-    defs.append(('PCG_EMULATED_MATH', int(PCG_EMULATED_MATH)))
-
-    DSFMT_DEFS = [('DSFMT_MEXP', '19937')]
-    if USE_SSE2:
-        if os.name == 'nt':
-            EXTRA_COMPILE_ARGS += ['/wd4146', '/GL']
-            if struct.calcsize('P') < 8:
-                EXTRA_COMPILE_ARGS += ['/arch:SSE2']
-        else:
-            EXTRA_COMPILE_ARGS += ['-msse2']
-        DSFMT_DEFS += [('HAVE_SSE2', '1')]
-
-    config.add_extension('entropy',
-                        sources=['entropy.c', 'src/entropy/entropy.c'],
-                        include_dirs=[join('randomgen', 'src', 'entropy')],
-                        libraries=EXTRA_LIBRARIES,
-                        extra_compile_args=EXTRA_COMPILE_ARGS,
-                        extra_link_args=EXTRA_LINK_ARGS,
-                        depends=[join('src', 'splitmix64', 'splitmix.h'),
-                                 join('src', 'entropy', 'entropy.h'),
-                                 'entropy.pyx',
-                                ],
-                        define_macros=defs,
-                        )
-    config.add_extension('dsfmt',
-                        sources=['dsfmt.c', 'src/dsfmt/dSFMT.c',
-                             'src/dsfmt/dSFMT-jump.c',
-                             'src/aligned_malloc/aligned_malloc.c'],
-                        include_dirs=[join('src', 'dsfmt')],
-                        libraries=EXTRA_LIBRARIES,
-                        extra_compile_args=EXTRA_COMPILE_ARGS,
-                        extra_link_args=EXTRA_LINK_ARGS,
-                        depends=[join('src', 'dsfmt', 'dsfmt.h'),
-                                 'dsfmt.pyx',
-                                ],
-                        define_macros=defs + DSFMT_DEFS,
-                        )
-    for gen in ['mt19937']:
-        # gen.pyx, src/gen/gen.c, src/gen/gen-jump.c
-        config.add_extension(gen,
-                        sources=['{0}.c'.format(gen), 'src/{0}/{0}.c'.format(gen),
-                             'src/{0}/{0}-jump.c'.format(gen)],
-                        include_dirs=[join('src', gen)],
-                        libraries=EXTRA_LIBRARIES,
-                        extra_compile_args=EXTRA_COMPILE_ARGS,
-                        extra_link_args=EXTRA_LINK_ARGS,
-                        depends=['%s.pyx' % gen],
-                        define_macros=defs,
-                        )
-    for gen in ['philox', 'threefry', 'threefry32',
-                'xoroshiro128', 'xorshift1024', 'xoshiro256starstar',
-                'xoshiro512starstar',
-                'pcg64', 'pcg32',
-               ]:
-        # gen.pyx, src/gen/gen.c
-        if gen == 'pcg64':
-            _defs = defs + PCG64_DEFS
-        else:
-            _defs = defs
-        config.add_extension(gen,
-                        sources=['{0}.c'.format(gen), 'src/{0}/{0}.c'.format(gen)],
-                        include_dirs=[join('src', gen)],
-                        libraries=EXTRA_LIBRARIES,
-                        extra_compile_args=EXTRA_COMPILE_ARGS,
-                        extra_link_args=EXTRA_LINK_ARGS,
-                        depends=['%s.pyx' % gen],
-                        define_macros=_defs,
-                        )
-    for gen in ['common']:
-        # gen.pyx
-        config.add_extension(gen,
-                        sources=['{0}.c'.format(gen)],
-                        libraries=EXTRA_LIBRARIES,
-                        extra_compile_args=EXTRA_COMPILE_ARGS,
-                        extra_link_args=EXTRA_LINK_ARGS,
-                        depends=['%s.pyx' % gen],
-                        define_macros=defs,
-                        )
-    for gen in ['generator', 'bounded_integers']:
-        # gen.pyx, src/distributions/distributions.c
-        config.add_extension(gen,
-                        sources=['{0}.c'.format(gen),
-                                 join('src', 'distributions',
-                                      'distributions.c')],
-                        libraries=EXTRA_LIBRARIES,
-                        extra_compile_args=EXTRA_COMPILE_ARGS,
-                        extra_link_args=EXTRA_LINK_ARGS,
-                        depends=['%s.pyx' % gen],
-                        define_macros=defs,
-                        )
-    config.add_extension('mtrand',
-                        sources=['mtrand.c',
-                             'src/legacy/distributions-boxmuller.c',
-                             'src/distributions/distributions.c' ],
-                        include_dirs=['.', 'legacy'],
-                        libraries=EXTRA_LIBRARIES,
-                        extra_compile_args=EXTRA_COMPILE_ARGS,
-                        extra_link_args=EXTRA_LINK_ARGS,
-                        depends=['mtrand.pyx'],
-                        define_macros=defs + DSFMT_DEFS,
-                        )
-    config.add_subpackage('legacy')
-    return config
-if __name__ == '__main__':
-    from numpy.distutils.core import setup
-    setup(configuration=configuration)
diff --git a/numpy/random/randomgen/tests/data/__init__.py b/numpy/random/randomgen/tests/data/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/numpy/random/randomgen/tests/data/__init__.py
+++ /dev/null
diff --git a/numpy/random/setup.py b/numpy/random/setup.py
index 481c4e380..088764791 100644
--- a/numpy/random/setup.py
+++ b/numpy/random/setup.py
@@ -46,21 +46,160 @@ def configuration(parent_package='',top_path=None):
     libs = []
     defs.append(('NPY_NO_DEPRECATED_API', 0))
     # Configure mtrand
-    config.add_extension('mtrand',
-                         sources=[join('mtrand', x) for x in
+    config.add_extension('_mtrand',
+                         sources=[join('_mtrand', x) for x in
                                   ['mtrand.c', 'randomkit.c', 'initarray.c',
                                    'distributions.c']]+[generate_libraries],
                          libraries=libs,
-                         depends=[join('mtrand', '*.h'),
-                                  join('mtrand', '*.pyx'),
-                                  join('mtrand', '*.pxi'),],
+                         depends=[join('_mtrand', '*.h'),
+                                  join('_mtrand', '*.pyx'),
+                                  join('_mtrand', '*.pxi'),],
                          define_macros=defs,
                          )
 
-    config.add_data_files(('.', join('mtrand', 'randomkit.h')))
+    config.add_data_files(('.', join('_mtrand', 'randomkit.h')))
     config.add_data_dir('tests')
 
-    config.add_subpackage('randomgen')
+    ##############################
+    # randomgen
+    ##############################
+
+    # Make a guess as to whether SSE2 is present for now, TODO: Improve
+    USE_SSE2 = False
+    for k in platform.uname():
+        for val in ('x86', 'i686', 'i386', 'amd64'):
+            USE_SSE2 = USE_SSE2 or val in k.lower()
+    print('Building with SSE?: {0}'.format(USE_SSE2))
+    if '--no-sse2' in sys.argv:
+        USE_SSE2 = False
+        sys.argv.remove('--no-sse2')
+
+    DEBUG = False
+    PCG_EMULATED_MATH = False
+    EXTRA_LINK_ARGS = []
+    EXTRA_LIBRARIES = ['m'] if os.name != 'nt' else []
+    EXTRA_COMPILE_ARGS = [] if os.name == 'nt' else [
+        '-std=c99', '-U__GNUC_GNU_INLINE__']
+    if os.name == 'nt':
+        EXTRA_LINK_ARGS = ['/LTCG', '/OPT:REF', 'Advapi32.lib', 'Kernel32.lib']
+        if DEBUG:
+            EXTRA_LINK_ARGS += ['-debug']
+            EXTRA_COMPILE_ARGS += ["-Zi", "/Od"]
+        if sys.version_info < (3, 0):
+            EXTRA_INCLUDE_DIRS += [join(MOD_DIR, 'src', 'common')]
+
+    PCG64_DEFS = []
+    # TODO: remove the unconditional forced emulation, move code from pcg64.pyx
+    # to an #ifdef
+    if 1 or sys.maxsize < 2 ** 32 or os.name == 'nt':
+        # Force emulated mode here
+        PCG_EMULATED_MATH = True
+        PCG64_DEFS += [('PCG_FORCE_EMULATED_128BIT_MATH', '1')]
+    
+    if struct.calcsize('P') < 8:
+        PCG_EMULATED_MATH = True
+    defs.append(('PCG_EMULATED_MATH', int(PCG_EMULATED_MATH)))
+
+    DSFMT_DEFS = [('DSFMT_MEXP', '19937')]
+    if USE_SSE2:
+        if os.name == 'nt':
+            EXTRA_COMPILE_ARGS += ['/wd4146', '/GL']
+            if struct.calcsize('P') < 8:
+                EXTRA_COMPILE_ARGS += ['/arch:SSE2']
+        else:
+            EXTRA_COMPILE_ARGS += ['-msse2']
+        DSFMT_DEFS += [('HAVE_SSE2', '1')]
+
+    config.add_extension('entropy',
+                        sources=['entropy.c', 'src/entropy/entropy.c'],
+                        include_dirs=[join('randomgen', 'src', 'entropy')],
+                        libraries=EXTRA_LIBRARIES,
+                        extra_compile_args=EXTRA_COMPILE_ARGS,
+                        extra_link_args=EXTRA_LINK_ARGS,
+                        depends=[join('src', 'splitmix64', 'splitmix.h'),
+                                 join('src', 'entropy', 'entropy.h'),
+                                 'entropy.pyx',
+                                ],
+                        define_macros=defs,
+                        )
+    config.add_extension('dsfmt',
+                        sources=['dsfmt.c', 'src/dsfmt/dSFMT.c',
+                             'src/dsfmt/dSFMT-jump.c',
+                             'src/aligned_malloc/aligned_malloc.c'],
+                        include_dirs=[join('src', 'dsfmt')],
+                        libraries=EXTRA_LIBRARIES,
+                        extra_compile_args=EXTRA_COMPILE_ARGS,
+                        extra_link_args=EXTRA_LINK_ARGS,
+                        depends=[join('src', 'dsfmt', 'dsfmt.h'),
+                                 'dsfmt.pyx',
+                                ],
+                        define_macros=defs + DSFMT_DEFS,
+                        )
+    for gen in ['mt19937']:
+        # gen.pyx, src/gen/gen.c, src/gen/gen-jump.c
+        config.add_extension(gen,
+                        sources=['{0}.c'.format(gen), 'src/{0}/{0}.c'.format(gen),
+                             'src/{0}/{0}-jump.c'.format(gen)],
+                        include_dirs=[join('src', gen)],
+                        libraries=EXTRA_LIBRARIES,
+                        extra_compile_args=EXTRA_COMPILE_ARGS,
+                        extra_link_args=EXTRA_LINK_ARGS,
+                        depends=['%s.pyx' % gen],
+                        define_macros=defs,
+                        )
+    for gen in ['philox', 'threefry', 'threefry32',
+                'xoroshiro128', 'xorshift1024', 'xoshiro256starstar',
+                'xoshiro512starstar',
+                'pcg64', 'pcg32',
+               ]:
+        # gen.pyx, src/gen/gen.c
+        if gen == 'pcg64':
+            _defs = defs + PCG64_DEFS
+        else:
+            _defs = defs
+        config.add_extension(gen,
+                        sources=['{0}.c'.format(gen), 'src/{0}/{0}.c'.format(gen)],
+                        include_dirs=[join('src', gen)],
+                        libraries=EXTRA_LIBRARIES,
+                        extra_compile_args=EXTRA_COMPILE_ARGS,
+                        extra_link_args=EXTRA_LINK_ARGS,
+                        depends=['%s.pyx' % gen],
+                        define_macros=_defs,
+                        )
+    for gen in ['common']:
+        # gen.pyx
+        config.add_extension(gen,
+                        sources=['{0}.c'.format(gen)],
+                        libraries=EXTRA_LIBRARIES,
+                        extra_compile_args=EXTRA_COMPILE_ARGS,
+                        extra_link_args=EXTRA_LINK_ARGS,
+                        depends=['%s.pyx' % gen],
+                        define_macros=defs,
+                        )
+    for gen in ['generator', 'bounded_integers']:
+        # gen.pyx, src/distributions/distributions.c
+        config.add_extension(gen,
+                        sources=['{0}.c'.format(gen),
+                                 join('src', 'distributions',
+                                      'distributions.c')],
+                        libraries=EXTRA_LIBRARIES,
+                        extra_compile_args=EXTRA_COMPILE_ARGS,
+                        extra_link_args=EXTRA_LINK_ARGS,
+                        depends=['%s.pyx' % gen],
+                        define_macros=defs,
+                        )
+    config.add_extension('mtrand',
+                        sources=['mtrand.c',
+                             'src/legacy/distributions-boxmuller.c',
+                             'src/distributions/distributions.c' ],
+                        include_dirs=['.', 'legacy'],
+                        libraries=EXTRA_LIBRARIES,
+                        extra_compile_args=EXTRA_COMPILE_ARGS,
+                        extra_link_args=EXTRA_LINK_ARGS,
+                        depends=['mtrand.pyx'],
+                        define_macros=defs + DSFMT_DEFS,
+                        )
+    config.add_subpackage('legacy')
     return config
 
 if __name__ == '__main__':
diff --git a/numpy/random/randomgen/src/aligned_malloc/aligned_malloc.c b/numpy/random/src/aligned_malloc/aligned_malloc.c
index 6e8192cfb..6e8192cfb 100644
--- a/numpy/random/randomgen/src/aligned_malloc/aligned_malloc.c
+++ b/numpy/random/src/aligned_malloc/aligned_malloc.c
diff --git a/numpy/random/randomgen/src/aligned_malloc/aligned_malloc.h b/numpy/random/src/aligned_malloc/aligned_malloc.h
index ea24f6d23..ea24f6d23 100644
--- a/numpy/random/randomgen/src/aligned_malloc/aligned_malloc.h
+++ b/numpy/random/src/aligned_malloc/aligned_malloc.h
diff --git a/numpy/random/randomgen/src/common/LICENSE.md b/numpy/random/src/common/LICENSE.md
index 71bf8cf46..71bf8cf46 100644
--- a/numpy/random/randomgen/src/common/LICENSE.md
+++ b/numpy/random/src/common/LICENSE.md
diff --git a/numpy/random/randomgen/src/common/inttypes.h b/numpy/random/src/common/inttypes.h
index 8f8b61108..8f8b61108 100644
--- a/numpy/random/randomgen/src/common/inttypes.h
+++ b/numpy/random/src/common/inttypes.h
diff --git a/numpy/random/randomgen/src/common/stdint.h b/numpy/random/src/common/stdint.h
index 710de1570..710de1570 100644
--- a/numpy/random/randomgen/src/common/stdint.h
+++ b/numpy/random/src/common/stdint.h
diff --git a/numpy/random/randomgen/src/distributions/LICENSE.md b/numpy/random/src/distributions/LICENSE.md
index 31576ba4b..31576ba4b 100644
--- a/numpy/random/randomgen/src/distributions/LICENSE.md
+++ b/numpy/random/src/distributions/LICENSE.md
diff --git a/numpy/random/randomgen/src/distributions/binomial.h b/numpy/random/src/distributions/binomial.h
index e69de29bb..e69de29bb 100644
--- a/numpy/random/randomgen/src/distributions/binomial.h
+++ b/numpy/random/src/distributions/binomial.h
diff --git a/numpy/random/randomgen/src/distributions/distributions.c b/numpy/random/src/distributions/distributions.c
index 83806de38..83806de38 100644
--- a/numpy/random/randomgen/src/distributions/distributions.c
+++ b/numpy/random/src/distributions/distributions.c
diff --git a/numpy/random/randomgen/src/distributions/distributions.h b/numpy/random/src/distributions/distributions.h
index 7ca31a16c..7ca31a16c 100644
--- a/numpy/random/randomgen/src/distributions/distributions.h
+++ b/numpy/random/src/distributions/distributions.h
diff --git a/numpy/random/randomgen/src/distributions/ziggurat.h b/numpy/random/src/distributions/ziggurat.h
index 7808c0e68..7808c0e68 100644
--- a/numpy/random/randomgen/src/distributions/ziggurat.h
+++ b/numpy/random/src/distributions/ziggurat.h
diff --git a/numpy/random/randomgen/src/distributions/ziggurat_constants.h b/numpy/random/src/distributions/ziggurat_constants.h
index 17eccec0f..17eccec0f 100644
--- a/numpy/random/randomgen/src/distributions/ziggurat_constants.h
+++ b/numpy/random/src/distributions/ziggurat_constants.h
diff --git a/numpy/random/randomgen/src/dsfmt/128-bit-jump.poly.txt b/numpy/random/src/dsfmt/128-bit-jump.poly.txt
index fea1318fb..fea1318fb 100644
--- a/numpy/random/randomgen/src/dsfmt/128-bit-jump.poly.txt
+++ b/numpy/random/src/dsfmt/128-bit-jump.poly.txt
diff --git a/numpy/random/randomgen/src/dsfmt/96-bit-jump.poly.txt b/numpy/random/src/dsfmt/96-bit-jump.poly.txt
index 15c68d155..15c68d155 100644
--- a/numpy/random/randomgen/src/dsfmt/96-bit-jump.poly.txt
+++ b/numpy/random/src/dsfmt/96-bit-jump.poly.txt
diff --git a/numpy/random/randomgen/src/dsfmt/LICENSE.md b/numpy/random/src/dsfmt/LICENSE.md
index d59568f6b..d59568f6b 100644
--- a/numpy/random/randomgen/src/dsfmt/LICENSE.md
+++ b/numpy/random/src/dsfmt/LICENSE.md
diff --git a/numpy/random/randomgen/src/dsfmt/calc-jump.cpp b/numpy/random/src/dsfmt/calc-jump.cpp
index 495b2797c..495b2797c 100644
--- a/numpy/random/randomgen/src/dsfmt/calc-jump.cpp
+++ b/numpy/random/src/dsfmt/calc-jump.cpp
diff --git a/numpy/random/randomgen/src/dsfmt/dSFMT-benchmark.c b/numpy/random/src/dsfmt/dSFMT-benchmark.c
index af29d0e1f..af29d0e1f 100644
--- a/numpy/random/randomgen/src/dsfmt/dSFMT-benchmark.c
+++ b/numpy/random/src/dsfmt/dSFMT-benchmark.c
diff --git a/numpy/random/randomgen/src/dsfmt/dSFMT-calc-jump.hpp b/numpy/random/src/dsfmt/dSFMT-calc-jump.hpp
index b960826be..b960826be 100644
--- a/numpy/random/randomgen/src/dsfmt/dSFMT-calc-jump.hpp
+++ b/numpy/random/src/dsfmt/dSFMT-calc-jump.hpp
diff --git a/numpy/random/randomgen/src/dsfmt/dSFMT-common.h b/numpy/random/src/dsfmt/dSFMT-common.h
index 30c26c08b..30c26c08b 100644
--- a/numpy/random/randomgen/src/dsfmt/dSFMT-common.h
+++ b/numpy/random/src/dsfmt/dSFMT-common.h
diff --git a/numpy/random/randomgen/src/dsfmt/dSFMT-jump.c b/numpy/random/src/dsfmt/dSFMT-jump.c
index 1832bb885..1832bb885 100644
--- a/numpy/random/randomgen/src/dsfmt/dSFMT-jump.c
+++ b/numpy/random/src/dsfmt/dSFMT-jump.c
diff --git a/numpy/random/randomgen/src/dsfmt/dSFMT-jump.h b/numpy/random/src/dsfmt/dSFMT-jump.h
index 689f9499a..689f9499a 100644
--- a/numpy/random/randomgen/src/dsfmt/dSFMT-jump.h
+++ b/numpy/random/src/dsfmt/dSFMT-jump.h
diff --git a/numpy/random/randomgen/src/dsfmt/dSFMT-params.h b/numpy/random/src/dsfmt/dSFMT-params.h
index aa0247800..aa0247800 100644
--- a/numpy/random/randomgen/src/dsfmt/dSFMT-params.h
+++ b/numpy/random/src/dsfmt/dSFMT-params.h
diff --git a/numpy/random/randomgen/src/dsfmt/dSFMT-params19937.h b/numpy/random/src/dsfmt/dSFMT-params19937.h
index a600b0dbc..a600b0dbc 100644
--- a/numpy/random/randomgen/src/dsfmt/dSFMT-params19937.h
+++ b/numpy/random/src/dsfmt/dSFMT-params19937.h
diff --git a/numpy/random/randomgen/src/dsfmt/dSFMT-poly.h b/numpy/random/src/dsfmt/dSFMT-poly.h
index f8e15c3eb..f8e15c3eb 100644
--- a/numpy/random/randomgen/src/dsfmt/dSFMT-poly.h
+++ b/numpy/random/src/dsfmt/dSFMT-poly.h
diff --git a/numpy/random/randomgen/src/dsfmt/dSFMT-test-gen.c b/numpy/random/src/dsfmt/dSFMT-test-gen.c
index 697a3010a..697a3010a 100644
--- a/numpy/random/randomgen/src/dsfmt/dSFMT-test-gen.c
+++ b/numpy/random/src/dsfmt/dSFMT-test-gen.c
diff --git a/numpy/random/randomgen/src/dsfmt/dSFMT.c b/numpy/random/src/dsfmt/dSFMT.c
index 0f122c26c..0f122c26c 100644
--- a/numpy/random/randomgen/src/dsfmt/dSFMT.c
+++ b/numpy/random/src/dsfmt/dSFMT.c
diff --git a/numpy/random/randomgen/src/dsfmt/dSFMT.h b/numpy/random/src/dsfmt/dSFMT.h
index 224d0108f..224d0108f 100644
--- a/numpy/random/randomgen/src/dsfmt/dSFMT.h
+++ b/numpy/random/src/dsfmt/dSFMT.h
diff --git a/numpy/random/randomgen/src/entropy/LICENSE.md b/numpy/random/src/entropy/LICENSE.md
index b7276aad7..b7276aad7 100644
--- a/numpy/random/randomgen/src/entropy/LICENSE.md
+++ b/numpy/random/src/entropy/LICENSE.md
diff --git a/numpy/random/randomgen/src/entropy/entropy.c b/numpy/random/src/entropy/entropy.c
index ead4bef83..ead4bef83 100644
--- a/numpy/random/randomgen/src/entropy/entropy.c
+++ b/numpy/random/src/entropy/entropy.c
diff --git a/numpy/random/randomgen/src/entropy/entropy.h b/numpy/random/src/entropy/entropy.h
index 785603dd3..785603dd3 100644
--- a/numpy/random/randomgen/src/entropy/entropy.h
+++ b/numpy/random/src/entropy/entropy.h
diff --git a/numpy/random/randomgen/src/legacy/LICENSE.md b/numpy/random/src/legacy/LICENSE.md
index 88b1791b2..88b1791b2 100644
--- a/numpy/random/randomgen/src/legacy/LICENSE.md
+++ b/numpy/random/src/legacy/LICENSE.md
diff --git a/numpy/random/randomgen/src/legacy/distributions-boxmuller.c b/numpy/random/src/legacy/distributions-boxmuller.c
index 5d3ba27f8..5d3ba27f8 100644
--- a/numpy/random/randomgen/src/legacy/distributions-boxmuller.c
+++ b/numpy/random/src/legacy/distributions-boxmuller.c
diff --git a/numpy/random/randomgen/src/legacy/distributions-boxmuller.h b/numpy/random/src/legacy/distributions-boxmuller.h
index 445686e6c..445686e6c 100644
--- a/numpy/random/randomgen/src/legacy/distributions-boxmuller.h
+++ b/numpy/random/src/legacy/distributions-boxmuller.h
diff --git a/numpy/random/randomgen/src/mt19937/LICENSE.md b/numpy/random/src/mt19937/LICENSE.md
index f65c3d46e..f65c3d46e 100644
--- a/numpy/random/randomgen/src/mt19937/LICENSE.md
+++ b/numpy/random/src/mt19937/LICENSE.md
diff --git a/numpy/random/randomgen/src/mt19937/mt19937-benchmark.c b/numpy/random/src/mt19937/mt19937-benchmark.c
index 039f8030a..039f8030a 100644
--- a/numpy/random/randomgen/src/mt19937/mt19937-benchmark.c
+++ b/numpy/random/src/mt19937/mt19937-benchmark.c
diff --git a/numpy/random/randomgen/src/mt19937/mt19937-jump.c b/numpy/random/src/mt19937/mt19937-jump.c
index 46b28cf96..46b28cf96 100644
--- a/numpy/random/randomgen/src/mt19937/mt19937-jump.c
+++ b/numpy/random/src/mt19937/mt19937-jump.c
diff --git a/numpy/random/randomgen/src/mt19937/mt19937-jump.h b/numpy/random/src/mt19937/mt19937-jump.h
index 394c150a0..394c150a0 100644
--- a/numpy/random/randomgen/src/mt19937/mt19937-jump.h
+++ b/numpy/random/src/mt19937/mt19937-jump.h
diff --git a/numpy/random/randomgen/src/mt19937/mt19937-poly.h b/numpy/random/src/mt19937/mt19937-poly.h
index b03747881..b03747881 100644
--- a/numpy/random/randomgen/src/mt19937/mt19937-poly.h
+++ b/numpy/random/src/mt19937/mt19937-poly.h
diff --git a/numpy/random/randomgen/src/mt19937/mt19937-test-data-gen.c b/numpy/random/src/mt19937/mt19937-test-data-gen.c
index 4f4ec1d64..4f4ec1d64 100644
--- a/numpy/random/randomgen/src/mt19937/mt19937-test-data-gen.c
+++ b/numpy/random/src/mt19937/mt19937-test-data-gen.c
diff --git a/numpy/random/randomgen/src/mt19937/mt19937.c b/numpy/random/src/mt19937/mt19937.c
index e5ca9e0cf..e5ca9e0cf 100644
--- a/numpy/random/randomgen/src/mt19937/mt19937.c
+++ b/numpy/random/src/mt19937/mt19937.c
diff --git a/numpy/random/randomgen/src/mt19937/mt19937.h b/numpy/random/src/mt19937/mt19937.h
index 8105329ec..8105329ec 100644
--- a/numpy/random/randomgen/src/mt19937/mt19937.h
+++ b/numpy/random/src/mt19937/mt19937.h
diff --git a/numpy/random/randomgen/src/mt19937/randomkit.c b/numpy/random/src/mt19937/randomkit.c
index f8ed4b49e..f8ed4b49e 100644
--- a/numpy/random/randomgen/src/mt19937/randomkit.c
+++ b/numpy/random/src/mt19937/randomkit.c
diff --git a/numpy/random/randomgen/src/mt19937/randomkit.h b/numpy/random/src/mt19937/randomkit.h
index abb082cb2..abb082cb2 100644
--- a/numpy/random/randomgen/src/mt19937/randomkit.h
+++ b/numpy/random/src/mt19937/randomkit.h
diff --git a/numpy/random/randomgen/src/pcg32/LICENSE.md b/numpy/random/src/pcg32/LICENSE.md
index 3db2ac2e8..3db2ac2e8 100644
--- a/numpy/random/randomgen/src/pcg32/LICENSE.md
+++ b/numpy/random/src/pcg32/LICENSE.md
diff --git a/numpy/random/randomgen/src/pcg32/pcg-advance-64.c b/numpy/random/src/pcg32/pcg-advance-64.c
index 8210e7565..8210e7565 100644
--- a/numpy/random/randomgen/src/pcg32/pcg-advance-64.c
+++ b/numpy/random/src/pcg32/pcg-advance-64.c
diff --git a/numpy/random/randomgen/src/pcg32/pcg32-test-data-gen.c b/numpy/random/src/pcg32/pcg32-test-data-gen.c
index cccaf84b9..cccaf84b9 100644
--- a/numpy/random/randomgen/src/pcg32/pcg32-test-data-gen.c
+++ b/numpy/random/src/pcg32/pcg32-test-data-gen.c
diff --git a/numpy/random/randomgen/src/pcg32/pcg32.c b/numpy/random/src/pcg32/pcg32.c
index 5fbf6759f..5fbf6759f 100644
--- a/numpy/random/randomgen/src/pcg32/pcg32.c
+++ b/numpy/random/src/pcg32/pcg32.c
diff --git a/numpy/random/randomgen/src/pcg32/pcg32.h b/numpy/random/src/pcg32/pcg32.h
index 557113d8f..557113d8f 100644
--- a/numpy/random/randomgen/src/pcg32/pcg32.h
+++ b/numpy/random/src/pcg32/pcg32.h
diff --git a/numpy/random/randomgen/src/pcg32/pcg_variants.h b/numpy/random/src/pcg32/pcg_variants.h
index 32daac1ce..32daac1ce 100644
--- a/numpy/random/randomgen/src/pcg32/pcg_variants.h
+++ b/numpy/random/src/pcg32/pcg_variants.h
diff --git a/numpy/random/randomgen/src/pcg64/LICENSE.md b/numpy/random/src/pcg64/LICENSE.md
index dd6a17ee8..dd6a17ee8 100644
--- a/numpy/random/randomgen/src/pcg64/LICENSE.md
+++ b/numpy/random/src/pcg64/LICENSE.md
diff --git a/numpy/random/randomgen/src/pcg64/pcg64-benchmark.c b/numpy/random/src/pcg64/pcg64-benchmark.c
index 76f3ec78c..76f3ec78c 100644
--- a/numpy/random/randomgen/src/pcg64/pcg64-benchmark.c
+++ b/numpy/random/src/pcg64/pcg64-benchmark.c
diff --git a/numpy/random/randomgen/src/pcg64/pcg64-test-data-gen.c b/numpy/random/src/pcg64/pcg64-test-data-gen.c
index 0c2b079a3..0c2b079a3 100644
--- a/numpy/random/randomgen/src/pcg64/pcg64-test-data-gen.c
+++ b/numpy/random/src/pcg64/pcg64-test-data-gen.c
diff --git a/numpy/random/randomgen/src/pcg64/pcg64.c b/numpy/random/src/pcg64/pcg64.c
index c7c1eb045..c7c1eb045 100644
--- a/numpy/random/randomgen/src/pcg64/pcg64.c
+++ b/numpy/random/src/pcg64/pcg64.c
diff --git a/numpy/random/randomgen/src/pcg64/pcg64.h b/numpy/random/src/pcg64/pcg64.h
index 156c73a36..156c73a36 100644
--- a/numpy/random/randomgen/src/pcg64/pcg64.h
+++ b/numpy/random/src/pcg64/pcg64.h
diff --git a/numpy/random/randomgen/src/pcg64/pcg64.orig.c b/numpy/random/src/pcg64/pcg64.orig.c
index 07e97e4b6..07e97e4b6 100644
--- a/numpy/random/randomgen/src/pcg64/pcg64.orig.c
+++ b/numpy/random/src/pcg64/pcg64.orig.c
diff --git a/numpy/random/randomgen/src/pcg64/pcg64.orig.h b/numpy/random/src/pcg64/pcg64.orig.h
index 74be91f31..74be91f31 100644
--- a/numpy/random/randomgen/src/pcg64/pcg64.orig.h
+++ b/numpy/random/src/pcg64/pcg64.orig.h
diff --git a/numpy/random/randomgen/src/philox/LICENSE.md b/numpy/random/src/philox/LICENSE.md
index 4a9f6bb29..4a9f6bb29 100644
--- a/numpy/random/randomgen/src/philox/LICENSE.md
+++ b/numpy/random/src/philox/LICENSE.md
diff --git a/numpy/random/randomgen/src/philox/philox-benchmark.c b/numpy/random/src/philox/philox-benchmark.c
index 0cab04cf5..0cab04cf5 100644
--- a/numpy/random/randomgen/src/philox/philox-benchmark.c
+++ b/numpy/random/src/philox/philox-benchmark.c
diff --git a/numpy/random/randomgen/src/philox/philox-test-data-gen.c b/numpy/random/src/philox/philox-test-data-gen.c
index 442e18b55..442e18b55 100644
--- a/numpy/random/randomgen/src/philox/philox-test-data-gen.c
+++ b/numpy/random/src/philox/philox-test-data-gen.c
diff --git a/numpy/random/randomgen/src/philox/philox.c b/numpy/random/src/philox/philox.c
index 3382c60d6..3382c60d6 100644
--- a/numpy/random/randomgen/src/philox/philox.c
+++ b/numpy/random/src/philox/philox.c
diff --git a/numpy/random/randomgen/src/philox/philox.h b/numpy/random/src/philox/philox.h
index 411404b55..411404b55 100644
--- a/numpy/random/randomgen/src/philox/philox.h
+++ b/numpy/random/src/philox/philox.h
diff --git a/numpy/random/randomgen/src/splitmix64/LICENSE.md b/numpy/random/src/splitmix64/LICENSE.md
index 3c4d73b92..3c4d73b92 100644
--- a/numpy/random/randomgen/src/splitmix64/LICENSE.md
+++ b/numpy/random/src/splitmix64/LICENSE.md
diff --git a/numpy/random/randomgen/src/splitmix64/splitmix64.c b/numpy/random/src/splitmix64/splitmix64.c
index 79a845982..79a845982 100644
--- a/numpy/random/randomgen/src/splitmix64/splitmix64.c
+++ b/numpy/random/src/splitmix64/splitmix64.c
diff --git a/numpy/random/randomgen/src/splitmix64/splitmix64.h b/numpy/random/src/splitmix64/splitmix64.h
index 880132970..880132970 100644
--- a/numpy/random/randomgen/src/splitmix64/splitmix64.h
+++ b/numpy/random/src/splitmix64/splitmix64.h
diff --git a/numpy/random/randomgen/src/splitmix64/splitmix64.orig.c b/numpy/random/src/splitmix64/splitmix64.orig.c
index df6133aab..df6133aab 100644
--- a/numpy/random/randomgen/src/splitmix64/splitmix64.orig.c
+++ b/numpy/random/src/splitmix64/splitmix64.orig.c
diff --git a/numpy/random/randomgen/src/threefry/LICENSE.md b/numpy/random/src/threefry/LICENSE.md
index 4a9f6bb29..4a9f6bb29 100644
--- a/numpy/random/randomgen/src/threefry/LICENSE.md
+++ b/numpy/random/src/threefry/LICENSE.md
diff --git a/numpy/random/randomgen/src/threefry/threefry-benchmark.c b/numpy/random/src/threefry/threefry-benchmark.c
index 6d6239cd3..6d6239cd3 100644
--- a/numpy/random/randomgen/src/threefry/threefry-benchmark.c
+++ b/numpy/random/src/threefry/threefry-benchmark.c
diff --git a/numpy/random/randomgen/src/threefry/threefry-orig.c b/numpy/random/src/threefry/threefry-orig.c
index d27cfd797..d27cfd797 100644
--- a/numpy/random/randomgen/src/threefry/threefry-orig.c
+++ b/numpy/random/src/threefry/threefry-orig.c
diff --git a/numpy/random/randomgen/src/threefry/threefry-test-data-gen.c b/numpy/random/src/threefry/threefry-test-data-gen.c
index 328eb2575..328eb2575 100644
--- a/numpy/random/randomgen/src/threefry/threefry-test-data-gen.c
+++ b/numpy/random/src/threefry/threefry-test-data-gen.c
diff --git a/numpy/random/randomgen/src/threefry/threefry.c b/numpy/random/src/threefry/threefry.c
index 19c37df1b..19c37df1b 100644
--- a/numpy/random/randomgen/src/threefry/threefry.c
+++ b/numpy/random/src/threefry/threefry.c
diff --git a/numpy/random/randomgen/src/threefry/threefry.h b/numpy/random/src/threefry/threefry.h
index 297c1241a..297c1241a 100644
--- a/numpy/random/randomgen/src/threefry/threefry.h
+++ b/numpy/random/src/threefry/threefry.h
diff --git a/numpy/random/randomgen/src/threefry32/LICENSE.md b/numpy/random/src/threefry32/LICENSE.md
index 591cd75f4..591cd75f4 100644
--- a/numpy/random/randomgen/src/threefry32/LICENSE.md
+++ b/numpy/random/src/threefry32/LICENSE.md
diff --git a/numpy/random/randomgen/src/threefry32/threefry32-test-data-gen.c b/numpy/random/src/threefry32/threefry32-test-data-gen.c
index 0e6229995..0e6229995 100644
--- a/numpy/random/randomgen/src/threefry32/threefry32-test-data-gen.c
+++ b/numpy/random/src/threefry32/threefry32-test-data-gen.c
diff --git a/numpy/random/randomgen/src/threefry32/threefry32.c b/numpy/random/src/threefry32/threefry32.c
index 500e9482d..500e9482d 100644
--- a/numpy/random/randomgen/src/threefry32/threefry32.c
+++ b/numpy/random/src/threefry32/threefry32.c
diff --git a/numpy/random/randomgen/src/threefry32/threefry32.h b/numpy/random/src/threefry32/threefry32.h
index 74a85c42b..74a85c42b 100644
--- a/numpy/random/randomgen/src/threefry32/threefry32.h
+++ b/numpy/random/src/threefry32/threefry32.h
diff --git a/numpy/random/randomgen/src/xoroshiro128/LICENSE.md b/numpy/random/src/xoroshiro128/LICENSE.md
index 969430149..969430149 100644
--- a/numpy/random/randomgen/src/xoroshiro128/LICENSE.md
+++ b/numpy/random/src/xoroshiro128/LICENSE.md
diff --git a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128-benchmark.c b/numpy/random/src/xoroshiro128/xoroshiro128-benchmark.c
index 9a7b52bfb..9a7b52bfb 100644
--- a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128-benchmark.c
+++ b/numpy/random/src/xoroshiro128/xoroshiro128-benchmark.c
diff --git a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128-test-data-gen.c b/numpy/random/src/xoroshiro128/xoroshiro128-test-data-gen.c
index d50e63f5e..d50e63f5e 100644
--- a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128-test-data-gen.c
+++ b/numpy/random/src/xoroshiro128/xoroshiro128-test-data-gen.c
diff --git a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128.c b/numpy/random/src/xoroshiro128/xoroshiro128.c
index 060eb8a51..060eb8a51 100644
--- a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128.c
+++ b/numpy/random/src/xoroshiro128/xoroshiro128.c
diff --git a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128.h b/numpy/random/src/xoroshiro128/xoroshiro128.h
index 0db82b173..0db82b173 100644
--- a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128.h
+++ b/numpy/random/src/xoroshiro128/xoroshiro128.h
diff --git a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128plus.orig.c b/numpy/random/src/xoroshiro128/xoroshiro128plus.orig.c
index 1b5f46e4b..1b5f46e4b 100644
--- a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128plus.orig.c
+++ b/numpy/random/src/xoroshiro128/xoroshiro128plus.orig.c
diff --git a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128plus.orig.h b/numpy/random/src/xoroshiro128/xoroshiro128plus.orig.h
index 20c96fe04..20c96fe04 100644
--- a/numpy/random/randomgen/src/xoroshiro128/xoroshiro128plus.orig.h
+++ b/numpy/random/src/xoroshiro128/xoroshiro128plus.orig.h
diff --git a/numpy/random/randomgen/src/xorshift1024/LICENSE.md b/numpy/random/src/xorshift1024/LICENSE.md
index 3ca8ed4b9..3ca8ed4b9 100644
--- a/numpy/random/randomgen/src/xorshift1024/LICENSE.md
+++ b/numpy/random/src/xorshift1024/LICENSE.md
diff --git a/numpy/random/randomgen/src/xorshift1024/xorshift1024-benchmark.c b/numpy/random/src/xorshift1024/xorshift1024-benchmark.c
index 0eef33537..0eef33537 100644
--- a/numpy/random/randomgen/src/xorshift1024/xorshift1024-benchmark.c
+++ b/numpy/random/src/xorshift1024/xorshift1024-benchmark.c
diff --git a/numpy/random/randomgen/src/xorshift1024/xorshift1024-test-data-gen.c b/numpy/random/src/xorshift1024/xorshift1024-test-data-gen.c
index a2ae08df4..a2ae08df4 100644
--- a/numpy/random/randomgen/src/xorshift1024/xorshift1024-test-data-gen.c
+++ b/numpy/random/src/xorshift1024/xorshift1024-test-data-gen.c
diff --git a/numpy/random/randomgen/src/xorshift1024/xorshift1024.c b/numpy/random/src/xorshift1024/xorshift1024.c
index 8737b5a82..8737b5a82 100644
--- a/numpy/random/randomgen/src/xorshift1024/xorshift1024.c
+++ b/numpy/random/src/xorshift1024/xorshift1024.c
diff --git a/numpy/random/randomgen/src/xorshift1024/xorshift1024.h b/numpy/random/src/xorshift1024/xorshift1024.h
index e0ef77826..e0ef77826 100644
--- a/numpy/random/randomgen/src/xorshift1024/xorshift1024.h
+++ b/numpy/random/src/xorshift1024/xorshift1024.h
diff --git a/numpy/random/randomgen/src/xorshift1024/xorshift1024.orig.c b/numpy/random/src/xorshift1024/xorshift1024.orig.c
index 03c1c17fe..03c1c17fe 100644
--- a/numpy/random/randomgen/src/xorshift1024/xorshift1024.orig.c
+++ b/numpy/random/src/xorshift1024/xorshift1024.orig.c
diff --git a/numpy/random/randomgen/src/xorshift1024/xorshift1024.orig.h b/numpy/random/src/xorshift1024/xorshift1024.orig.h
index 9b7597967..9b7597967 100644
--- a/numpy/random/randomgen/src/xorshift1024/xorshift1024.orig.h
+++ b/numpy/random/src/xorshift1024/xorshift1024.orig.h
diff --git a/numpy/random/randomgen/src/xoshiro256starstar/LICENSE.md b/numpy/random/src/xoshiro256starstar/LICENSE.md
index d863f3b29..d863f3b29 100644
--- a/numpy/random/randomgen/src/xoshiro256starstar/LICENSE.md
+++ b/numpy/random/src/xoshiro256starstar/LICENSE.md
diff --git a/numpy/random/randomgen/src/xoshiro256starstar/xoshiro256starstar-test-data-gen.c b/numpy/random/src/xoshiro256starstar/xoshiro256starstar-test-data-gen.c
index 8522229dd..8522229dd 100644
--- a/numpy/random/randomgen/src/xoshiro256starstar/xoshiro256starstar-test-data-gen.c
+++ b/numpy/random/src/xoshiro256starstar/xoshiro256starstar-test-data-gen.c
diff --git a/numpy/random/randomgen/src/xoshiro256starstar/xoshiro256starstar.c b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.c
index 30b6c7d85..30b6c7d85 100644
--- a/numpy/random/randomgen/src/xoshiro256starstar/xoshiro256starstar.c
+++ b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.c
diff --git a/numpy/random/randomgen/src/xoshiro256starstar/xoshiro256starstar.h b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.h
index 1d7d8ea40..1d7d8ea40 100644
--- a/numpy/random/randomgen/src/xoshiro256starstar/xoshiro256starstar.h
+++ b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.h
diff --git a/numpy/random/randomgen/src/xoshiro256starstar/xoshiro256starstar.orig.c b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.orig.c
index ecf87bab9..ecf87bab9 100644
--- a/numpy/random/randomgen/src/xoshiro256starstar/xoshiro256starstar.orig.c
+++ b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.orig.c
diff --git a/numpy/random/randomgen/src/xoshiro256starstar/xoshiro256starstar.orig.h b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.orig.h
index 3aa788ec9..3aa788ec9 100644
--- a/numpy/random/randomgen/src/xoshiro256starstar/xoshiro256starstar.orig.h
+++ b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.orig.h
diff --git a/numpy/random/randomgen/src/xoshiro512starstar/LICENSE.md b/numpy/random/src/xoshiro512starstar/LICENSE.md
index aa34c1966..aa34c1966 100644
--- a/numpy/random/randomgen/src/xoshiro512starstar/LICENSE.md
+++ b/numpy/random/src/xoshiro512starstar/LICENSE.md
diff --git a/numpy/random/randomgen/src/xoshiro512starstar/xoshiro512starstar-test-data-gen.c b/numpy/random/src/xoshiro512starstar/xoshiro512starstar-test-data-gen.c
index bcc3574e4..bcc3574e4 100644
--- a/numpy/random/randomgen/src/xoshiro512starstar/xoshiro512starstar-test-data-gen.c
+++ b/numpy/random/src/xoshiro512starstar/xoshiro512starstar-test-data-gen.c
diff --git a/numpy/random/randomgen/src/xoshiro512starstar/xoshiro512starstar.c b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.c
index a9f56699f..a9f56699f 100644
--- a/numpy/random/randomgen/src/xoshiro512starstar/xoshiro512starstar.c
+++ b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.c
diff --git a/numpy/random/randomgen/src/xoshiro512starstar/xoshiro512starstar.h b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.h
index 0fa0ba3cd..0fa0ba3cd 100644
--- a/numpy/random/randomgen/src/xoshiro512starstar/xoshiro512starstar.h
+++ b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.h
diff --git a/numpy/random/randomgen/src/xoshiro512starstar/xoshiro512starstar.orig.c b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.orig.c
index 0cf884edb..0cf884edb 100644
--- a/numpy/random/randomgen/src/xoshiro512starstar/xoshiro512starstar.orig.c
+++ b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.orig.c
diff --git a/numpy/random/randomgen/src/xoshiro512starstar/xoshiro512starstar.orig.h b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.orig.h
index 0b7892473..0b7892473 100644
--- a/numpy/random/randomgen/src/xoshiro512starstar/xoshiro512starstar.orig.h
+++ b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.orig.h
diff --git a/numpy/random/randomgen/tests/__init__.py b/numpy/random/tests/data/__init__.py
index e69de29bb..e69de29bb 100644
--- a/numpy/random/randomgen/tests/__init__.py
+++ b/numpy/random/tests/data/__init__.py
diff --git a/numpy/random/randomgen/tests/data/dSFMT-testset-1.csv b/numpy/random/tests/data/dSFMT-testset-1.csv
index 9f3f68aee..9f3f68aee 100644
--- a/numpy/random/randomgen/tests/data/dSFMT-testset-1.csv
+++ b/numpy/random/tests/data/dSFMT-testset-1.csv
diff --git a/numpy/random/randomgen/tests/data/dSFMT-testset-2.csv b/numpy/random/tests/data/dSFMT-testset-2.csv
index 2ec2d7a51..2ec2d7a51 100644
--- a/numpy/random/randomgen/tests/data/dSFMT-testset-2.csv
+++ b/numpy/random/tests/data/dSFMT-testset-2.csv
diff --git a/numpy/random/randomgen/tests/data/mt19937-testset-1.csv b/numpy/random/tests/data/mt19937-testset-1.csv
index 3d4995840..3d4995840 100644
--- a/numpy/random/randomgen/tests/data/mt19937-testset-1.csv
+++ b/numpy/random/tests/data/mt19937-testset-1.csv
diff --git a/numpy/random/randomgen/tests/data/mt19937-testset-2.csv b/numpy/random/tests/data/mt19937-testset-2.csv
index d2f6c156c..d2f6c156c 100644
--- a/numpy/random/randomgen/tests/data/mt19937-testset-2.csv
+++ b/numpy/random/tests/data/mt19937-testset-2.csv
diff --git a/numpy/random/randomgen/tests/data/pcg32-testset-1.csv b/numpy/random/tests/data/pcg32-testset-1.csv
index 6bddc8d5c..6bddc8d5c 100644
--- a/numpy/random/randomgen/tests/data/pcg32-testset-1.csv
+++ b/numpy/random/tests/data/pcg32-testset-1.csv
diff --git a/numpy/random/randomgen/tests/data/pcg32-testset-2.csv b/numpy/random/tests/data/pcg32-testset-2.csv
index 2d4c8aed1..2d4c8aed1 100644
--- a/numpy/random/randomgen/tests/data/pcg32-testset-2.csv
+++ b/numpy/random/tests/data/pcg32-testset-2.csv
diff --git a/numpy/random/randomgen/tests/data/pcg64-testset-1.csv b/numpy/random/tests/data/pcg64-testset-1.csv
index da6d77d40..da6d77d40 100644
--- a/numpy/random/randomgen/tests/data/pcg64-testset-1.csv
+++ b/numpy/random/tests/data/pcg64-testset-1.csv
diff --git a/numpy/random/randomgen/tests/data/pcg64-testset-2.csv b/numpy/random/tests/data/pcg64-testset-2.csv
index 779761d0f..779761d0f 100644
--- a/numpy/random/randomgen/tests/data/pcg64-testset-2.csv
+++ b/numpy/random/tests/data/pcg64-testset-2.csv
diff --git a/numpy/random/randomgen/tests/data/philox-testset-1.csv b/numpy/random/tests/data/philox-testset-1.csv
index 64c1516cb..64c1516cb 100644
--- a/numpy/random/randomgen/tests/data/philox-testset-1.csv
+++ b/numpy/random/tests/data/philox-testset-1.csv
diff --git a/numpy/random/randomgen/tests/data/philox-testset-2.csv b/numpy/random/tests/data/philox-testset-2.csv
index 1c2d4eba0..1c2d4eba0 100644
--- a/numpy/random/randomgen/tests/data/philox-testset-2.csv
+++ b/numpy/random/tests/data/philox-testset-2.csv
diff --git a/numpy/random/randomgen/tests/data/threefry-testset-1.csv b/numpy/random/tests/data/threefry-testset-1.csv
index ddfa736dc..ddfa736dc 100644
--- a/numpy/random/randomgen/tests/data/threefry-testset-1.csv
+++ b/numpy/random/tests/data/threefry-testset-1.csv
diff --git a/numpy/random/randomgen/tests/data/threefry-testset-2.csv b/numpy/random/tests/data/threefry-testset-2.csv
index 275604557..275604557 100644
--- a/numpy/random/randomgen/tests/data/threefry-testset-2.csv
+++ b/numpy/random/tests/data/threefry-testset-2.csv
diff --git a/numpy/random/randomgen/tests/data/threefry32-testset-1.csv b/numpy/random/tests/data/threefry32-testset-1.csv
index 3aec7304d..3aec7304d 100644
--- a/numpy/random/randomgen/tests/data/threefry32-testset-1.csv
+++ b/numpy/random/tests/data/threefry32-testset-1.csv
diff --git a/numpy/random/randomgen/tests/data/threefry32-testset-2.csv b/numpy/random/tests/data/threefry32-testset-2.csv
index b7753638f..b7753638f 100644
--- a/numpy/random/randomgen/tests/data/threefry32-testset-2.csv
+++ b/numpy/random/tests/data/threefry32-testset-2.csv
diff --git a/numpy/random/randomgen/tests/data/xoroshiro128-testset-1.csv b/numpy/random/tests/data/xoroshiro128-testset-1.csv
index 4ef7172e1..4ef7172e1 100644
--- a/numpy/random/randomgen/tests/data/xoroshiro128-testset-1.csv
+++ b/numpy/random/tests/data/xoroshiro128-testset-1.csv
diff --git a/numpy/random/randomgen/tests/data/xoroshiro128-testset-2.csv b/numpy/random/tests/data/xoroshiro128-testset-2.csv
index 2de341ecd..2de341ecd 100644
--- a/numpy/random/randomgen/tests/data/xoroshiro128-testset-2.csv
+++ b/numpy/random/tests/data/xoroshiro128-testset-2.csv
diff --git a/numpy/random/randomgen/tests/data/xorshift1024-testset-1.csv b/numpy/random/tests/data/xorshift1024-testset-1.csv
index 661b157b1..661b157b1 100644
--- a/numpy/random/randomgen/tests/data/xorshift1024-testset-1.csv
+++ b/numpy/random/tests/data/xorshift1024-testset-1.csv
diff --git a/numpy/random/randomgen/tests/data/xorshift1024-testset-2.csv b/numpy/random/tests/data/xorshift1024-testset-2.csv
index ef10e6872..ef10e6872 100644
--- a/numpy/random/randomgen/tests/data/xorshift1024-testset-2.csv
+++ b/numpy/random/tests/data/xorshift1024-testset-2.csv
diff --git a/numpy/random/randomgen/tests/data/xoshiro256starstar-testset-1.csv b/numpy/random/tests/data/xoshiro256starstar-testset-1.csv
index 534799b04..534799b04 100644
--- a/numpy/random/randomgen/tests/data/xoshiro256starstar-testset-1.csv
+++ b/numpy/random/tests/data/xoshiro256starstar-testset-1.csv
diff --git a/numpy/random/randomgen/tests/data/xoshiro256starstar-testset-2.csv b/numpy/random/tests/data/xoshiro256starstar-testset-2.csv
index b688fcb2a..b688fcb2a 100644
--- a/numpy/random/randomgen/tests/data/xoshiro256starstar-testset-2.csv
+++ b/numpy/random/tests/data/xoshiro256starstar-testset-2.csv
diff --git a/numpy/random/randomgen/tests/data/xoshiro512starstar-testset-1.csv b/numpy/random/tests/data/xoshiro512starstar-testset-1.csv
index 78fb903ee..78fb903ee 100644
--- a/numpy/random/randomgen/tests/data/xoshiro512starstar-testset-1.csv
+++ b/numpy/random/tests/data/xoshiro512starstar-testset-1.csv
diff --git a/numpy/random/randomgen/tests/data/xoshiro512starstar-testset-2.csv b/numpy/random/tests/data/xoshiro512starstar-testset-2.csv
index 264308f1a..264308f1a 100644
--- a/numpy/random/randomgen/tests/data/xoshiro512starstar-testset-2.csv
+++ b/numpy/random/tests/data/xoshiro512starstar-testset-2.csv
diff --git a/numpy/random/randomgen/tests/test_against_numpy.py b/numpy/random/tests/test_against_numpy.py
index 431c7bd85..b930fcbff 100644
--- a/numpy/random/randomgen/tests/test_against_numpy.py
+++ b/numpy/random/tests/test_against_numpy.py
@@ -5,7 +5,7 @@ from numpy.testing import (assert_allclose, assert_array_equal, assert_equal,
 
 import pytest
 
-from numpy.random.randomgen import RandomGenerator, MT19937, generator
+from numpy.random import RandomGenerator, MT19937, generator
 from numpy.random import RandomState
 
 
@@ -98,12 +98,12 @@ class TestAgainstNumPy(object):
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
         cls.rs = RandomState(cls.brng(*cls.seed))
         cls.nprs = cls.np.RandomState(*cls.seed)
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls._set_common_state()
 
     @classmethod
     def _set_common_state(cls):
-        state = cls.rg.state
+        state = cls.rg.brng.state
         st = [[]] * 5
         st[0] = 'MT19937'
         st[1] = state['state']['key']
@@ -125,7 +125,7 @@ class TestAgainstNumPy(object):
 
     def _is_state_common(self):
         state = self.nprs.get_state()
-        state2 = self.rg.state
+        state2 = self.rg.brng.state
         assert (state[1] == state2['state']['key']).all()
         assert (state[2] == state2['state']['pos'])
 
@@ -138,10 +138,10 @@ class TestAgainstNumPy(object):
         assert_allclose(state[4], state2['gauss'], atol=1e-10)
 
     def test_common_seed(self):
-        self.rg.seed(1234)
+        self.rg.brng.seed(1234)
         self.nprs.seed(1234)
         self._is_state_common()
-        self.rg.seed(23456)
+        self.rg.brng.seed(23456)
         self.nprs.seed(23456)
         self._is_state_common()
 
@@ -149,8 +149,8 @@ class TestAgainstNumPy(object):
         nprs = np.random.RandomState()
         nprs.standard_normal(99)
         state = nprs.get_state()
-        self.rg.state = state
-        state2 = self.rg.state
+        self.rg.brng.state = state
+        state2 = self.rg.brng.state
         assert (state[1] == state2['state']['key']).all()
         assert (state[2] == state2['state']['pos'])
 
@@ -383,7 +383,7 @@ class TestAgainstNumPy(object):
         assert_equal(s1.randint(1000), 419)
         assert_equal(s1.randint(1000), s.randint(1000))
 
-        self.rg.seed(4294967295)
+        self.rg.brng.seed(4294967295)
         self.nprs.seed(4294967295)
         self._is_state_common()
 
@@ -400,26 +400,6 @@ class TestAgainstNumPy(object):
         s = RandomGenerator(MT19937([4294967295]))
         assert_equal(s.randint(1000), 265)
 
-    def test_dir(self):
-        nprs_d = set(dir(self.nprs))
-        rs_d = dir(self.rg)
-        excluded = {'get_state', 'set_state'}
-        nprs_d.difference_update(excluded)
-        assert (len(nprs_d.difference(rs_d)) == 0)
-
-        npmod = dir(numpy.random)
-        mod = dir(generator)
-        known_exlcuded = ['__all__', '__cached__', '__path__', 'Tester',
-                          'info', 'bench', '__RandomState_ctor', 'mtrand',
-                          'test', '__warningregistry__', '_numpy_tester',
-                          'division', 'get_state', 'set_state', 'seed',
-                          'ranf', 'random', 'sample', 'absolute_import',
-                          'print_function', 'RandomState', 'randomgen',
-                          'tests', 'Lock']
-        mod += known_exlcuded
-        diff = set(npmod).difference(mod)
-        assert_equal(len(diff), 0)
-
     # Tests using legacy generator
     def test_chisquare(self):
         self._set_common_state_legacy()
diff --git a/numpy/random/randomgen/tests/test_direct.py b/numpy/random/tests/test_direct.py
index 22fdcd865..d6042100a 100644
--- a/numpy/random/randomgen/tests/test_direct.py
+++ b/numpy/random/tests/test_direct.py
@@ -7,10 +7,10 @@ from numpy.testing import assert_equal, assert_allclose, assert_array_equal, \
     assert_raises
 import pytest
 
-from ...randomgen import RandomGenerator, MT19937, DSFMT, ThreeFry32, ThreeFry, \
+from numpy.random import RandomGenerator, MT19937, DSFMT, ThreeFry32, ThreeFry, \
     PCG32, PCG64, Philox, Xoroshiro128, Xorshift1024, Xoshiro256StarStar, \
     Xoshiro512StarStar, RandomState
-from ...randomgen.common import interface
+from numpy.random.common import interface
 
 try:
     import cffi  # noqa: F401
@@ -206,30 +206,30 @@ class Base(object):
     def test_seed_float(self):
         # GH #82
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(self.seed_error_type, rs.seed, np.pi)
-        assert_raises(self.seed_error_type, rs.seed, -np.pi)
+        assert_raises(self.seed_error_type, rs.brng.seed, np.pi)
+        assert_raises(self.seed_error_type, rs.brng.seed, -np.pi)
 
     def test_seed_float_array(self):
         # GH #82
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(self.seed_error_type, rs.seed, np.array([np.pi]))
-        assert_raises(self.seed_error_type, rs.seed, np.array([-np.pi]))
-        assert_raises(ValueError, rs.seed, np.array([np.pi, -np.pi]))
-        assert_raises(TypeError, rs.seed, np.array([0, np.pi]))
-        assert_raises(TypeError, rs.seed, [np.pi])
-        assert_raises(TypeError, rs.seed, [0, np.pi])
+        assert_raises(self.seed_error_type, rs.brng.seed, np.array([np.pi]))
+        assert_raises(self.seed_error_type, rs.brng.seed, np.array([-np.pi]))
+        assert_raises(ValueError, rs.brng.seed, np.array([np.pi, -np.pi]))
+        assert_raises(TypeError, rs.brng.seed, np.array([0, np.pi]))
+        assert_raises(TypeError, rs.brng.seed, [np.pi])
+        assert_raises(TypeError, rs.brng.seed, [0, np.pi])
 
     def test_seed_out_of_range(self):
         # GH #82
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(ValueError, rs.seed, 2 ** (2 * self.bits + 1))
-        assert_raises(ValueError, rs.seed, -1)
+        assert_raises(ValueError, rs.brng.seed, 2 ** (2 * self.bits + 1))
+        assert_raises(ValueError, rs.brng.seed, -1)
 
     def test_seed_out_of_range_array(self):
         # GH #82
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(ValueError, rs.seed, [2 ** (2 * self.bits + 1)])
-        assert_raises(ValueError, rs.seed, [-1])
+        assert_raises(ValueError, rs.brng.seed, [2 ** (2 * self.bits + 1)])
+        assert_raises(ValueError, rs.brng.seed, [-1])
 
     def test_repr(self):
         rs = RandomGenerator(self.brng(*self.data1['seed']))
@@ -412,18 +412,18 @@ class TestPCG64(Base):
 
     def test_seed_float_array(self):
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(self.seed_error_type, rs.seed, np.array([np.pi]))
-        assert_raises(self.seed_error_type, rs.seed, np.array([-np.pi]))
-        assert_raises(self.seed_error_type, rs.seed, np.array([np.pi, -np.pi]))
-        assert_raises(self.seed_error_type, rs.seed, np.array([0, np.pi]))
-        assert_raises(self.seed_error_type, rs.seed, [np.pi])
-        assert_raises(self.seed_error_type, rs.seed, [0, np.pi])
+        assert_raises(self.seed_error_type, rs.brng.seed, np.array([np.pi]))
+        assert_raises(self.seed_error_type, rs.brng.seed, np.array([-np.pi]))
+        assert_raises(self.seed_error_type, rs.brng.seed, np.array([np.pi, -np.pi]))
+        assert_raises(self.seed_error_type, rs.brng.seed, np.array([0, np.pi]))
+        assert_raises(self.seed_error_type, rs.brng.seed, [np.pi])
+        assert_raises(self.seed_error_type, rs.brng.seed, [0, np.pi])
 
     def test_seed_out_of_range_array(self):
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(self.seed_error_type, rs.seed,
+        assert_raises(self.seed_error_type, rs.brng.seed,
                       [2 ** (2 * self.bits + 1)])
-        assert_raises(self.seed_error_type, rs.seed, [-1])
+        assert_raises(self.seed_error_type, rs.brng.seed, [-1])
 
 
 class TestPhilox(Base):
@@ -464,43 +464,45 @@ class TestMT19937(Base):
     def test_seed_out_of_range(self):
         # GH #82
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(ValueError, rs.seed, 2 ** (self.bits + 1))
-        assert_raises(ValueError, rs.seed, -1)
-        assert_raises(ValueError, rs.seed, 2 ** (2 * self.bits + 1))
+        assert_raises(ValueError, rs.brng.seed, 2 ** (self.bits + 1))
+        assert_raises(ValueError, rs.brng.seed, -1)
+        assert_raises(ValueError, rs.brng.seed, 2 ** (2 * self.bits + 1))
 
     def test_seed_out_of_range_array(self):
         # GH #82
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(ValueError, rs.seed, [2 ** (self.bits + 1)])
-        assert_raises(ValueError, rs.seed, [-1])
-        assert_raises(TypeError, rs.seed, [2 ** (2 * self.bits + 1)])
+        assert_raises(ValueError, rs.brng.seed, [2 ** (self.bits + 1)])
+        assert_raises(ValueError, rs.brng.seed, [-1])
+        assert_raises(TypeError, rs.brng.seed, [2 ** (2 * self.bits + 1)])
 
     def test_seed_float(self):
         # GH #82
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(TypeError, rs.seed, np.pi)
-        assert_raises(TypeError, rs.seed, -np.pi)
+        assert_raises(TypeError, rs.brng.seed, np.pi)
+        assert_raises(TypeError, rs.brng.seed, -np.pi)
 
     def test_seed_float_array(self):
         # GH #82
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(TypeError, rs.seed, np.array([np.pi]))
-        assert_raises(TypeError, rs.seed, np.array([-np.pi]))
-        assert_raises(TypeError, rs.seed, np.array([np.pi, -np.pi]))
-        assert_raises(TypeError, rs.seed, np.array([0, np.pi]))
-        assert_raises(TypeError, rs.seed, [np.pi])
-        assert_raises(TypeError, rs.seed, [0, np.pi])
+        brng = rs.brng
+        assert_raises(TypeError, brng.seed, np.array([np.pi]))
+        assert_raises(TypeError, brng.seed, np.array([-np.pi]))
+        assert_raises(TypeError, brng.seed, np.array([np.pi, -np.pi]))
+        assert_raises(TypeError, brng.seed, np.array([0, np.pi]))
+        assert_raises(TypeError, brng.seed, [np.pi])
+        assert_raises(TypeError, brng.seed, [0, np.pi])
 
     def test_state_tuple(self):
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        state = rs.state
+        brng = rs.brng
+        state = brng.state
         desired = rs.randint(2 ** 16)
         tup = (state['brng'], state['state']['key'], state['state']['pos'])
-        rs.state = tup
+        brng.state = tup
         actual = rs.randint(2 ** 16)
         assert_equal(actual, desired)
         tup = tup + (0, 0.0)
-        rs.state = tup
+        brng.state = tup
         actual = rs.randint(2 ** 16)
         assert_equal(actual, desired)
 
@@ -542,25 +544,25 @@ class TestDSFMT(Base):
     def test_seed_out_of_range_array(self):
         # GH #82
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(ValueError, rs.seed, [2 ** (self.bits + 1)])
-        assert_raises(ValueError, rs.seed, [-1])
-        assert_raises(TypeError, rs.seed, [2 ** (2 * self.bits + 1)])
+        assert_raises(ValueError, rs.brng.seed, [2 ** (self.bits + 1)])
+        assert_raises(ValueError, rs.brng.seed, [-1])
+        assert_raises(TypeError, rs.brng.seed, [2 ** (2 * self.bits + 1)])
 
     def test_seed_float(self):
         # GH #82
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(TypeError, rs.seed, np.pi)
-        assert_raises(TypeError, rs.seed, -np.pi)
+        assert_raises(TypeError, rs.brng.seed, np.pi)
+        assert_raises(TypeError, rs.brng.seed, -np.pi)
 
     def test_seed_float_array(self):
         # GH #82
         rs = RandomGenerator(self.brng(*self.data1['seed']))
-        assert_raises(TypeError, rs.seed, np.array([np.pi]))
-        assert_raises(TypeError, rs.seed, np.array([-np.pi]))
-        assert_raises(TypeError, rs.seed, np.array([np.pi, -np.pi]))
-        assert_raises(TypeError, rs.seed, np.array([0, np.pi]))
-        assert_raises(TypeError, rs.seed, [np.pi])
-        assert_raises(TypeError, rs.seed, [0, np.pi])
+        assert_raises(TypeError, rs.brng.seed, np.array([np.pi]))
+        assert_raises(TypeError, rs.brng.seed, np.array([-np.pi]))
+        assert_raises(TypeError, rs.brng.seed, np.array([np.pi, -np.pi]))
+        assert_raises(TypeError, rs.brng.seed, np.array([0, np.pi]))
+        assert_raises(TypeError, rs.brng.seed, [np.pi])
+        assert_raises(TypeError, rs.brng.seed, [0, np.pi])
 
     def test_uniform_float(self):
         rs = RandomGenerator(self.brng(*self.data1['seed']))
@@ -578,9 +580,9 @@ class TestDSFMT(Base):
     def test_buffer_reset(self):
         rs = RandomGenerator(self.brng(*self.data1['seed']))
         rs.random_sample(1)
-        assert rs.state['buffer_loc'] != 382
-        rs.seed(*self.data1['seed'])
-        assert rs.state['buffer_loc'] == 382
+        assert rs.brng.state['buffer_loc'] != 382
+        rs.brng.seed(*self.data1['seed'])
+        assert rs.brng.state['buffer_loc'] == 382
 
 
 class TestThreeFry32(Base):
diff --git a/numpy/random/randomgen/tests/test_generator_mt19937.py b/numpy/random/tests/test_generator_mt19937.py
index 10dd8733a..3eda84d84 100644
--- a/numpy/random/randomgen/tests/test_generator_mt19937.py
+++ b/numpy/random/tests/test_generator_mt19937.py
@@ -7,7 +7,7 @@ from numpy.testing import (
     assert_warns, assert_no_warnings, assert_array_equal,
     assert_array_almost_equal, suppress_warnings)
 
-from ...randomgen import RandomGenerator, MT19937
+from numpy.random import RandomGenerator, MT19937
 
 random = RandomGenerator(MT19937())
 
@@ -96,21 +96,22 @@ class TestSetState(object):
     def setup(self):
         self.seed = 1234567890
         self.rg = RandomGenerator(MT19937(self.seed))
-        self.state = self.rg.state
+        self.brng = self.rg.brng
+        self.state = self.brng.state
         self.legacy_state = (self.state['brng'],
                              self.state['state']['key'],
                              self.state['state']['pos'])
 
     def test_basic(self):
         old = self.rg.tomaxint(16)
-        self.rg.state = self.state
+        self.brng.state = self.state
         new = self.rg.tomaxint(16)
         assert_(np.all(old == new))
 
     def test_gaussian_reset(self):
         # Make sure the cached every-other-Gaussian is reset.
         old = self.rg.standard_normal(size=3)
-        self.rg.state = self.state
+        self.brng.state = self.state
         new = self.rg.standard_normal(size=3)
         assert_(np.all(old == new))
 
@@ -119,9 +120,9 @@ class TestSetState(object):
         # cached Gaussian is restored.
 
         self.rg.standard_normal()
-        state = self.rg.state
+        state = self.brng.state
         old = self.rg.standard_normal(size=3)
-        self.rg.state = state
+        self.brng.state = state
         new = self.rg.standard_normal(size=3)
         assert_(np.all(old == new))
 
@@ -244,7 +245,7 @@ class TestRandint(object):
 
     def test_in_bounds_fuzz(self):
         # Don't use fixed seed
-        random.seed()
+        random.brng.seed()
 
         for dt in self.itype[1:]:
             for ubnd in [4, 8, 16]:
@@ -263,13 +264,13 @@ class TestRandint(object):
             ubnd = 2 if dt is bool else np.iinfo(dt).max + 1
 
             size = 1000
-            random.seed(1234)
+            random.brng.seed(1234)
             scalar = self.rfunc(lbnd, ubnd, size=size, dtype=dt)
 
-            random.seed(1234)
+            random.brng.seed(1234)
             scalar_array = self.rfunc([lbnd], [ubnd], size=size, dtype=dt)
 
-            random.seed(1234)
+            random.brng.seed(1234)
             array = self.rfunc([lbnd] * size, [ubnd] *
                                size, size=size, dtype=dt)
             assert_array_equal(scalar, scalar_array)
@@ -291,7 +292,7 @@ class TestRandint(object):
                'uint8': '27dd30c4e08a797063dffac2490b0be6'}
 
         for dt in self.itype[1:]:
-            random.seed(1234)
+            random.brng.seed(1234)
 
             # view as little endian for hash
             if sys.byteorder == 'little':
@@ -303,7 +304,7 @@ class TestRandint(object):
             assert_(tgt[np.dtype(dt).name] == res)
 
         # bools do not depend on endianness
-        random.seed(1234)
+        random.brng.seed(1234)
         val = self.rfunc(0, 2, size=1000, dtype=bool).view(np.int8)
         res = hashlib.md5(val).hexdigest()
         assert_(tgt[np.dtype(bool).name] == res)
@@ -316,15 +317,15 @@ class TestRandint(object):
                 np.bool, bool, np.bool_) else np.iinfo(dt).max + 1
 
             # view as little endian for hash
-            random.seed(1234)
+            random.brng.seed(1234)
             val = self.rfunc(lbnd, ubnd, size=1000, dtype=dt)
 
-            random.seed(1234)
+            random.brng.seed(1234)
             val_bc = self.rfunc([lbnd] * 1000, ubnd, dtype=dt)
 
             assert_array_equal(val, val_bc)
 
-            random.seed(1234)
+            random.brng.seed(1234)
             val_bc = self.rfunc([lbnd] * 1000, [ubnd] * 1000, dtype=dt)
 
             assert_array_equal(val, val_bc)
@@ -400,7 +401,7 @@ class TestRandomDist(object):
         self.seed = 1234567890
 
     def test_rand(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.rand(3, 2)
         desired = np.array([[0.61879477158567997, 0.59162362775974664],
                             [0.88868358904449662, 0.89165480011560816],
@@ -408,25 +409,25 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=15)
 
     def test_rand_singleton(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.rand()
         desired = 0.61879477158567997
         assert_array_almost_equal(actual, desired, decimal=15)
 
     def test_randn(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.randn(3, 2)
         desired = np.array([[-3.472754000610961, -0.108938564229143],
                             [-0.245965753396411, -0.704101550261701],
                             [0.360102487116356,  0.127832101772367]])
         assert_array_almost_equal(actual, desired, decimal=15)
 
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.randn()
         assert_array_almost_equal(actual, desired[0, 0], decimal=15)
 
     def test_randint(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.randint(-99, 99, size=(3, 2))
         desired = np.array([[31, 3],
                             [-52, 41],
@@ -436,7 +437,7 @@ class TestRandomDist(object):
     def test_randint_masked(self):
         # Test masked rejection sampling algorithm to generate array of
         # uint32 in an interval.
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.randint(0, 99, size=(3, 2), dtype=np.uint32,
                                 use_masked=True)
         desired = np.array([[2, 47],
@@ -446,7 +447,7 @@ class TestRandomDist(object):
 
     def test_randint_lemire_32(self):
         # Test lemire algorithm to generate array of uint32 in an interval.
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.randint(0, 99, size=(3, 2), dtype=np.uint32,
                                 use_masked=False)
         desired = np.array([[61, 33],
@@ -456,7 +457,7 @@ class TestRandomDist(object):
 
     def test_randint_lemire_64(self):
         # Test lemire algorithm to generate array of uint64 in an interval.
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.randint(0, 99 + 0xFFFFFFFFF, size=(3, 2),
                                 dtype=np.uint64, use_masked=False)
         desired = np.array([[42523252834, 40656066204],
@@ -465,7 +466,7 @@ class TestRandomDist(object):
         assert_array_equal(actual, desired)
 
     def test_random_integers(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         with suppress_warnings() as sup:
             w = sup.record(DeprecationWarning)
             actual = random.random_integers(-99, 99, size=(3, 2))
@@ -505,19 +506,19 @@ class TestRandomDist(object):
                           np.iinfo('l').max, np.iinfo('l').max)
 
     def test_random_sample(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.random_sample((3, 2))
         desired = np.array([[0.61879477158567997, 0.59162362775974664],
                             [0.88868358904449662, 0.89165480011560816],
                             [0.4575674820298663, 0.7781880808593471]])
         assert_array_almost_equal(actual, desired, decimal=15)
 
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.random_sample()
         assert_array_almost_equal(actual, desired[0, 0], decimal=15)
 
     def test_random_sample_float(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.random_sample((3, 2))
         desired = np.array([[0.6187948, 0.5916236],
                             [0.8886836, 0.8916548],
@@ -525,7 +526,7 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=7)
 
     def test_random_sample_float_scalar(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.random_sample(dtype=np.float32)
         desired = 0.6187948
         assert_array_almost_equal(actual, desired, decimal=7)
@@ -534,31 +535,31 @@ class TestRandomDist(object):
         assert_raises(TypeError, random.random_sample, dtype='int32')
 
     def test_choice_uniform_replace(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.choice(4, 4)
         desired = np.array([2, 3, 2, 3])
         assert_array_equal(actual, desired)
 
     def test_choice_nonuniform_replace(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.choice(4, 4, p=[0.4, 0.4, 0.1, 0.1])
         desired = np.array([1, 1, 2, 2])
         assert_array_equal(actual, desired)
 
     def test_choice_uniform_noreplace(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.choice(4, 3, replace=False)
         desired = np.array([0, 1, 3])
         assert_array_equal(actual, desired)
 
     def test_choice_nonuniform_noreplace(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.choice(4, 3, replace=False, p=[0.1, 0.3, 0.5, 0.1])
         desired = np.array([2, 3, 1])
         assert_array_equal(actual, desired)
 
     def test_choice_noninteger(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.choice(['a', 'b', 'c', 'd'], 4)
         desired = np.array(['c', 'd', 'c', 'd'])
         assert_array_equal(actual, desired)
@@ -634,7 +635,7 @@ class TestRandomDist(object):
         assert_raises(ValueError, random.choice, a, p=p)
 
     def test_bytes(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.bytes(10)
         desired = b'\x82Ui\x9e\xff\x97+Wf\xa5'
         assert_equal(actual, desired)
@@ -659,7 +660,7 @@ class TestRandomDist(object):
                      lambda x: np.asarray([(i, i) for i in x],
                                           [("a", object, 1),
                                            ("b", np.int32, 1)])]:
-            random.seed(self.seed)
+            random.brng.seed(self.seed)
             alist = conv([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
             random.shuffle(alist)
             actual = alist
@@ -681,19 +682,19 @@ class TestRandomDist(object):
                 sorted(b.data[~b.mask]), sorted(b_orig.data[~b_orig.mask]))
 
     def test_permutation(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
         actual = random.permutation(alist)
         desired = [0, 1, 9, 6, 2, 4, 5, 8, 7, 3]
         assert_array_equal(actual, desired)
 
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         arr_2d = np.atleast_2d([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]).T
         actual = random.permutation(arr_2d)
         assert_array_equal(actual, np.atleast_2d(desired).T)
 
     def test_beta(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.beta(.1, .9, size=(3, 2))
         desired = np.array(
             [[1.45341850513746058e-02, 5.31297615662868145e-04],
@@ -702,20 +703,20 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=15)
 
     def test_binomial(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.binomial(100.123, .456, size=(3, 2))
         desired = np.array([[37, 43],
                             [42, 48],
                             [46, 45]])
         assert_array_equal(actual, desired)
 
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.binomial(100.123, .456)
         desired = 37
         assert_array_equal(actual, desired)
 
     def test_chisquare(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.chisquare(50, size=(3, 2))
         desired = np.array([[22.2534560369812, 46.9302393710074],
                             [52.9974164611614, 85.3559029505718],
@@ -723,7 +724,7 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=13)
 
     def test_dirichlet(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         alpha = np.array([51.72840233779265162, 39.74494232180943953])
         actual = random.dirichlet(alpha, size=(3, 2))
         desired = np.array([[[0.444382290764855, 0.555617709235145],
@@ -736,7 +737,7 @@ class TestRandomDist(object):
         bad_alpha = np.array([5.4e-01, -1.0e-16])
         assert_raises(ValueError, random.dirichlet, bad_alpha)
 
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         alpha = np.array([51.72840233779265162, 39.74494232180943953])
         actual = random.dirichlet(alpha)
         assert_array_almost_equal(actual, desired[0, 0], decimal=15)
@@ -759,7 +760,7 @@ class TestRandomDist(object):
         assert_raises(ValueError, random.dirichlet, alpha)
 
     def test_exponential(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.exponential(1.1234, size=(3, 2))
         desired = np.array([[5.350682337747634, 1.152307441755771],
                             [3.867015473358779, 1.538765912839396],
@@ -771,7 +772,7 @@ class TestRandomDist(object):
         assert_raises(ValueError, random.exponential, scale=-0.)
 
     def test_f(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.f(12, 77, size=(3, 2))
         desired = np.array([[0.809498839488467, 2.867222762455471],
                             [0.588036831639353, 1.012185639664636],
@@ -779,7 +780,7 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=15)
 
     def test_gamma(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.gamma(5, 3, size=(3, 2))
         desired = np.array([[12.46569350177219, 16.46580642087044],
                             [43.65744473309084, 11.98722785682592],
@@ -791,7 +792,7 @@ class TestRandomDist(object):
         assert_raises(ValueError, random.gamma, shape=-0., scale=-0.)
 
     def test_geometric(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.geometric(.123456789, size=(3, 2))
         desired = np.array([[8, 7],
                             [17, 17],
@@ -809,7 +810,7 @@ class TestRandomDist(object):
             assert_raises(ValueError, random.geometric, [np.nan] * 10)
 
     def test_gumbel(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.gumbel(loc=.123456789, scale=2.0, size=(3, 2))
         desired = np.array([[0.19591898743416816, 0.34405539668096674],
                             [-1.4492522252274278, -1.47374816298446865],
@@ -821,7 +822,7 @@ class TestRandomDist(object):
         assert_raises(ValueError, random.gumbel, scale=-0.)
 
     def test_hypergeometric(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.hypergeometric(10.1, 5.5, 14, size=(3, 2))
         desired = np.array([[10, 10],
                             [10, 10],
@@ -847,7 +848,7 @@ class TestRandomDist(object):
         assert_array_equal(actual, desired)
 
     def test_laplace(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.laplace(loc=.123456789, scale=2.0, size=(3, 2))
         desired = np.array([[0.66599721112760157, 0.52829452552221945],
                             [3.12791959514407125, 3.18202813572992005],
@@ -859,7 +860,7 @@ class TestRandomDist(object):
         assert_raises(ValueError, random.laplace, scale=-0.)
 
     def test_logistic(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.logistic(loc=.123456789, scale=2.0, size=(3, 2))
         desired = np.array([[1.09232835305011444, 0.8648196662399954],
                             [4.27818590694950185, 4.33897006346929714],
@@ -867,7 +868,7 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=15)
 
     def test_lognormal(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.lognormal(mean=.123456789, sigma=2.0, size=(3, 2))
         desired = np.array([[1.0894838661036e-03, 9.0990021488311e-01],
                             [6.9178869932225e-01, 2.7672077560016e-01],
@@ -879,7 +880,7 @@ class TestRandomDist(object):
         assert_raises(ValueError, random.lognormal, sigma=-0.)
 
     def test_logseries(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.logseries(p=.923456789, size=(3, 2))
         desired = np.array([[2, 2],
                             [6, 17],
@@ -893,7 +894,7 @@ class TestRandomDist(object):
             assert_raises(ValueError, random.logseries, [np.nan] * 10)
 
     def test_multinomial(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.multinomial(20, [1 / 6.] * 6, size=(3, 2))
         desired = np.array([[[4, 3, 5, 4, 2, 2],
                              [5, 2, 8, 2, 2, 1]],
@@ -904,7 +905,7 @@ class TestRandomDist(object):
         assert_array_equal(actual, desired)
 
     def test_multivariate_normal(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         mean = (.123456789, 10)
         cov = [[1, 0], [0, 1]]
         size = (3, 2)
@@ -955,7 +956,7 @@ class TestRandomDist(object):
                       mu, np.eye(3))
 
     def test_negative_binomial(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.negative_binomial(n=100, p=.12345, size=(3, 2))
         desired = np.array([[521, 736],
                             [665, 690],
@@ -970,7 +971,7 @@ class TestRandomDist(object):
                           [np.nan] * 10)
 
     def test_noncentral_chisquare(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.noncentral_chisquare(df=5, nonc=5, size=(3, 2))
         desired = np.array([[9.47783251920357, 10.02066178260461],
                             [3.15869984192364, 10.5581565031544],
@@ -983,7 +984,7 @@ class TestRandomDist(object):
                             [1.41985055641800, 0.15451287602753]])
         assert_array_almost_equal(actual, desired, decimal=14)
 
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.noncentral_chisquare(df=5, nonc=0, size=(3, 2))
         desired = np.array([[3.64881368071039, 5.48224544747803],
                             [20.41999842025404, 3.44075915187367],
@@ -991,7 +992,7 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=14)
 
     def test_noncentral_f(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.noncentral_f(dfnum=5, dfden=2, nonc=1,
                                      size=(3, 2))
         desired = np.array([[1.22680230963236, 2.56457837623956],
@@ -1000,12 +1001,12 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=14)
 
     def test_noncentral_f_nan(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.noncentral_f(dfnum=5, dfden=2, nonc=np.nan)
         assert np.isnan(actual)
 
     def test_normal(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.normal(loc=.123456789, scale=2.0, size=(3, 2))
         desired = np.array([[-6.822051212221923, -0.094420339458285],
                             [-0.368474717792823, -1.284746311523402],
@@ -1017,7 +1018,7 @@ class TestRandomDist(object):
         assert_raises(ValueError, random.normal, scale=-0.)
 
     def test_pareto(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.pareto(a=.123456789, size=(3, 2))
         desired = np.array([[5.6883528121891552e+16, 4.0569373841667057e+03],
                             [1.2854967019379475e+12, 6.5833156486851483e+04],
@@ -1031,7 +1032,7 @@ class TestRandomDist(object):
         np.testing.assert_array_almost_equal_nulp(actual, desired, nulp=30)
 
     def test_poisson(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.poisson(lam=.123456789, size=(3, 2))
         desired = np.array([[0, 0],
                             [1, 0],
@@ -1051,7 +1052,7 @@ class TestRandomDist(object):
             assert_raises(ValueError, random.poisson, [np.nan] * 10)
 
     def test_power(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.power(a=.123456789, size=(3, 2))
         desired = np.array([[9.328833342693975e-01, 2.742250409261003e-02],
                             [7.684513237993961e-01, 9.297548209160028e-02],
@@ -1059,7 +1060,7 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=15)
 
     def test_rayleigh(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.rayleigh(scale=10, size=(3, 2))
         desired = np.array([[13.8882496494248393, 13.383318339044731],
                             [20.95413364294492098, 21.08285015800712614],
@@ -1071,7 +1072,7 @@ class TestRandomDist(object):
         assert_raises(ValueError, random.rayleigh, scale=-0.)
 
     def test_standard_cauchy(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.standard_cauchy(size=(3, 2))
         desired = np.array([[31.87809592667601, 0.349332782046838],
                             [2.816995747731641, 10.552372563459114],
@@ -1079,7 +1080,7 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=15)
 
     def test_standard_exponential(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.standard_exponential(size=(3, 2), method='inv')
         desired = np.array([[0.96441739162374596, 0.89556604882105506],
                             [2.1953785836319808, 2.22243285392490542],
@@ -1090,7 +1091,7 @@ class TestRandomDist(object):
         assert_raises(TypeError, random.standard_exponential, dtype=np.int32)
 
     def test_standard_gamma(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.standard_gamma(shape=3, size=(3, 2))
         desired = np.array([[2.28483515569645,  3.29899524967824],
                             [11.12492298902645,  2.16784417297277],
@@ -1098,13 +1099,13 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=14)
 
     def test_standard_gammma_scalar_float(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.standard_gamma(3, dtype=np.float32)
         desired = 1.3877466
         assert_array_almost_equal(actual, desired, decimal=6)
 
     def test_standard_gamma_float(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.standard_gamma(shape=3, size=(3, 2))
         desired = np.array([[2.2848352, 3.2989952],
                             [11.124923, 2.1678442],
@@ -1113,14 +1114,14 @@ class TestRandomDist(object):
 
     def test_standard_gammma_float_out(self):
         actual = np.zeros((3, 2), dtype=np.float32)
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         random.standard_gamma(10.0, out=actual, dtype=np.float32)
         desired = np.array([[6.9824033, 7.3731737],
                             [14.860578, 7.5327270],
                             [11.767487, 6.2320185]], dtype=np.float32)
         assert_array_almost_equal(actual, desired, decimal=5)
 
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         random.standard_gamma(10.0, out=actual, size=(3, 2), dtype=np.float32)
         assert_array_almost_equal(actual, desired, decimal=5)
 
@@ -1140,7 +1141,7 @@ class TestRandomDist(object):
         assert_raises(ValueError, random.standard_gamma, shape=-0.)
 
     def test_standard_normal(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.standard_normal(size=(3, 2))
         desired = np.array([[-3.472754000610961, -0.108938564229143],
                             [-0.245965753396411, -0.704101550261701],
@@ -1151,7 +1152,7 @@ class TestRandomDist(object):
         assert_raises(TypeError, random.standard_normal, dtype=np.int32)
 
     def test_standard_t(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.standard_t(df=10, size=(3, 2))
         desired = np.array([[-3.68722108185508, -0.672031186266171],
                             [2.900224996448669, -0.199656996187739],
@@ -1159,7 +1160,7 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=15)
 
     def test_triangular(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.triangular(left=5.12, mode=10.23, right=20.34,
                                    size=(3, 2))
         desired = np.array([[12.68117178949215784, 12.4129206149193152],
@@ -1168,7 +1169,7 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=14)
 
     def test_uniform(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.uniform(low=1.23, high=10.54, size=(3, 2))
         desired = np.array([[6.99097932346268003, 6.73801597444323974],
                             [9.50364421400426274, 9.53130618907631089],
@@ -1214,7 +1215,7 @@ class TestRandomDist(object):
         assert_raises(TypeError, random.hypergeometric, throwing_int, 1, 1)
 
     def test_vonmises(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.vonmises(mu=1.23, kappa=1.54, size=(3, 2))
         desired = np.array([[2.28567572673902042, 2.89163838442285037],
                             [0.38198375564286025, 2.57638023113890746],
@@ -1223,17 +1224,17 @@ class TestRandomDist(object):
 
     def test_vonmises_small(self):
         # check infinite loop, gh-4720
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         r = random.vonmises(mu=0., kappa=1.1e-8, size=10**6)
         assert_(np.isfinite(r).all())
 
     def test_vonmises_nan(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         r = random.vonmises(mu=0., kappa=np.nan)
         assert_(np.isnan(r))
 
     def test_wald(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.wald(mean=1.23, scale=1.54, size=(3, 2))
         desired = np.array([[0.10653278160339, 0.98771068102461],
                             [0.89276055317879, 0.13640126419923],
@@ -1241,7 +1242,7 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=14)
 
     def test_weibull(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.weibull(a=1.23, size=(3, 2))
         desired = np.array([[3.557276979846361, 1.020870580998542],
                             [2.731847777612348, 1.29148068905082],
@@ -1249,12 +1250,12 @@ class TestRandomDist(object):
         assert_array_almost_equal(actual, desired, decimal=15)
 
     def test_weibull_0(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         assert_equal(random.weibull(a=0, size=12), np.zeros(12))
         assert_raises(ValueError, random.weibull, a=-0.)
 
     def test_zipf(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
         actual = random.zipf(a=1.23, size=(3, 2))
         desired = np.array([[66, 29],
                             [1, 1],
@@ -1269,7 +1270,7 @@ class TestBroadcast(object):
         self.seed = 123456789
 
     def set_seed(self):
-        random.seed(self.seed)
+        random.brng.seed(self.seed)
 
     def test_uniform(self):
         low = [0]
diff --git a/numpy/random/randomgen/tests/test_generator_mt19937_regressions.py b/numpy/random/tests/test_generator_mt19937_regressions.py
index 75064720f..f9478ccf6 100644
--- a/numpy/random/randomgen/tests/test_generator_mt19937_regressions.py
+++ b/numpy/random/tests/test_generator_mt19937_regressions.py
@@ -3,7 +3,7 @@ from numpy.testing import (assert_, assert_array_equal)
 from numpy.compat import long
 import numpy as np
 import pytest
-from ...randomgen import RandomGenerator, MT19937
+from numpy.random import RandomGenerator, MT19937
 
 mt19937 = RandomGenerator(MT19937())
 
@@ -36,7 +36,7 @@ class TestRegression(object):
     def test_logseries_convergence(self):
         # Test for ticket #923
         N = 1000
-        mt19937.seed(0)
+        mt19937.brng.seed(0)
         rvsn = mt19937.logseries(0.8, size=N)
         # these two frequency counts should be close to theoretical
         # numbers with this large sample
@@ -50,9 +50,9 @@ class TestRegression(object):
         assert_(freq < 0.23, msg)
 
     def test_permutation_longs(self):
-        mt19937.seed(1234)
+        mt19937.brng.seed(1234)
         a = mt19937.permutation(12)
-        mt19937.seed(1234)
+        mt19937.brng.seed(1234)
         b = mt19937.permutation(long(12))
         assert_array_equal(a, b)
 
@@ -62,7 +62,7 @@ class TestRegression(object):
                   [(1, 1), (2, 2), (3, 3), None],
                   [1, (2, 2), (3, 3), None],
                   [(1, 1), 2, 3, None]]:
-            mt19937.seed(12345)
+            mt19937.brng.seed(12345)
             shuffled = list(t)
             mt19937.shuffle(shuffled)
             assert_array_equal(shuffled, [t[0], t[3], t[1], t[2]])
@@ -72,8 +72,8 @@ class TestRegression(object):
         m = RandomGenerator(MT19937())  # mt19937.RandomState()
         res = np.array([0, 8, 7, 2, 1, 9, 4, 7, 0, 3])
         for i in range(3):
-            mt19937.seed(i)
-            m.seed(4321)
+            mt19937.brng.seed(i)
+            m.brng.seed(4321)
             # If m.state is not honored, the result will change
             assert_array_equal(m.choice(10, size=10, p=np.ones(10)/10.), res)
 
@@ -88,7 +88,7 @@ class TestRegression(object):
     def test_beta_small_parameters(self):
         # Test that beta with small a and b parameters does not produce
         # NaNs due to roundoff errors causing 0 / 0, gh-5851
-        mt19937.seed(1234567890)
+        mt19937.brng.seed(1234567890)
         x = mt19937.beta(0.0001, 0.0001, size=100)
         assert_(not np.any(np.isnan(x)), 'Nans in mt19937.beta')
 
@@ -96,7 +96,7 @@ class TestRegression(object):
         # The sum of probs should be 1.0 with some tolerance.
         # For low precision dtypes the tolerance was too tight.
         # See numpy github issue 6123.
-        mt19937.seed(1234)
+        mt19937.brng.seed(1234)
         a = [1, 2, 3]
         counts = [4, 4, 2]
         for dt in np.float16, np.float32, np.float64:
@@ -110,7 +110,7 @@ class TestRegression(object):
         # Test that permuting an array of different length strings
         # will not cause a segfault on garbage collection
         # Tests gh-7710
-        mt19937.seed(1234)
+        mt19937.brng.seed(1234)
 
         a = np.array(['a', 'a' * 1000])
 
@@ -125,7 +125,7 @@ class TestRegression(object):
         # Test that permuting an array of objects will not cause
         # a segfault on garbage collection.
         # See gh-7719
-        mt19937.seed(1234)
+        mt19937.brng.seed(1234)
         a = np.array([np.arange(1), np.arange(4)])
 
         for _ in range(1000):
@@ -139,7 +139,7 @@ class TestRegression(object):
         class N(np.ndarray):
             pass
 
-        mt19937.seed(1)
+        mt19937.brng.seed(1)
         orig = np.arange(3).view(N)
         perm = mt19937.permutation(orig)
         assert_array_equal(perm, np.array([0, 2, 1]))
@@ -151,7 +151,7 @@ class TestRegression(object):
             def __array__(self):
                 return self.a
 
-        mt19937.seed(1)
+        mt19937.brng.seed(1)
         m = M()
         perm = mt19937.permutation(m)
         assert_array_equal(perm, np.array([2, 1, 4, 0, 3]))
diff --git a/numpy/random/randomgen/tests/test_randomstate.py b/numpy/random/tests/test_randomstate.py
index 6adde6c2a..d0ad5e794 100644
--- a/numpy/random/randomgen/tests/test_randomstate.py
+++ b/numpy/random/tests/test_randomstate.py
@@ -9,7 +9,7 @@ from numpy.testing import (
         suppress_warnings
         )
 
-from ...randomgen import MT19937, Xoshiro256StarStar, mtrand as random
+from numpy.random import MT19937, Xoshiro256StarStar, mtrand as random
 
 
 def assert_mt19937_state_equal(a, b):
diff --git a/numpy/random/randomgen/tests/test_randomstate_regression.py b/numpy/random/tests/test_randomstate_regression.py
index cf21ee756..9c319319e 100644
--- a/numpy/random/randomgen/tests/test_randomstate_regression.py
+++ b/numpy/random/tests/test_randomstate_regression.py
@@ -5,7 +5,7 @@ from numpy.testing import (
 from numpy.compat import long
 import numpy as np
 
-from ...randomgen import mtrand as random
+from numpy.random import mtrand as random
 
 
 class TestRegression(object):
diff --git a/numpy/random/randomgen/tests/test_smoke.py b/numpy/random/tests/test_smoke.py
index 816ce6ddc..fa7a0b567 100644
--- a/numpy/random/randomgen/tests/test_smoke.py
+++ b/numpy/random/tests/test_smoke.py
@@ -8,7 +8,7 @@ import numpy as np
 import pytest
 from numpy.testing import (assert_almost_equal, assert_equal, assert_,
     assert_array_equal, suppress_warnings)
-from ...randomgen import (RandomGenerator, MT19937, DSFMT, ThreeFry32, ThreeFry,
+from numpy.random import (RandomGenerator, MT19937, DSFMT, ThreeFry32, ThreeFry,
     PCG32, PCG64, Philox, Xoroshiro128, Xorshift1024, Xoshiro256StarStar,
     Xoshiro512StarStar, entropy)
 
@@ -106,7 +106,7 @@ class RNG(object):
         cls.advance = None
         cls.seed = [12345]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls.seed_vector_bits = 64
         cls._extra_setup()
 
@@ -118,39 +118,39 @@ class RNG(object):
         cls.seed_error = TypeError
 
     def _reset_state(self):
-        self.rg.state = self.initial_state
+        self.rg.brng.state = self.initial_state
 
     def test_init(self):
         rg = RandomGenerator(self.brng())
-        state = rg.state
+        state = rg.brng.state
         rg.standard_normal(1)
         rg.standard_normal(1)
-        rg.state = state
-        new_state = rg.state
+        rg.brng.state = state
+        new_state = rg.brng.state
         assert_(comp_state(state, new_state))
 
     def test_advance(self):
-        state = self.rg.state
-        if hasattr(self.rg._basicrng, 'advance'):
-            self.rg._basicrng.advance(self.advance)
-            assert_(not comp_state(state, self.rg.state))
+        state = self.rg.brng.state
+        if hasattr(self.rg.brng, 'advance'):
+            self.rg.brng.advance(self.advance)
+            assert_(not comp_state(state, self.rg.brng.state))
         else:
-            brng_name = self.rg._basicrng.__class__.__name__
+            brng_name = self.rg.brng.__class__.__name__
             pytest.skip('Advance is not supported by {0}'.format(brng_name))
 
     def test_jump(self):
-        state = self.rg.state
-        if hasattr(self.rg._basicrng, 'jump'):
-            self.rg._basicrng.jump()
-            jumped_state = self.rg.state
+        state = self.rg.brng.state
+        if hasattr(self.rg.brng, 'jump'):
+            self.rg.brng.jump()
+            jumped_state = self.rg.brng.state
             assert_(not comp_state(state, jumped_state))
             self.rg.random_sample(2 * 3 * 5 * 7 * 11 * 13 * 17)
-            self.rg.state = state
-            self.rg._basicrng.jump()
-            rejumped_state = self.rg.state
+            self.rg.brng.state = state
+            self.rg.brng.jump()
+            rejumped_state = self.rg.brng.state
             assert_(comp_state(jumped_state, rejumped_state))
         else:
-            brng_name = self.rg._basicrng.__class__.__name__
+            brng_name = self.rg.brng.__class__.__name__
             pytest.skip('Jump is not supported by {0}'.format(brng_name))
 
     def test_uniform(self):
@@ -221,51 +221,51 @@ class RNG(object):
         assert_(self.rg.binomial(1000, .5) >= 0)
 
     def test_reset_state(self):
-        state = self.rg.state
+        state = self.rg.brng.state
         int_1 = self.rg.randint(2**31)
-        self.rg.state = state
+        self.rg.brng.state = state
         int_2 = self.rg.randint(2**31)
         assert_(int_1 == int_2)
 
     def test_entropy_init(self):
         rg = RandomGenerator(self.brng())
         rg2 = RandomGenerator(self.brng())
-        assert_(not comp_state(rg.state, rg2.state))
+        assert_(not comp_state(rg.brng.state, rg2.brng.state))
 
     def test_seed(self):
         rg = RandomGenerator(self.brng(*self.seed))
         rg2 = RandomGenerator(self.brng(*self.seed))
         rg.random_sample()
         rg2.random_sample()
-        assert_(comp_state(rg.state, rg2.state))
+        assert_(comp_state(rg.brng.state, rg2.brng.state))
 
     def test_reset_state_gauss(self):
         rg = RandomGenerator(self.brng(*self.seed))
         rg.standard_normal()
-        state = rg.state
+        state = rg.brng.state
         n1 = rg.standard_normal(size=10)
         rg2 = RandomGenerator(self.brng())
-        rg2.state = state
+        rg2.brng.state = state
         n2 = rg2.standard_normal(size=10)
         assert_array_equal(n1, n2)
 
     def test_reset_state_uint32(self):
         rg = RandomGenerator(self.brng(*self.seed))
         rg.randint(0, 2 ** 24, 120, dtype=np.uint32)
-        state = rg.state
+        state = rg.brng.state
         n1 = rg.randint(0, 2 ** 24, 10, dtype=np.uint32)
         rg2 = RandomGenerator(self.brng())
-        rg2.state = state
+        rg2.brng.state = state
         n2 = rg2.randint(0, 2 ** 24, 10, dtype=np.uint32)
         assert_array_equal(n1, n2)
 
     def test_reset_state_float(self):
         rg = RandomGenerator(self.brng(*self.seed))
         rg.random_sample(dtype='float32')
-        state = rg.state
+        state = rg.brng.state
         n1 = rg.random_sample(size=10, dtype='float32')
         rg2 = RandomGenerator(self.brng())
-        rg2.state = state
+        rg2.brng.state = state
         n2 = rg2.random_sample(size=10, dtype='float32')
         assert_((n1 == n2).all())
 
@@ -354,29 +354,29 @@ class RNG(object):
         assert_(len(vals) == 10)
 
     def test_rand(self):
-        state = self.rg.state
+        state = self.rg.brng.state
         vals = self.rg.rand(10, 10, 10)
-        self.rg.state = state
+        self.rg.brng.state = state
         assert_((vals == self.rg.random_sample((10, 10, 10))).all())
         assert_(vals.shape == (10, 10, 10))
         vals = self.rg.rand(10, 10, 10, dtype=np.float32)
         assert_(vals.shape == (10, 10, 10))
 
     def test_randn(self):
-        state = self.rg.state
+        state = self.rg.brng.state
         vals = self.rg.randn(10, 10, 10)
-        self.rg.state = state
+        self.rg.brng.state = state
         assert_equal(vals, self.rg.standard_normal((10, 10, 10)))
         assert_equal(vals.shape, (10, 10, 10))
 
-        state = self.rg.state
+        state = self.rg.brng.state
         vals = self.rg.randn(10, 10, 10)
-        self.rg.state = state
+        self.rg.brng.state = state
         assert_equal(vals, self.rg.standard_normal((10, 10, 10)))
 
-        state = self.rg.state
+        state = self.rg.brng.state
         self.rg.randn(10, 10, 10)
-        self.rg.state = state
+        self.rg.brng.state = state
         vals = self.rg.randn(10, 10, 10, dtype=np.float32)
         assert_(vals.shape == (10, 10, 10))
 
@@ -487,12 +487,12 @@ class RNG(object):
         pick = pickle.dumps(self.rg)
         unpick = pickle.loads(pick)
         assert_((type(self.rg) == type(unpick)))
-        assert_(comp_state(self.rg.state, unpick.state))
+        assert_(comp_state(self.rg.brng.state, unpick.brng.state))
 
         pick = pickle.dumps(self.rg)
         unpick = pickle.loads(pick)
         assert_((type(self.rg) == type(unpick)))
-        assert_(comp_state(self.rg.state, unpick.state))
+        assert_(comp_state(self.rg.brng.state, unpick.brng.state))
 
     def test_seed_array(self):
         if self.seed_vector_bits is None:
@@ -505,32 +505,32 @@ class RNG(object):
         else:
             dtype = np.uint64
         seed = np.array([1], dtype=dtype)
-        self.rg.seed(seed)
-        state1 = self.rg.state
-        self.rg.seed(1)
-        state2 = self.rg.state
+        self.rg.brng.seed(seed)
+        state1 = self.rg.brng.state
+        self.rg.brng.seed(1)
+        state2 = self.rg.brng.state
         assert_(comp_state(state1, state2))
 
         seed = np.arange(4, dtype=dtype)
-        self.rg.seed(seed)
-        state1 = self.rg.state
-        self.rg.seed(seed[0])
-        state2 = self.rg.state
+        self.rg.brng.seed(seed)
+        state1 = self.rg.brng.state
+        self.rg.brng.seed(seed[0])
+        state2 = self.rg.brng.state
         assert_(not comp_state(state1, state2))
 
         seed = np.arange(1500, dtype=dtype)
-        self.rg.seed(seed)
-        state1 = self.rg.state
-        self.rg.seed(seed[0])
-        state2 = self.rg.state
+        self.rg.brng.seed(seed)
+        state1 = self.rg.brng.state
+        self.rg.brng.seed(seed[0])
+        state2 = self.rg.brng.state
         assert_(not comp_state(state1, state2))
 
         seed = 2 ** np.mod(np.arange(1500, dtype=dtype),
                            self.seed_vector_bits - 1) + 1
-        self.rg.seed(seed)
-        state1 = self.rg.state
-        self.rg.seed(seed[0])
-        state2 = self.rg.state
+        self.rg.brng.seed(seed)
+        state1 = self.rg.brng.state
+        self.rg.brng.seed(seed[0])
+        state2 = self.rg.brng.state
         assert_(not comp_state(state1, state2))
 
     def test_seed_array_error(self):
@@ -541,164 +541,164 @@ class RNG(object):
 
         seed = -1
         with pytest.raises(ValueError):
-            self.rg.seed(seed)
+            self.rg.brng.seed(seed)
 
         seed = np.array([-1], dtype=np.int32)
         with pytest.raises(ValueError):
-            self.rg.seed(seed)
+            self.rg.brng.seed(seed)
 
         seed = np.array([1, 2, 3, -5], dtype=np.int32)
         with pytest.raises(ValueError):
-            self.rg.seed(seed)
+            self.rg.brng.seed(seed)
 
         seed = np.array([1, 2, 3, out_of_bounds])
         with pytest.raises(ValueError):
-            self.rg.seed(seed)
+            self.rg.brng.seed(seed)
 
     def test_uniform_float(self):
         rg = RandomGenerator(self.brng(12345))
         warmup(rg)
-        state = rg.state
+        state = rg.brng.state
         r1 = rg.random_sample(11, dtype=np.float32)
         rg2 = RandomGenerator(self.brng())
         warmup(rg2)
-        rg2.state = state
+        rg2.brng.state = state
         r2 = rg2.random_sample(11, dtype=np.float32)
         assert_array_equal(r1, r2)
         assert_equal(r1.dtype, np.float32)
-        assert_(comp_state(rg.state, rg2.state))
+        assert_(comp_state(rg.brng.state, rg2.brng.state))
 
     def test_gamma_floats(self):
         rg = RandomGenerator(self.brng())
         warmup(rg)
-        state = rg.state
+        state = rg.brng.state
         r1 = rg.standard_gamma(4.0, 11, dtype=np.float32)
         rg2 = RandomGenerator(self.brng())
         warmup(rg2)
-        rg2.state = state
+        rg2.brng.state = state
         r2 = rg2.standard_gamma(4.0, 11, dtype=np.float32)
         assert_array_equal(r1, r2)
         assert_equal(r1.dtype, np.float32)
-        assert_(comp_state(rg.state, rg2.state))
+        assert_(comp_state(rg.brng.state, rg2.brng.state))
 
     def test_normal_floats(self):
         rg = RandomGenerator(self.brng())
         warmup(rg)
-        state = rg.state
+        state = rg.brng.state
         r1 = rg.standard_normal(11, dtype=np.float32)
         rg2 = RandomGenerator(self.brng())
         warmup(rg2)
-        rg2.state = state
+        rg2.brng.state = state
         r2 = rg2.standard_normal(11, dtype=np.float32)
         assert_array_equal(r1, r2)
         assert_equal(r1.dtype, np.float32)
-        assert_(comp_state(rg.state, rg2.state))
+        assert_(comp_state(rg.brng.state, rg2.brng.state))
 
     def test_normal_zig_floats(self):
         rg = RandomGenerator(self.brng())
         warmup(rg)
-        state = rg.state
+        state = rg.brng.state
         r1 = rg.standard_normal(11, dtype=np.float32)
         rg2 = RandomGenerator(self.brng())
         warmup(rg2)
-        rg2.state = state
+        rg2.brng.state = state
         r2 = rg2.standard_normal(11, dtype=np.float32)
         assert_array_equal(r1, r2)
         assert_equal(r1.dtype, np.float32)
-        assert_(comp_state(rg.state, rg2.state))
+        assert_(comp_state(rg.brng.state, rg2.brng.state))
 
     def test_output_fill(self):
         rg = self.rg
-        state = rg.state
+        state = rg.brng.state
         size = (31, 7, 97)
         existing = np.empty(size)
-        rg.state = state
+        rg.brng.state = state
         rg.standard_normal(out=existing)
-        rg.state = state
+        rg.brng.state = state
         direct = rg.standard_normal(size=size)
         assert_equal(direct, existing)
 
         sized = np.empty(size)
-        rg.state = state
+        rg.brng.state = state
         rg.standard_normal(out=sized, size=sized.shape)
 
         existing = np.empty(size, dtype=np.float32)
-        rg.state = state
+        rg.brng.state = state
         rg.standard_normal(out=existing, dtype=np.float32)
-        rg.state = state
+        rg.brng.state = state
         direct = rg.standard_normal(size=size, dtype=np.float32)
         assert_equal(direct, existing)
 
     def test_output_filling_uniform(self):
         rg = self.rg
-        state = rg.state
+        state = rg.brng.state
         size = (31, 7, 97)
         existing = np.empty(size)
-        rg.state = state
+        rg.brng.state = state
         rg.random_sample(out=existing)
-        rg.state = state
+        rg.brng.state = state
         direct = rg.random_sample(size=size)
         assert_equal(direct, existing)
 
         existing = np.empty(size, dtype=np.float32)
-        rg.state = state
+        rg.brng.state = state
         rg.random_sample(out=existing, dtype=np.float32)
-        rg.state = state
+        rg.brng.state = state
         direct = rg.random_sample(size=size, dtype=np.float32)
         assert_equal(direct, existing)
 
     def test_output_filling_exponential(self):
         rg = self.rg
-        state = rg.state
+        state = rg.brng.state
         size = (31, 7, 97)
         existing = np.empty(size)
-        rg.state = state
+        rg.brng.state = state
         rg.standard_exponential(out=existing)
-        rg.state = state
+        rg.brng.state = state
         direct = rg.standard_exponential(size=size)
         assert_equal(direct, existing)
 
         existing = np.empty(size, dtype=np.float32)
-        rg.state = state
+        rg.brng.state = state
         rg.standard_exponential(out=existing, dtype=np.float32)
-        rg.state = state
+        rg.brng.state = state
         direct = rg.standard_exponential(size=size, dtype=np.float32)
         assert_equal(direct, existing)
 
     def test_output_filling_gamma(self):
         rg = self.rg
-        state = rg.state
+        state = rg.brng.state
         size = (31, 7, 97)
         existing = np.zeros(size)
-        rg.state = state
+        rg.brng.state = state
         rg.standard_gamma(1.0, out=existing)
-        rg.state = state
+        rg.brng.state = state
         direct = rg.standard_gamma(1.0, size=size)
         assert_equal(direct, existing)
 
         existing = np.zeros(size, dtype=np.float32)
-        rg.state = state
+        rg.brng.state = state
         rg.standard_gamma(1.0, out=existing, dtype=np.float32)
-        rg.state = state
+        rg.brng.state = state
         direct = rg.standard_gamma(1.0, size=size, dtype=np.float32)
         assert_equal(direct, existing)
 
     def test_output_filling_gamma_broadcast(self):
         rg = self.rg
-        state = rg.state
+        state = rg.brng.state
         size = (31, 7, 97)
         mu = np.arange(97.0) + 1.0
         existing = np.zeros(size)
-        rg.state = state
+        rg.brng.state = state
         rg.standard_gamma(mu, out=existing)
-        rg.state = state
+        rg.brng.state = state
         direct = rg.standard_gamma(mu, size=size)
         assert_equal(direct, existing)
 
         existing = np.zeros(size, dtype=np.float32)
-        rg.state = state
+        rg.brng.state = state
         rg.standard_gamma(mu, out=existing, dtype=np.float32)
-        rg.state = state
+        rg.brng.state = state
         direct = rg.standard_gamma(mu, size=size, dtype=np.float32)
         assert_equal(direct, existing)
 
@@ -796,7 +796,7 @@ class TestMT19937(RNG):
         cls.advance = None
         cls.seed = [2 ** 21 + 2 ** 16 + 2 ** 5 + 1]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls.seed_vector_bits = 32
         cls._extra_setup()
         cls.seed_error = ValueError
@@ -805,8 +805,8 @@ class TestMT19937(RNG):
         nprg = np.random.RandomState()
         nprg.standard_normal(99)
         state = nprg.get_state()
-        self.rg.state = state
-        state2 = self.rg.state
+        self.rg.brng.state = state
+        state2 = self.rg.brng.state
         assert_((state[1] == state2['state']['key']).all())
         assert_((state[2] == state2['state']['pos']))
 
@@ -819,7 +819,7 @@ class TestPCG64(RNG):
         cls.seed = [2 ** 96 + 2 ** 48 + 2 ** 21 + 2 ** 16 + 2 ** 5 + 1,
                     2 ** 21 + 2 ** 16 + 2 ** 5 + 1]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls.seed_vector_bits = None
         cls._extra_setup()
 
@@ -832,20 +832,20 @@ class TestPCG64(RNG):
 
         seed = -1
         with pytest.raises(ValueError):
-            self.rg.seed(seed)
+            self.rg.brng.seed(seed)
 
         error_type = ValueError if self.seed_vector_bits else TypeError
         seed = np.array([-1], dtype=np.int32)
         with pytest.raises(error_type):
-            self.rg.seed(seed)
+            self.rg.brng.seed(seed)
 
         seed = np.array([1, 2, 3, -5], dtype=np.int32)
         with pytest.raises(error_type):
-            self.rg.seed(seed)
+            self.rg.brng.seed(seed)
 
         seed = np.array([1, 2, 3, out_of_bounds])
         with pytest.raises(error_type):
-            self.rg.seed(seed)
+            self.rg.brng.seed(seed)
 
 
 class TestPhilox(RNG):
@@ -855,7 +855,7 @@ class TestPhilox(RNG):
         cls.advance = 2**63 + 2**31 + 2**15 + 1
         cls.seed = [12345]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls.seed_vector_bits = 64
         cls._extra_setup()
 
@@ -867,7 +867,7 @@ class TestThreeFry(RNG):
         cls.advance = 2 ** 63 + 2 ** 31 + 2 ** 15 + 1
         cls.seed = [12345]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls.seed_vector_bits = 64
         cls._extra_setup()
 
@@ -879,7 +879,7 @@ class TestXoroshiro128(RNG):
         cls.advance = None
         cls.seed = [12345]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls.seed_vector_bits = 64
         cls._extra_setup()
 
@@ -891,7 +891,7 @@ class TestXoshiro256StarStar(RNG):
         cls.advance = None
         cls.seed = [12345]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls.seed_vector_bits = 64
         cls._extra_setup()
 
@@ -903,7 +903,7 @@ class TestXoshiro512StarStar(RNG):
         cls.advance = None
         cls.seed = [12345]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls.seed_vector_bits = 64
         cls._extra_setup()
 
@@ -915,7 +915,7 @@ class TestXorshift1024(RNG):
         cls.advance = None
         cls.seed = [12345]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls.seed_vector_bits = 64
         cls._extra_setup()
 
@@ -927,7 +927,7 @@ class TestDSFMT(RNG):
         cls.advance = None
         cls.seed = [12345]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls._extra_setup()
         cls.seed_vector_bits = 32
 
@@ -939,7 +939,7 @@ class TestThreeFry32(RNG):
         cls.advance = 2**63 + 2**31 + 2**15 + 1
         cls.seed = [2 ** 21 + 2 ** 16 + 2 ** 5 + 1]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls.seed_vector_bits = 64
         cls._extra_setup()
         cls.seed_error = ValueError
@@ -972,6 +972,6 @@ class TestPCG32(TestPCG64):
         cls.seed = [2 ** 48 + 2 ** 21 + 2 ** 16 + 2 ** 5 + 1,
                     2 ** 21 + 2 ** 16 + 2 ** 5 + 1]
         cls.rg = RandomGenerator(cls.brng(*cls.seed))
-        cls.initial_state = cls.rg.state
+        cls.initial_state = cls.rg.brng.state
         cls.seed_vector_bits = None
         cls._extra_setup()
diff --git a/numpy/random/randomgen/threefry.pyx b/numpy/random/threefry.pyx
index 8140c6a9b..8140c6a9b 100644
--- a/numpy/random/randomgen/threefry.pyx
+++ b/numpy/random/threefry.pyx
diff --git a/numpy/random/randomgen/threefry32.pyx b/numpy/random/threefry32.pyx
index 1fa98eabd..1fa98eabd 100644
--- a/numpy/random/randomgen/threefry32.pyx
+++ b/numpy/random/threefry32.pyx
diff --git a/numpy/random/randomgen/xoroshiro128.pyx b/numpy/random/xoroshiro128.pyx
index 7795500e8..7795500e8 100644
--- a/numpy/random/randomgen/xoroshiro128.pyx
+++ b/numpy/random/xoroshiro128.pyx
diff --git a/numpy/random/randomgen/xorshift1024.pyx b/numpy/random/xorshift1024.pyx
index 3c7ffac52..3c7ffac52 100644
--- a/numpy/random/randomgen/xorshift1024.pyx
+++ b/numpy/random/xorshift1024.pyx
diff --git a/numpy/random/randomgen/xoshiro256starstar.pyx b/numpy/random/xoshiro256starstar.pyx
index c3856b6f7..c3856b6f7 100644
--- a/numpy/random/randomgen/xoshiro256starstar.pyx
+++ b/numpy/random/xoshiro256starstar.pyx
diff --git a/numpy/random/randomgen/xoshiro512starstar.pyx b/numpy/random/xoshiro512starstar.pyx
index 761d1f1d0..761d1f1d0 100644
--- a/numpy/random/randomgen/xoshiro512starstar.pyx
+++ b/numpy/random/xoshiro512starstar.pyx