02.Numpy.array基础.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11.8 numpy.array基础"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看numpy版本\n",
    "`numpy.__version__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.19.2'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy\n",
    "numpy.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python List的特点\n",
    "对列表的类型不做具体限定，从而导致效率较低，要审查列表中的每一个元素。\n",
    "array函数，可以设置为某一具体的类型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = array.array('i', [i for i in range(10)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array('i', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## numpy.array\n",
    "只能存储一种类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "nparr = np.array([i for i in range(10)])\n",
    "nparr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nparr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "nparr[4] = 3.33"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 3, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nparr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "array函数中如果是整形，插入浮点会自动变成整形，具有自动转换的性质。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "nparr = np.array([1, 2, 3.0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nparr.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 其他创建numpy.array的方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(10, dtype = int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(shape = (3, 5), dtype = int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`np.zeros(shape = (3, 5), dtype = int)`\n",
    "和\n",
    "`np.zeros((3, 5), dtype = int)`相同。\n",
    "\n",
    "`np.zeros(3, 5)`代表生成3x5的零矩阵\n",
    "\n",
    "`np.ones(3, 5)`代表生成3x5每个参数为1的矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[666., 666., 666., 666., 666.],\n",
       "       [666., 666., 666., 666., 666.],\n",
       "       [666., 666., 666., 666., 666.]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full(shape = (3, 5), fill_value = 666.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([666, 666, 666, 666, 666, 666, 666, 666, 666, 666])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full(shape = 10, fill_value = 666)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## arange\n",
    "与python区别是步长可以设置间隔为浮点型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  2.5,  5. ,  7.5, 10. , 12.5, 15. , 17.5])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0, 20, 2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## linspace\n",
    "`np.linspace(0, 20, 10)`表示起始点和终点等距截取10个点（包括0，20）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  2.22222222,  4.44444444,  6.66666667,  8.88888889,\n",
       "       11.11111111, 13.33333333, 15.55555556, 17.77777778, 20.        ])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 20, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## random\n",
    "randint随机数区间是前闭后开"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(0, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 5, 7, 7, 9, 8, 5, 8, 4, 4])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(0, 10, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`np.random.randint(4, 8, size = 10)` size代表个数，也可以插入矩阵3x4 `np.random.randint(4, 8, size = (3, 4))`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 7, 7, 6, 7, 7, 6, 5, 5, 5])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(4, 8, size = 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "随机种子seed可以人为调试生成的随机数相同"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 6, 5, 7, 7, 5, 7, 4, 6, 5])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(4, 8, size = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(666)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 6, 5, 6, 6, 6, 5, 6, 4, 5])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(4, 8, size = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 6, 5, 6, 6, 6, 5, 6, 4, 5])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(666)\n",
    "np.random.randint(4, 8, size = 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`np.random.random()`随机生成一个浮点数～U（0， 1）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.012703197034767633"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`np.random.normal(a, b, size = n)`随机生成n个浮点数～N（a，b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.571721451899459"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.normal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.78100546,  1.03805653, -0.88752213,  2.28114631, -0.57288634],\n",
       "       [ 2.21773999, -0.8620237 ,  2.9564445 , -0.47383612,  0.40253476],\n",
       "       [ 0.07882525, -1.17758597, -0.15154149, -2.36580154,  1.4583705 ]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.normal(1, 2, size = (3, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on package numpy.random in numpy:\n",
      "\n",
      "NAME\n",
      "    numpy.random\n",
      "\n",
      "DESCRIPTION\n",
      "    ========================\n",
      "    Random Number Generation\n",
      "    ========================\n",
      "    \n",
      "    Use ``default_rng()`` to create a `Generator` and call its methods.\n",
      "    \n",
      "    =============== =========================================================\n",
      "    Generator\n",
      "    --------------- ---------------------------------------------------------\n",
      "    Generator       Class implementing all of the random number distributions\n",
      "    default_rng     Default constructor for ``Generator``\n",
      "    =============== =========================================================\n",
      "    \n",
      "    ============================================= ===\n",
      "    BitGenerator Streams that work with Generator\n",
      "    --------------------------------------------- ---\n",
      "    MT19937\n",
      "    PCG64\n",
      "    Philox\n",
      "    SFC64\n",
      "    ============================================= ===\n",
      "    \n",
      "    ============================================= ===\n",
      "    Getting entropy to initialize a BitGenerator\n",
      "    --------------------------------------------- ---\n",
      "    SeedSequence\n",
      "    ============================================= ===\n",
      "    \n",
      "    \n",
      "    Legacy\n",
      "    ------\n",
      "    \n",
      "    For backwards compatibility with previous versions of numpy before 1.17, the\n",
      "    various aliases to the global `RandomState` methods are left alone and do not\n",
      "    use the new `Generator` API.\n",
      "    \n",
      "    ==================== =========================================================\n",
      "    Utility functions\n",
      "    -------------------- ---------------------------------------------------------\n",
      "    random               Uniformly distributed floats over ``[0, 1)``\n",
      "    bytes                Uniformly distributed random bytes.\n",
      "    permutation          Randomly permute a sequence / generate a random sequence.\n",
      "    shuffle              Randomly permute a sequence in place.\n",
      "    choice               Random sample from 1-D array.\n",
      "    ==================== =========================================================\n",
      "    \n",
      "    ==================== =========================================================\n",
      "    Compatibility\n",
      "    functions - removed\n",
      "    in the new API\n",
      "    -------------------- ---------------------------------------------------------\n",
      "    rand                 Uniformly distributed values.\n",
      "    randn                Normally distributed values.\n",
      "    ranf                 Uniformly distributed floating point numbers.\n",
      "    random_integers      Uniformly distributed integers in a given range.\n",
      "                         (deprecated, use ``integers(..., closed=True)`` instead)\n",
      "    random_sample        Alias for `random_sample`\n",
      "    randint              Uniformly distributed integers in a given range\n",
      "    seed                 Seed the legacy random number generator.\n",
      "    ==================== =========================================================\n",
      "    \n",
      "    ==================== =========================================================\n",
      "    Univariate\n",
      "    distributions\n",
      "    -------------------- ---------------------------------------------------------\n",
      "    beta                 Beta distribution over ``[0, 1]``.\n",
      "    binomial             Binomial distribution.\n",
      "    chisquare            :math:`\\chi^2` distribution.\n",
      "    exponential          Exponential distribution.\n",
      "    f                    F (Fisher-Snedecor) distribution.\n",
      "    gamma                Gamma distribution.\n",
      "    geometric            Geometric distribution.\n",
      "    gumbel               Gumbel distribution.\n",
      "    hypergeometric       Hypergeometric distribution.\n",
      "    laplace              Laplace distribution.\n",
      "    logistic             Logistic distribution.\n",
      "    lognormal            Log-normal distribution.\n",
      "    logseries            Logarithmic series distribution.\n",
      "    negative_binomial    Negative binomial distribution.\n",
      "    noncentral_chisquare Non-central chi-square distribution.\n",
      "    noncentral_f         Non-central F distribution.\n",
      "    normal               Normal / Gaussian distribution.\n",
      "    pareto               Pareto distribution.\n",
      "    poisson              Poisson distribution.\n",
      "    power                Power distribution.\n",
      "    rayleigh             Rayleigh distribution.\n",
      "    triangular           Triangular distribution.\n",
      "    uniform              Uniform distribution.\n",
      "    vonmises             Von Mises circular distribution.\n",
      "    wald                 Wald (inverse Gaussian) distribution.\n",
      "    weibull              Weibull distribution.\n",
      "    zipf                 Zipf's distribution over ranked data.\n",
      "    ==================== =========================================================\n",
      "    \n",
      "    ==================== ==========================================================\n",
      "    Multivariate\n",
      "    distributions\n",
      "    -------------------- ----------------------------------------------------------\n",
      "    dirichlet            Multivariate generalization of Beta distribution.\n",
      "    multinomial          Multivariate generalization of the binomial distribution.\n",
      "    multivariate_normal  Multivariate generalization of the normal distribution.\n",
      "    ==================== ==========================================================\n",
      "    \n",
      "    ==================== =========================================================\n",
      "    Standard\n",
      "    distributions\n",
      "    -------------------- ---------------------------------------------------------\n",
      "    standard_cauchy      Standard Cauchy-Lorentz distribution.\n",
      "    standard_exponential Standard exponential distribution.\n",
      "    standard_gamma       Standard Gamma distribution.\n",
      "    standard_normal      Standard normal distribution.\n",
      "    standard_t           Standard Student's t-distribution.\n",
      "    ==================== =========================================================\n",
      "    \n",
      "    ==================== =========================================================\n",
      "    Internal functions\n",
      "    -------------------- ---------------------------------------------------------\n",
      "    get_state            Get tuple representing internal state of generator.\n",
      "    set_state            Set state of generator.\n",
      "    ==================== =========================================================\n",
      "\n",
      "PACKAGE CONTENTS\n",
      "    _bounded_integers\n",
      "    _common\n",
      "    _generator\n",
      "    _mt19937\n",
      "    _pcg64\n",
      "    _philox\n",
      "    _pickle\n",
      "    _sfc64\n",
      "    bit_generator\n",
      "    mtrand\n",
      "    setup\n",
      "    tests (package)\n",
      "\n",
      "CLASSES\n",
      "    builtins.object\n",
      "        numpy.random._generator.Generator\n",
      "        numpy.random.bit_generator.BitGenerator\n",
      "            numpy.random._mt19937.MT19937\n",
      "            numpy.random._pcg64.PCG64\n",
      "            numpy.random._philox.Philox\n",
      "            numpy.random._sfc64.SFC64\n",
      "        numpy.random.bit_generator.SeedSequence\n",
      "        numpy.random.mtrand.RandomState\n",
      "    \n",
      "    class BitGenerator(builtins.object)\n",
      "     |  BitGenerator(seed=None)\n",
      "     |  \n",
      "     |  Base Class for generic BitGenerators, which provide a stream\n",
      "     |  of random bits based on different algorithms. Must be overridden.\n",
      "     |  \n",
      "     |  Parameters\n",
      "     |  ----------\n",
      "     |  seed : {None, int, array_like[ints], SeedSequence}, optional\n",
      "     |      A seed to initialize the `BitGenerator`. If None, then fresh,\n",
      "     |      unpredictable entropy will be pulled from the OS. If an ``int`` or\n",
      "     |      ``array_like[ints]`` is passed, then it will be passed to\n",
      "     |      ~`numpy.random.SeedSequence` to derive the initial `BitGenerator` state.\n",
      "     |      One may also pass in a `SeedSequence` instance.\n",
      "     |  \n",
      "     |  Attributes\n",
      "     |  ----------\n",
      "     |  lock : threading.Lock\n",
      "     |      Lock instance that is shared so that the same BitGenerator can\n",
      "     |      be used in multiple Generators without corrupting the state. Code that\n",
      "     |      generates values from a bit generator should hold the bit generator's\n",
      "     |      lock.\n",
      "     |  \n",
      "     |  See Also\n",
      "     |  -------\n",
      "     |  SeedSequence\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getstate__(...)\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  random_raw(...)\n",
      "     |      random_raw(self, size=None)\n",
      "     |      \n",
      "     |      Return randoms as generated by the underlying BitGenerator\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      output : bool, optional\n",
      "     |          Output values.  Used for performance testing since the generated\n",
      "     |          values are not returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : uint or ndarray\n",
      "     |          Drawn samples.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      This method directly exposes the the raw underlying pseudo-random\n",
      "     |      number generator. All values are returned as unsigned 64-bit\n",
      "     |      values irrespective of the number of bits produced by the PRNG.\n",
      "     |      \n",
      "     |      See the class docstring for the number of bits returned.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  capsule\n",
      "     |  \n",
      "     |  cffi\n",
      "     |      CFFI interface\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      interface : namedtuple\n",
      "     |          Named tuple containing CFFI wrapper\n",
      "     |      \n",
      "     |          * state_address - Memory address of the state struct\n",
      "     |          * state - pointer to the state struct\n",
      "     |          * next_uint64 - function pointer to produce 64 bit integers\n",
      "     |          * next_uint32 - function pointer to produce 32 bit integers\n",
      "     |          * next_double - function pointer to produce doubles\n",
      "     |          * bitgen - pointer to the bit generator struct\n",
      "     |  \n",
      "     |  ctypes\n",
      "     |      ctypes interface\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      interface : namedtuple\n",
      "     |          Named tuple containing ctypes wrapper\n",
      "     |      \n",
      "     |          * state_address - Memory address of the state struct\n",
      "     |          * state - pointer to the state struct\n",
      "     |          * next_uint64 - function pointer to produce 64 bit integers\n",
      "     |          * next_uint32 - function pointer to produce 32 bit integers\n",
      "     |          * next_double - function pointer to produce doubles\n",
      "     |          * bitgen - pointer to the bit generator struct\n",
      "     |  \n",
      "     |  lock\n",
      "     |  \n",
      "     |  state\n",
      "     |      Get or set the PRNG state\n",
      "     |      \n",
      "     |      The base BitGenerator.state must be overridden by a subclass\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      state : dict\n",
      "     |          Dictionary containing the information required to describe the\n",
      "     |          state of the PRNG\n",
      "    \n",
      "    class Generator(builtins.object)\n",
      "     |  Generator(bit_generator)\n",
      "     |  \n",
      "     |  Container for the BitGenerators.\n",
      "     |  \n",
      "     |  ``Generator`` exposes a number of methods for generating random\n",
      "     |  numbers drawn from a variety of probability distributions. In addition to\n",
      "     |  the distribution-specific arguments, each method takes a keyword argument\n",
      "     |  `size` that defaults to ``None``. If `size` is ``None``, then a single\n",
      "     |  value is generated and returned. If `size` is an integer, then a 1-D\n",
      "     |  array filled with generated values is returned. If `size` is a tuple,\n",
      "     |  then an array with that shape is filled and returned.\n",
      "     |  \n",
      "     |  The function :func:`numpy.random.default_rng` will instantiate\n",
      "     |  a `Generator` with numpy's default `BitGenerator`.\n",
      "     |  \n",
      "     |  **No Compatibility Guarantee**\n",
      "     |  \n",
      "     |  ``Generator`` does not provide a version compatibility guarantee. In\n",
      "     |  particular, as better algorithms evolve the bit stream may change.\n",
      "     |  \n",
      "     |  Parameters\n",
      "     |  ----------\n",
      "     |  bit_generator : BitGenerator\n",
      "     |      BitGenerator to use as the core generator.\n",
      "     |  \n",
      "     |  Notes\n",
      "     |  -----\n",
      "     |  The Python stdlib module `random` contains pseudo-random number generator\n",
      "     |  with a number of methods that are similar to the ones available in\n",
      "     |  ``Generator``. It uses Mersenne Twister, and this bit generator can\n",
      "     |  be accessed using ``MT19937``. ``Generator``, besides being\n",
      "     |  NumPy-aware, has the advantage that it provides a much larger number\n",
      "     |  of probability distributions to choose from.\n",
      "     |  \n",
      "     |  Examples\n",
      "     |  --------\n",
      "     |  >>> from numpy.random import Generator, PCG64\n",
      "     |  >>> rg = Generator(PCG64())\n",
      "     |  >>> rg.standard_normal()\n",
      "     |  -0.203  # random\n",
      "     |  \n",
      "     |  See Also\n",
      "     |  --------\n",
      "     |  default_rng : Recommended constructor for `Generator`.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getstate__(...)\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  beta(...)\n",
      "     |      beta(a, b, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Beta distribution.\n",
      "     |      \n",
      "     |      The Beta distribution is a special case of the Dirichlet distribution,\n",
      "     |      and is related to the Gamma distribution.  It has the probability\n",
      "     |      distribution function\n",
      "     |      \n",
      "     |      .. math:: f(x; a,b) = \\frac{1}{B(\\alpha, \\beta)} x^{\\alpha - 1}\n",
      "     |                                                       (1 - x)^{\\beta - 1},\n",
      "     |      \n",
      "     |      where the normalization, B, is the beta function,\n",
      "     |      \n",
      "     |      .. math:: B(\\alpha, \\beta) = \\int_0^1 t^{\\alpha - 1}\n",
      "     |                                   (1 - t)^{\\beta - 1} dt.\n",
      "     |      \n",
      "     |      It is often seen in Bayesian inference and order statistics.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : float or array_like of floats\n",
      "     |          Alpha, positive (>0).\n",
      "     |      b : float or array_like of floats\n",
      "     |          Beta, positive (>0).\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``a`` and ``b`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(a, b).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized beta distribution.\n",
      "     |  \n",
      "     |  binomial(...)\n",
      "     |      binomial(n, p, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a binomial distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a binomial distribution with specified\n",
      "     |      parameters, n trials and p probability of success where\n",
      "     |      n an integer >= 0 and p is in the interval [0,1]. (n may be\n",
      "     |      input as a float, but it is truncated to an integer in use)\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      n : int or array_like of ints\n",
      "     |          Parameter of the distribution, >= 0. Floats are also accepted,\n",
      "     |          but they will be truncated to integers.\n",
      "     |      p : float or array_like of floats\n",
      "     |          Parameter of the distribution, >= 0 and <=1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``n`` and ``p`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized binomial distribution, where\n",
      "     |          each sample is equal to the number of successes over the n trials.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.binom : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the binomial distribution is\n",
      "     |      \n",
      "     |      .. math:: P(N) = \\binom{n}{N}p^N(1-p)^{n-N},\n",
      "     |      \n",
      "     |      where :math:`n` is the number of trials, :math:`p` is the probability\n",
      "     |      of success, and :math:`N` is the number of successes.\n",
      "     |      \n",
      "     |      When estimating the standard error of a proportion in a population by\n",
      "     |      using a random sample, the normal distribution works well unless the\n",
      "     |      product p*n <=5, where p = population proportion estimate, and n =\n",
      "     |      number of samples, in which case the binomial distribution is used\n",
      "     |      instead. For example, a sample of 15 people shows 4 who are left\n",
      "     |      handed, and 11 who are right handed. Then p = 4/15 = 27%. 0.27*15 = 4,\n",
      "     |      so the binomial distribution should be used in this case.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Dalgaard, Peter, \"Introductory Statistics with R\",\n",
      "     |             Springer-Verlag, 2002.\n",
      "     |      .. [2] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n",
      "     |             Fifth Edition, 2002.\n",
      "     |      .. [3] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n",
      "     |             and Quigley, 1972.\n",
      "     |      .. [4] Weisstein, Eric W. \"Binomial Distribution.\" From MathWorld--A\n",
      "     |             Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/BinomialDistribution.html\n",
      "     |      .. [5] Wikipedia, \"Binomial distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Binomial_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> n, p = 10, .5  # number of trials, probability of each trial\n",
      "     |      >>> s = rng.binomial(n, p, 1000)\n",
      "     |      # result of flipping a coin 10 times, tested 1000 times.\n",
      "     |      \n",
      "     |      A real world example. A company drills 9 wild-cat oil exploration\n",
      "     |      wells, each with an estimated probability of success of 0.1. All nine\n",
      "     |      wells fail. What is the probability of that happening?\n",
      "     |      \n",
      "     |      Let's do 20,000 trials of the model, and count the number that\n",
      "     |      generate zero positive results.\n",
      "     |      \n",
      "     |      >>> sum(rng.binomial(9, 0.1, 20000) == 0)/20000.\n",
      "     |      # answer = 0.38885, or 38%.\n",
      "     |  \n",
      "     |  bytes(...)\n",
      "     |      bytes(length)\n",
      "     |      \n",
      "     |      Return random bytes.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      length : int\n",
      "     |          Number of random bytes.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : str\n",
      "     |          String of length `length`.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> np.random.default_rng().bytes(10)\n",
      "     |      ' eh\\x85\\x022SZ\\xbf\\xa4' #random\n",
      "     |  \n",
      "     |  chisquare(...)\n",
      "     |      chisquare(df, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a chi-square distribution.\n",
      "     |      \n",
      "     |      When `df` independent random variables, each with standard normal\n",
      "     |      distributions (mean 0, variance 1), are squared and summed, the\n",
      "     |      resulting distribution is chi-square (see Notes).  This distribution\n",
      "     |      is often used in hypothesis testing.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      df : float or array_like of floats\n",
      "     |           Number of degrees of freedom, must be > 0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``df`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(df).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized chi-square distribution.\n",
      "     |      \n",
      "     |      Raises\n",
      "     |      ------\n",
      "     |      ValueError\n",
      "     |          When `df` <= 0 or when an inappropriate `size` (e.g. ``size=-1``)\n",
      "     |          is given.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The variable obtained by summing the squares of `df` independent,\n",
      "     |      standard normally distributed random variables:\n",
      "     |      \n",
      "     |      .. math:: Q = \\sum_{i=0}^{\\mathtt{df}} X^2_i\n",
      "     |      \n",
      "     |      is chi-square distributed, denoted\n",
      "     |      \n",
      "     |      .. math:: Q \\sim \\chi^2_k.\n",
      "     |      \n",
      "     |      The probability density function of the chi-squared distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{(1/2)^{k/2}}{\\Gamma(k/2)}\n",
      "     |                       x^{k/2 - 1} e^{-x/2},\n",
      "     |      \n",
      "     |      where :math:`\\Gamma` is the gamma function,\n",
      "     |      \n",
      "     |      .. math:: \\Gamma(x) = \\int_0^{-\\infty} t^{x - 1} e^{-t} dt.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] NIST \"Engineering Statistics Handbook\"\n",
      "     |             https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> np.random.default_rng().chisquare(2,4)\n",
      "     |      array([ 1.89920014,  9.00867716,  3.13710533,  5.62318272]) # random\n",
      "     |  \n",
      "     |  choice(...)\n",
      "     |      choice(a, size=None, replace=True, p=None, axis=0, shuffle=True)\n",
      "     |      \n",
      "     |      Generates a random sample from a given 1-D array\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : {array_like, int}\n",
      "     |          If an ndarray, a random sample is generated from its elements.\n",
      "     |          If an int, the random sample is generated from np.arange(a).\n",
      "     |      size : {int, tuple[int]}, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn from the 1-d `a`. If `a` has more\n",
      "     |          than one dimension, the `size` shape will be inserted into the\n",
      "     |          `axis` dimension, so the output ``ndim`` will be ``a.ndim - 1 +\n",
      "     |          len(size)``. Default is None, in which case a single value is\n",
      "     |          returned.\n",
      "     |      replace : bool, optional\n",
      "     |          Whether the sample is with or without replacement\n",
      "     |      p : 1-D array_like, optional\n",
      "     |          The probabilities associated with each entry in a.\n",
      "     |          If not given the sample assumes a uniform distribution over all\n",
      "     |          entries in a.\n",
      "     |      axis : int, optional\n",
      "     |          The axis along which the selection is performed. The default, 0,\n",
      "     |          selects by row.\n",
      "     |      shuffle : bool, optional\n",
      "     |          Whether the sample is shuffled when sampling without replacement.\n",
      "     |          Default is True, False provides a speedup.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      samples : single item or ndarray\n",
      "     |          The generated random samples\n",
      "     |      \n",
      "     |      Raises\n",
      "     |      ------\n",
      "     |      ValueError\n",
      "     |          If a is an int and less than zero, if p is not 1-dimensional, if\n",
      "     |          a is array-like with a size 0, if p is not a vector of\n",
      "     |          probabilities, if a and p have different lengths, or if\n",
      "     |          replace=False and the sample size is greater than the population\n",
      "     |          size.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      integers, shuffle, permutation\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Generate a uniform random sample from np.arange(5) of size 3:\n",
      "     |      \n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> rng.choice(5, 3)\n",
      "     |      array([0, 3, 4]) # random\n",
      "     |      >>> #This is equivalent to rng.integers(0,5,3)\n",
      "     |      \n",
      "     |      Generate a non-uniform random sample from np.arange(5) of size 3:\n",
      "     |      \n",
      "     |      >>> rng.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])\n",
      "     |      array([3, 3, 0]) # random\n",
      "     |      \n",
      "     |      Generate a uniform random sample from np.arange(5) of size 3 without\n",
      "     |      replacement:\n",
      "     |      \n",
      "     |      >>> rng.choice(5, 3, replace=False)\n",
      "     |      array([3,1,0]) # random\n",
      "     |      >>> #This is equivalent to rng.permutation(np.arange(5))[:3]\n",
      "     |      \n",
      "     |      Generate a non-uniform random sample from np.arange(5) of size\n",
      "     |      3 without replacement:\n",
      "     |      \n",
      "     |      >>> rng.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])\n",
      "     |      array([2, 3, 0]) # random\n",
      "     |      \n",
      "     |      Any of the above can be repeated with an arbitrary array-like\n",
      "     |      instead of just integers. For instance:\n",
      "     |      \n",
      "     |      >>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']\n",
      "     |      >>> rng.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])\n",
      "     |      array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], # random\n",
      "     |            dtype='<U11')\n",
      "     |  \n",
      "     |  dirichlet(...)\n",
      "     |      dirichlet(alpha, size=None)\n",
      "     |      \n",
      "     |      Draw samples from the Dirichlet distribution.\n",
      "     |      \n",
      "     |      Draw `size` samples of dimension k from a Dirichlet distribution. A\n",
      "     |      Dirichlet-distributed random variable can be seen as a multivariate\n",
      "     |      generalization of a Beta distribution. The Dirichlet distribution\n",
      "     |      is a conjugate prior of a multinomial distribution in Bayesian\n",
      "     |      inference.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      alpha : sequence of floats, length k\n",
      "     |          Parameter of the distribution (length ``k`` for sample of\n",
      "     |          length ``k``).\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          vector of length ``k`` is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      samples : ndarray,\n",
      "     |          The drawn samples, of shape ``(size, k)``.\n",
      "     |      \n",
      "     |      Raises\n",
      "     |      -------\n",
      "     |      ValueError\n",
      "     |          If any value in ``alpha`` is less than or equal to zero\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The Dirichlet distribution is a distribution over vectors\n",
      "     |      :math:`x` that fulfil the conditions :math:`x_i>0` and\n",
      "     |      :math:`\\sum_{i=1}^k x_i = 1`.\n",
      "     |      \n",
      "     |      The probability density function :math:`p` of a\n",
      "     |      Dirichlet-distributed random vector :math:`X` is\n",
      "     |      proportional to\n",
      "     |      \n",
      "     |      .. math:: p(x) \\propto \\prod_{i=1}^{k}{x^{\\alpha_i-1}_i},\n",
      "     |      \n",
      "     |      where :math:`\\alpha` is a vector containing the positive\n",
      "     |      concentration parameters.\n",
      "     |      \n",
      "     |      The method uses the following property for computation: let :math:`Y`\n",
      "     |      be a random vector which has components that follow a standard gamma\n",
      "     |      distribution, then :math:`X = \\frac{1}{\\sum_{i=1}^k{Y_i}} Y`\n",
      "     |      is Dirichlet-distributed\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] David McKay, \"Information Theory, Inference and Learning\n",
      "     |             Algorithms,\" chapter 23,\n",
      "     |             http://www.inference.org.uk/mackay/itila/\n",
      "     |      .. [2] Wikipedia, \"Dirichlet distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Dirichlet_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Taking an example cited in Wikipedia, this distribution can be used if\n",
      "     |      one wanted to cut strings (each of initial length 1.0) into K pieces\n",
      "     |      with different lengths, where each piece had, on average, a designated\n",
      "     |      average length, but allowing some variation in the relative sizes of\n",
      "     |      the pieces.\n",
      "     |      \n",
      "     |      >>> s = np.random.default_rng().dirichlet((10, 5, 3), 20).transpose()\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> plt.barh(range(20), s[0])\n",
      "     |      >>> plt.barh(range(20), s[1], left=s[0], color='g')\n",
      "     |      >>> plt.barh(range(20), s[2], left=s[0]+s[1], color='r')\n",
      "     |      >>> plt.title(\"Lengths of Strings\")\n",
      "     |  \n",
      "     |  exponential(...)\n",
      "     |      exponential(scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from an exponential distribution.\n",
      "     |      \n",
      "     |      Its probability density function is\n",
      "     |      \n",
      "     |      .. math:: f(x; \\frac{1}{\\beta}) = \\frac{1}{\\beta} \\exp(-\\frac{x}{\\beta}),\n",
      "     |      \n",
      "     |      for ``x > 0`` and 0 elsewhere. :math:`\\beta` is the scale parameter,\n",
      "     |      which is the inverse of the rate parameter :math:`\\lambda = 1/\\beta`.\n",
      "     |      The rate parameter is an alternative, widely used parameterization\n",
      "     |      of the exponential distribution [3]_.\n",
      "     |      \n",
      "     |      The exponential distribution is a continuous analogue of the\n",
      "     |      geometric distribution.  It describes many common situations, such as\n",
      "     |      the size of raindrops measured over many rainstorms [1]_, or the time\n",
      "     |      between page requests to Wikipedia [2]_.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      scale : float or array_like of floats\n",
      "     |          The scale parameter, :math:`\\beta = 1/\\lambda`. Must be\n",
      "     |          non-negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``scale`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized exponential distribution.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Peyton Z. Peebles Jr., \"Probability, Random Variables and\n",
      "     |             Random Signal Principles\", 4th ed, 2001, p. 57.\n",
      "     |      .. [2] Wikipedia, \"Poisson process\",\n",
      "     |             https://en.wikipedia.org/wiki/Poisson_process\n",
      "     |      .. [3] Wikipedia, \"Exponential distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Exponential_distribution\n",
      "     |  \n",
      "     |  f(...)\n",
      "     |      f(dfnum, dfden, size=None)\n",
      "     |      \n",
      "     |      Draw samples from an F distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from an F distribution with specified parameters,\n",
      "     |      `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n",
      "     |      freedom in denominator), where both parameters must be greater than\n",
      "     |      zero.\n",
      "     |      \n",
      "     |      The random variate of the F distribution (also known as the\n",
      "     |      Fisher distribution) is a continuous probability distribution\n",
      "     |      that arises in ANOVA tests, and is the ratio of two chi-square\n",
      "     |      variates.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      dfnum : float or array_like of floats\n",
      "     |          Degrees of freedom in numerator, must be > 0.\n",
      "     |      dfden : float or array_like of float\n",
      "     |          Degrees of freedom in denominator, must be > 0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``dfnum`` and ``dfden`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(dfnum, dfden).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Fisher distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.f : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The F statistic is used to compare in-group variances to between-group\n",
      "     |      variances. Calculating the distribution depends on the sampling, and\n",
      "     |      so it is a function of the respective degrees of freedom in the\n",
      "     |      problem.  The variable `dfnum` is the number of samples minus one, the\n",
      "     |      between-groups degrees of freedom, while `dfden` is the within-groups\n",
      "     |      degrees of freedom, the sum of the number of samples in each group\n",
      "     |      minus the number of groups.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n",
      "     |             Fifth Edition, 2002.\n",
      "     |      .. [2] Wikipedia, \"F-distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/F-distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      An example from Glantz[1], pp 47-40:\n",
      "     |      \n",
      "     |      Two groups, children of diabetics (25 people) and children from people\n",
      "     |      without diabetes (25 controls). Fasting blood glucose was measured,\n",
      "     |      case group had a mean value of 86.1, controls had a mean value of\n",
      "     |      82.2. Standard deviations were 2.09 and 2.49 respectively. Are these\n",
      "     |      data consistent with the null hypothesis that the parents diabetic\n",
      "     |      status does not affect their children's blood glucose levels?\n",
      "     |      Calculating the F statistic from the data gives a value of 36.01.\n",
      "     |      \n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> dfnum = 1. # between group degrees of freedom\n",
      "     |      >>> dfden = 48. # within groups degrees of freedom\n",
      "     |      >>> s = np.random.default_rng().f(dfnum, dfden, 1000)\n",
      "     |      \n",
      "     |      The lower bound for the top 1% of the samples is :\n",
      "     |      \n",
      "     |      >>> np.sort(s)[-10]\n",
      "     |      7.61988120985 # random\n",
      "     |      \n",
      "     |      So there is about a 1% chance that the F statistic will exceed 7.62,\n",
      "     |      the measured value is 36, so the null hypothesis is rejected at the 1%\n",
      "     |      level.\n",
      "     |  \n",
      "     |  gamma(...)\n",
      "     |      gamma(shape, scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Gamma distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a Gamma distribution with specified parameters,\n",
      "     |      `shape` (sometimes designated \"k\") and `scale` (sometimes designated\n",
      "     |      \"theta\"), where both parameters are > 0.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      shape : float or array_like of floats\n",
      "     |          The shape of the gamma distribution. Must be non-negative.\n",
      "     |      scale : float or array_like of floats, optional\n",
      "     |          The scale of the gamma distribution. Must be non-negative.\n",
      "     |          Default is equal to 1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``shape`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(shape, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized gamma distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.gamma : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Gamma distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n",
      "     |      \n",
      "     |      where :math:`k` is the shape and :math:`\\theta` the scale,\n",
      "     |      and :math:`\\Gamma` is the Gamma function.\n",
      "     |      \n",
      "     |      The Gamma distribution is often used to model the times to failure of\n",
      "     |      electronic components, and arises naturally in processes for which the\n",
      "     |      waiting times between Poisson distributed events are relevant.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n",
      "     |             Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/GammaDistribution.html\n",
      "     |      .. [2] Wikipedia, \"Gamma distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Gamma_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> shape, scale = 2., 2.  # mean=4, std=2*sqrt(2)\n",
      "     |      >>> s = np.random.default_rng().gamma(shape, scale, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> import scipy.special as sps  # doctest: +SKIP\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 50, density=True)\n",
      "     |      >>> y = bins**(shape-1)*(np.exp(-bins/scale) /  # doctest: +SKIP\n",
      "     |      ...                      (sps.gamma(shape)*scale**shape))\n",
      "     |      >>> plt.plot(bins, y, linewidth=2, color='r')  # doctest: +SKIP\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  geometric(...)\n",
      "     |      geometric(p, size=None)\n",
      "     |      \n",
      "     |      Draw samples from the geometric distribution.\n",
      "     |      \n",
      "     |      Bernoulli trials are experiments with one of two outcomes:\n",
      "     |      success or failure (an example of such an experiment is flipping\n",
      "     |      a coin).  The geometric distribution models the number of trials\n",
      "     |      that must be run in order to achieve success.  It is therefore\n",
      "     |      supported on the positive integers, ``k = 1, 2, ...``.\n",
      "     |      \n",
      "     |      The probability mass function of the geometric distribution is\n",
      "     |      \n",
      "     |      .. math:: f(k) = (1 - p)^{k - 1} p\n",
      "     |      \n",
      "     |      where `p` is the probability of success of an individual trial.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      p : float or array_like of floats\n",
      "     |          The probability of success of an individual trial.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``p`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(p).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized geometric distribution.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw ten thousand values from the geometric distribution,\n",
      "     |      with the probability of an individual success equal to 0.35:\n",
      "     |      \n",
      "     |      >>> z = np.random.default_rng().geometric(p=0.35, size=10000)\n",
      "     |      \n",
      "     |      How many trials succeeded after a single run?\n",
      "     |      \n",
      "     |      >>> (z == 1).sum() / 10000.\n",
      "     |      0.34889999999999999 #random\n",
      "     |  \n",
      "     |  gumbel(...)\n",
      "     |      gumbel(loc=0.0, scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Gumbel distribution.\n",
      "     |      \n",
      "     |      Draw samples from a Gumbel distribution with specified location and\n",
      "     |      scale.  For more information on the Gumbel distribution, see\n",
      "     |      Notes and References below.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      loc : float or array_like of floats, optional\n",
      "     |          The location of the mode of the distribution. Default is 0.\n",
      "     |      scale : float or array_like of floats, optional\n",
      "     |          The scale parameter of the distribution. Default is 1. Must be non-\n",
      "     |          negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Gumbel distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.gumbel_l\n",
      "     |      scipy.stats.gumbel_r\n",
      "     |      scipy.stats.genextreme\n",
      "     |      weibull\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The Gumbel (or Smallest Extreme Value (SEV) or the Smallest Extreme\n",
      "     |      Value Type I) distribution is one of a class of Generalized Extreme\n",
      "     |      Value (GEV) distributions used in modeling extreme value problems.\n",
      "     |      The Gumbel is a special case of the Extreme Value Type I distribution\n",
      "     |      for maximums from distributions with \"exponential-like\" tails.\n",
      "     |      \n",
      "     |      The probability density for the Gumbel distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{e^{-(x - \\mu)/ \\beta}}{\\beta} e^{ -e^{-(x - \\mu)/\n",
      "     |                \\beta}},\n",
      "     |      \n",
      "     |      where :math:`\\mu` is the mode, a location parameter, and\n",
      "     |      :math:`\\beta` is the scale parameter.\n",
      "     |      \n",
      "     |      The Gumbel (named for German mathematician Emil Julius Gumbel) was used\n",
      "     |      very early in the hydrology literature, for modeling the occurrence of\n",
      "     |      flood events. It is also used for modeling maximum wind speed and\n",
      "     |      rainfall rates.  It is a \"fat-tailed\" distribution - the probability of\n",
      "     |      an event in the tail of the distribution is larger than if one used a\n",
      "     |      Gaussian, hence the surprisingly frequent occurrence of 100-year\n",
      "     |      floods. Floods were initially modeled as a Gaussian process, which\n",
      "     |      underestimated the frequency of extreme events.\n",
      "     |      \n",
      "     |      It is one of a class of extreme value distributions, the Generalized\n",
      "     |      Extreme Value (GEV) distributions, which also includes the Weibull and\n",
      "     |      Frechet.\n",
      "     |      \n",
      "     |      The function has a mean of :math:`\\mu + 0.57721\\beta` and a variance\n",
      "     |      of :math:`\\frac{\\pi^2}{6}\\beta^2`.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Gumbel, E. J., \"Statistics of Extremes,\"\n",
      "     |             New York: Columbia University Press, 1958.\n",
      "     |      .. [2] Reiss, R.-D. and Thomas, M., \"Statistical Analysis of Extreme\n",
      "     |             Values from Insurance, Finance, Hydrology and Other Fields,\"\n",
      "     |             Basel: Birkhauser Verlag, 2001.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> mu, beta = 0, 0.1 # location and scale\n",
      "     |      >>> s = rng.gumbel(mu, beta, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 30, density=True)\n",
      "     |      >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n",
      "     |      ...          * np.exp( -np.exp( -(bins - mu) /beta) ),\n",
      "     |      ...          linewidth=2, color='r')\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Show how an extreme value distribution can arise from a Gaussian process\n",
      "     |      and compare to a Gaussian:\n",
      "     |      \n",
      "     |      >>> means = []\n",
      "     |      >>> maxima = []\n",
      "     |      >>> for i in range(0,1000) :\n",
      "     |      ...    a = rng.normal(mu, beta, 1000)\n",
      "     |      ...    means.append(a.mean())\n",
      "     |      ...    maxima.append(a.max())\n",
      "     |      >>> count, bins, ignored = plt.hist(maxima, 30, density=True)\n",
      "     |      >>> beta = np.std(maxima) * np.sqrt(6) / np.pi\n",
      "     |      >>> mu = np.mean(maxima) - 0.57721*beta\n",
      "     |      >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n",
      "     |      ...          * np.exp(-np.exp(-(bins - mu)/beta)),\n",
      "     |      ...          linewidth=2, color='r')\n",
      "     |      >>> plt.plot(bins, 1/(beta * np.sqrt(2 * np.pi))\n",
      "     |      ...          * np.exp(-(bins - mu)**2 / (2 * beta**2)),\n",
      "     |      ...          linewidth=2, color='g')\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  hypergeometric(...)\n",
      "     |      hypergeometric(ngood, nbad, nsample, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Hypergeometric distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a hypergeometric distribution with specified\n",
      "     |      parameters, `ngood` (ways to make a good selection), `nbad` (ways to make\n",
      "     |      a bad selection), and `nsample` (number of items sampled, which is less\n",
      "     |      than or equal to the sum ``ngood + nbad``).\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      ngood : int or array_like of ints\n",
      "     |          Number of ways to make a good selection.  Must be nonnegative and\n",
      "     |          less than 10**9.\n",
      "     |      nbad : int or array_like of ints\n",
      "     |          Number of ways to make a bad selection.  Must be nonnegative and\n",
      "     |          less than 10**9.\n",
      "     |      nsample : int or array_like of ints\n",
      "     |          Number of items sampled.  Must be nonnegative and less than\n",
      "     |          ``ngood + nbad``.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if `ngood`, `nbad`, and `nsample`\n",
      "     |          are all scalars.  Otherwise, ``np.broadcast(ngood, nbad, nsample).size``\n",
      "     |          samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized hypergeometric distribution. Each\n",
      "     |          sample is the number of good items within a randomly selected subset of\n",
      "     |          size `nsample` taken from a set of `ngood` good items and `nbad` bad items.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      multivariate_hypergeometric : Draw samples from the multivariate\n",
      "     |          hypergeometric distribution.\n",
      "     |      scipy.stats.hypergeom : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Hypergeometric distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x) = \\frac{\\binom{g}{x}\\binom{b}{n-x}}{\\binom{g+b}{n}},\n",
      "     |      \n",
      "     |      where :math:`0 \\le x \\le n` and :math:`n-b \\le x \\le g`\n",
      "     |      \n",
      "     |      for P(x) the probability of ``x`` good results in the drawn sample,\n",
      "     |      g = `ngood`, b = `nbad`, and n = `nsample`.\n",
      "     |      \n",
      "     |      Consider an urn with black and white marbles in it, `ngood` of them\n",
      "     |      are black and `nbad` are white. If you draw `nsample` balls without\n",
      "     |      replacement, then the hypergeometric distribution describes the\n",
      "     |      distribution of black balls in the drawn sample.\n",
      "     |      \n",
      "     |      Note that this distribution is very similar to the binomial\n",
      "     |      distribution, except that in this case, samples are drawn without\n",
      "     |      replacement, whereas in the Binomial case samples are drawn with\n",
      "     |      replacement (or the sample space is infinite). As the sample space\n",
      "     |      becomes large, this distribution approaches the binomial.\n",
      "     |      \n",
      "     |      The arguments `ngood` and `nbad` each must be less than `10**9`. For\n",
      "     |      extremely large arguments, the algorithm that is used to compute the\n",
      "     |      samples [4]_ breaks down because of loss of precision in floating point\n",
      "     |      calculations.  For such large values, if `nsample` is not also large,\n",
      "     |      the distribution can be approximated with the binomial distribution,\n",
      "     |      `binomial(n=nsample, p=ngood/(ngood + nbad))`.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n",
      "     |             and Quigley, 1972.\n",
      "     |      .. [2] Weisstein, Eric W. \"Hypergeometric Distribution.\" From\n",
      "     |             MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/HypergeometricDistribution.html\n",
      "     |      .. [3] Wikipedia, \"Hypergeometric distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Hypergeometric_distribution\n",
      "     |      .. [4] Stadlober, Ernst, \"The ratio of uniforms approach for generating\n",
      "     |             discrete random variates\", Journal of Computational and Applied\n",
      "     |             Mathematics, 31, pp. 181-189 (1990).\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> ngood, nbad, nsamp = 100, 2, 10\n",
      "     |      # number of good, number of bad, and number of samples\n",
      "     |      >>> s = rng.hypergeometric(ngood, nbad, nsamp, 1000)\n",
      "     |      >>> from matplotlib.pyplot import hist\n",
      "     |      >>> hist(s)\n",
      "     |      #   note that it is very unlikely to grab both bad items\n",
      "     |      \n",
      "     |      Suppose you have an urn with 15 white and 15 black marbles.\n",
      "     |      If you pull 15 marbles at random, how likely is it that\n",
      "     |      12 or more of them are one color?\n",
      "     |      \n",
      "     |      >>> s = rng.hypergeometric(15, 15, 15, 100000)\n",
      "     |      >>> sum(s>=12)/100000. + sum(s<=3)/100000.\n",
      "     |      #   answer = 0.003 ... pretty unlikely!\n",
      "     |  \n",
      "     |  integers(...)\n",
      "     |      integers(low, high=None, size=None, dtype=np.int64, endpoint=False)\n",
      "     |      \n",
      "     |      Return random integers from `low` (inclusive) to `high` (exclusive), or\n",
      "     |      if endpoint=True, `low` (inclusive) to `high` (inclusive). Replaces\n",
      "     |      `RandomState.randint` (with endpoint=False) and\n",
      "     |      `RandomState.random_integers` (with endpoint=True)\n",
      "     |      \n",
      "     |      Return random integers from the \"discrete uniform\" distribution of\n",
      "     |      the specified dtype. If `high` is None (the default), then results are\n",
      "     |      from 0 to `low`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      low : int or array-like of ints\n",
      "     |          Lowest (signed) integers to be drawn from the distribution (unless\n",
      "     |          ``high=None``, in which case this parameter is 0 and this value is\n",
      "     |          used for `high`).\n",
      "     |      high : int or array-like of ints, optional\n",
      "     |          If provided, one above the largest (signed) integer to be drawn\n",
      "     |          from the distribution (see above for behavior if ``high=None``).\n",
      "     |          If array-like, must contain integer values\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      dtype : dtype, optional\n",
      "     |          Desired dtype of the result. Byteorder must be native.\n",
      "     |          The default value is np.int64.\n",
      "     |      endpoint : bool, optional\n",
      "     |          If true, sample from the interval [low, high] instead of the\n",
      "     |          default [low, high)\n",
      "     |          Defaults to False\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : int or ndarray of ints\n",
      "     |          `size`-shaped array of random integers from the appropriate\n",
      "     |          distribution, or a single such random int if `size` not provided.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      When using broadcasting with uint64 dtypes, the maximum value (2**64)\n",
      "     |      cannot be represented as a standard integer type. The high array (or\n",
      "     |      low if high is None) must have object dtype, e.g., array([2**64]).\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> rng.integers(2, size=10)\n",
      "     |      array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0])  # random\n",
      "     |      >>> rng.integers(1, size=10)\n",
      "     |      array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n",
      "     |      \n",
      "     |      Generate a 2 x 4 array of ints between 0 and 4, inclusive:\n",
      "     |      \n",
      "     |      >>> rng.integers(5, size=(2, 4))\n",
      "     |      array([[4, 0, 2, 1],\n",
      "     |             [3, 2, 2, 0]])  # random\n",
      "     |      \n",
      "     |      Generate a 1 x 3 array with 3 different upper bounds\n",
      "     |      \n",
      "     |      >>> rng.integers(1, [3, 5, 10])\n",
      "     |      array([2, 2, 9])  # random\n",
      "     |      \n",
      "     |      Generate a 1 by 3 array with 3 different lower bounds\n",
      "     |      \n",
      "     |      >>> rng.integers([1, 5, 7], 10)\n",
      "     |      array([9, 8, 7])  # random\n",
      "     |      \n",
      "     |      Generate a 2 by 4 array using broadcasting with dtype of uint8\n",
      "     |      \n",
      "     |      >>> rng.integers([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)\n",
      "     |      array([[ 8,  6,  9,  7],\n",
      "     |             [ 1, 16,  9, 12]], dtype=uint8)  # random\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Daniel Lemire., \"Fast Random Integer Generation in an Interval\",\n",
      "     |             ACM Transactions on Modeling and Computer Simulation 29 (1), 2019,\n",
      "     |             http://arxiv.org/abs/1805.10941.\n",
      "     |  \n",
      "     |  laplace(...)\n",
      "     |      laplace(loc=0.0, scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from the Laplace or double exponential distribution with\n",
      "     |      specified location (or mean) and scale (decay).\n",
      "     |      \n",
      "     |      The Laplace distribution is similar to the Gaussian/normal distribution,\n",
      "     |      but is sharper at the peak and has fatter tails. It represents the\n",
      "     |      difference between two independent, identically distributed exponential\n",
      "     |      random variables.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      loc : float or array_like of floats, optional\n",
      "     |          The position, :math:`\\mu`, of the distribution peak. Default is 0.\n",
      "     |      scale : float or array_like of floats, optional\n",
      "     |          :math:`\\lambda`, the exponential decay. Default is 1. Must be non-\n",
      "     |          negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Laplace distribution.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      It has the probability density function\n",
      "     |      \n",
      "     |      .. math:: f(x; \\mu, \\lambda) = \\frac{1}{2\\lambda}\n",
      "     |                                     \\exp\\left(-\\frac{|x - \\mu|}{\\lambda}\\right).\n",
      "     |      \n",
      "     |      The first law of Laplace, from 1774, states that the frequency\n",
      "     |      of an error can be expressed as an exponential function of the\n",
      "     |      absolute magnitude of the error, which leads to the Laplace\n",
      "     |      distribution. For many problems in economics and health\n",
      "     |      sciences, this distribution seems to model the data better\n",
      "     |      than the standard Gaussian distribution.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n",
      "     |             Mathematical Functions with Formulas, Graphs, and Mathematical\n",
      "     |             Tables, 9th printing,\" New York: Dover, 1972.\n",
      "     |      .. [2] Kotz, Samuel, et. al. \"The Laplace Distribution and\n",
      "     |             Generalizations, \" Birkhauser, 2001.\n",
      "     |      .. [3] Weisstein, Eric W. \"Laplace Distribution.\"\n",
      "     |             From MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/LaplaceDistribution.html\n",
      "     |      .. [4] Wikipedia, \"Laplace distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Laplace_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution\n",
      "     |      \n",
      "     |      >>> loc, scale = 0., 1.\n",
      "     |      >>> s = np.random.default_rng().laplace(loc, scale, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 30, density=True)\n",
      "     |      >>> x = np.arange(-8., 8., .01)\n",
      "     |      >>> pdf = np.exp(-abs(x-loc)/scale)/(2.*scale)\n",
      "     |      >>> plt.plot(x, pdf)\n",
      "     |      \n",
      "     |      Plot Gaussian for comparison:\n",
      "     |      \n",
      "     |      >>> g = (1/(scale * np.sqrt(2 * np.pi)) *\n",
      "     |      ...      np.exp(-(x - loc)**2 / (2 * scale**2)))\n",
      "     |      >>> plt.plot(x,g)\n",
      "     |  \n",
      "     |  logistic(...)\n",
      "     |      logistic(loc=0.0, scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a logistic distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a logistic distribution with specified\n",
      "     |      parameters, loc (location or mean, also median), and scale (>0).\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      loc : float or array_like of floats, optional\n",
      "     |          Parameter of the distribution. Default is 0.\n",
      "     |      scale : float or array_like of floats, optional\n",
      "     |          Parameter of the distribution. Must be non-negative.\n",
      "     |          Default is 1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized logistic distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.logistic : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Logistic distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x) = P(x) = \\frac{e^{-(x-\\mu)/s}}{s(1+e^{-(x-\\mu)/s})^2},\n",
      "     |      \n",
      "     |      where :math:`\\mu` = location and :math:`s` = scale.\n",
      "     |      \n",
      "     |      The Logistic distribution is used in Extreme Value problems where it\n",
      "     |      can act as a mixture of Gumbel distributions, in Epidemiology, and by\n",
      "     |      the World Chess Federation (FIDE) where it is used in the Elo ranking\n",
      "     |      system, assuming the performance of each player is a logistically\n",
      "     |      distributed random variable.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Reiss, R.-D. and Thomas M. (2001), \"Statistical Analysis of\n",
      "     |             Extreme Values, from Insurance, Finance, Hydrology and Other\n",
      "     |             Fields,\" Birkhauser Verlag, Basel, pp 132-133.\n",
      "     |      .. [2] Weisstein, Eric W. \"Logistic Distribution.\" From\n",
      "     |             MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/LogisticDistribution.html\n",
      "     |      .. [3] Wikipedia, \"Logistic-distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Logistic_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> loc, scale = 10, 1\n",
      "     |      >>> s = np.random.default_rng().logistic(loc, scale, 10000)\n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, bins=50)\n",
      "     |      \n",
      "     |      #   plot against distribution\n",
      "     |      \n",
      "     |      >>> def logist(x, loc, scale):\n",
      "     |      ...     return np.exp((loc-x)/scale)/(scale*(1+np.exp((loc-x)/scale))**2)\n",
      "     |      >>> lgst_val = logist(bins, loc, scale)\n",
      "     |      >>> plt.plot(bins, lgst_val * count.max() / lgst_val.max())\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  lognormal(...)\n",
      "     |      lognormal(mean=0.0, sigma=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a log-normal distribution.\n",
      "     |      \n",
      "     |      Draw samples from a log-normal distribution with specified mean,\n",
      "     |      standard deviation, and array shape.  Note that the mean and standard\n",
      "     |      deviation are not the values for the distribution itself, but of the\n",
      "     |      underlying normal distribution it is derived from.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      mean : float or array_like of floats, optional\n",
      "     |          Mean value of the underlying normal distribution. Default is 0.\n",
      "     |      sigma : float or array_like of floats, optional\n",
      "     |          Standard deviation of the underlying normal distribution. Must be\n",
      "     |          non-negative. Default is 1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``mean`` and ``sigma`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(mean, sigma).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized log-normal distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.lognorm : probability density function, distribution,\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      A variable `x` has a log-normal distribution if `log(x)` is normally\n",
      "     |      distributed.  The probability density function for the log-normal\n",
      "     |      distribution is:\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{1}{\\sigma x \\sqrt{2\\pi}}\n",
      "     |                       e^{(-\\frac{(ln(x)-\\mu)^2}{2\\sigma^2})}\n",
      "     |      \n",
      "     |      where :math:`\\mu` is the mean and :math:`\\sigma` is the standard\n",
      "     |      deviation of the normally distributed logarithm of the variable.\n",
      "     |      A log-normal distribution results if a random variable is the *product*\n",
      "     |      of a large number of independent, identically-distributed variables in\n",
      "     |      the same way that a normal distribution results if the variable is the\n",
      "     |      *sum* of a large number of independent, identically-distributed\n",
      "     |      variables.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Limpert, E., Stahel, W. A., and Abbt, M., \"Log-normal\n",
      "     |             Distributions across the Sciences: Keys and Clues,\"\n",
      "     |             BioScience, Vol. 51, No. 5, May, 2001.\n",
      "     |             https://stat.ethz.ch/~stahel/lognormal/bioscience.pdf\n",
      "     |      .. [2] Reiss, R.D. and Thomas, M., \"Statistical Analysis of Extreme\n",
      "     |             Values,\" Basel: Birkhauser Verlag, 2001, pp. 31-32.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> mu, sigma = 3., 1. # mean and standard deviation\n",
      "     |      >>> s = rng.lognormal(mu, sigma, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 100, density=True, align='mid')\n",
      "     |      \n",
      "     |      >>> x = np.linspace(min(bins), max(bins), 10000)\n",
      "     |      >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n",
      "     |      ...        / (x * sigma * np.sqrt(2 * np.pi)))\n",
      "     |      \n",
      "     |      >>> plt.plot(x, pdf, linewidth=2, color='r')\n",
      "     |      >>> plt.axis('tight')\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Demonstrate that taking the products of random samples from a uniform\n",
      "     |      distribution can be fit well by a log-normal probability density\n",
      "     |      function.\n",
      "     |      \n",
      "     |      >>> # Generate a thousand samples: each is the product of 100 random\n",
      "     |      >>> # values, drawn from a normal distribution.\n",
      "     |      >>> rng = rng\n",
      "     |      >>> b = []\n",
      "     |      >>> for i in range(1000):\n",
      "     |      ...    a = 10. + rng.standard_normal(100)\n",
      "     |      ...    b.append(np.product(a))\n",
      "     |      \n",
      "     |      >>> b = np.array(b) / np.min(b) # scale values to be positive\n",
      "     |      >>> count, bins, ignored = plt.hist(b, 100, density=True, align='mid')\n",
      "     |      >>> sigma = np.std(np.log(b))\n",
      "     |      >>> mu = np.mean(np.log(b))\n",
      "     |      \n",
      "     |      >>> x = np.linspace(min(bins), max(bins), 10000)\n",
      "     |      >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n",
      "     |      ...        / (x * sigma * np.sqrt(2 * np.pi)))\n",
      "     |      \n",
      "     |      >>> plt.plot(x, pdf, color='r', linewidth=2)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  logseries(...)\n",
      "     |      logseries(p, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a logarithmic series distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a log series distribution with specified\n",
      "     |      shape parameter, 0 < ``p`` < 1.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      p : float or array_like of floats\n",
      "     |          Shape parameter for the distribution.  Must be in the range (0, 1).\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``p`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(p).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized logarithmic series distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.logser : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability mass function for the Log Series distribution is\n",
      "     |      \n",
      "     |      .. math:: P(k) = \\frac{-p^k}{k \\ln(1-p)},\n",
      "     |      \n",
      "     |      where p = probability.\n",
      "     |      \n",
      "     |      The log series distribution is frequently used to represent species\n",
      "     |      richness and occurrence, first proposed by Fisher, Corbet, and\n",
      "     |      Williams in 1943 [2].  It may also be used to model the numbers of\n",
      "     |      occupants seen in cars [3].\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Buzas, Martin A.; Culver, Stephen J.,  Understanding regional\n",
      "     |             species diversity through the log series distribution of\n",
      "     |             occurrences: BIODIVERSITY RESEARCH Diversity & Distributions,\n",
      "     |             Volume 5, Number 5, September 1999 , pp. 187-195(9).\n",
      "     |      .. [2] Fisher, R.A,, A.S. Corbet, and C.B. Williams. 1943. The\n",
      "     |             relation between the number of species and the number of\n",
      "     |             individuals in a random sample of an animal population.\n",
      "     |             Journal of Animal Ecology, 12:42-58.\n",
      "     |      .. [3] D. J. Hand, F. Daly, D. Lunn, E. Ostrowski, A Handbook of Small\n",
      "     |             Data Sets, CRC Press, 1994.\n",
      "     |      .. [4] Wikipedia, \"Logarithmic distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Logarithmic_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> a = .6\n",
      "     |      >>> s = np.random.default_rng().logseries(a, 10000)\n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s)\n",
      "     |      \n",
      "     |      #   plot against distribution\n",
      "     |      \n",
      "     |      >>> def logseries(k, p):\n",
      "     |      ...     return -p**k/(k*np.log(1-p))\n",
      "     |      >>> plt.plot(bins, logseries(bins, a) * count.max()/\n",
      "     |      ...          logseries(bins, a).max(), 'r')\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  multinomial(...)\n",
      "     |      multinomial(n, pvals, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a multinomial distribution.\n",
      "     |      \n",
      "     |      The multinomial distribution is a multivariate generalization of the\n",
      "     |      binomial distribution.  Take an experiment with one of ``p``\n",
      "     |      possible outcomes.  An example of such an experiment is throwing a dice,\n",
      "     |      where the outcome can be 1 through 6.  Each sample drawn from the\n",
      "     |      distribution represents `n` such experiments.  Its values,\n",
      "     |      ``X_i = [X_0, X_1, ..., X_p]``, represent the number of times the\n",
      "     |      outcome was ``i``.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      n : int or array-like of ints\n",
      "     |          Number of experiments.\n",
      "     |      pvals : sequence of floats, length p\n",
      "     |          Probabilities of each of the ``p`` different outcomes.  These\n",
      "     |          must sum to 1 (however, the last element is always assumed to\n",
      "     |          account for the remaining probability, as long as\n",
      "     |          ``sum(pvals[:-1]) <= 1)``.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray\n",
      "     |          The drawn samples, of shape *size*, if that was provided.  If not,\n",
      "     |          the shape is ``(N,)``.\n",
      "     |      \n",
      "     |          In other words, each entry ``out[i,j,...,:]`` is an N-dimensional\n",
      "     |          value drawn from the distribution.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Throw a dice 20 times:\n",
      "     |      \n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> rng.multinomial(20, [1/6.]*6, size=1)\n",
      "     |      array([[4, 1, 7, 5, 2, 1]])  # random\n",
      "     |      \n",
      "     |      It landed 4 times on 1, once on 2, etc.\n",
      "     |      \n",
      "     |      Now, throw the dice 20 times, and 20 times again:\n",
      "     |      \n",
      "     |      >>> rng.multinomial(20, [1/6.]*6, size=2)\n",
      "     |      array([[3, 4, 3, 3, 4, 3],\n",
      "     |             [2, 4, 3, 4, 0, 7]])  # random\n",
      "     |      \n",
      "     |      For the first run, we threw 3 times 1, 4 times 2, etc.  For the second,\n",
      "     |      we threw 2 times 1, 4 times 2, etc.\n",
      "     |      \n",
      "     |      Now, do one experiment throwing the dice 10 time, and 10 times again,\n",
      "     |      and another throwing the dice 20 times, and 20 times again:\n",
      "     |      \n",
      "     |      >>> rng.multinomial([[10], [20]], [1/6.]*6, size=(2, 2))\n",
      "     |      array([[[2, 4, 0, 1, 2, 1],\n",
      "     |              [1, 3, 0, 3, 1, 2]],\n",
      "     |             [[1, 4, 4, 4, 4, 3],\n",
      "     |              [3, 3, 2, 5, 5, 2]]])  # random\n",
      "     |      \n",
      "     |      The first array shows the outcomes of throwing the dice 10 times, and\n",
      "     |      the second shows the outcomes from throwing the dice 20 times.\n",
      "     |      \n",
      "     |      A loaded die is more likely to land on number 6:\n",
      "     |      \n",
      "     |      >>> rng.multinomial(100, [1/7.]*5 + [2/7.])\n",
      "     |      array([11, 16, 14, 17, 16, 26])  # random\n",
      "     |      \n",
      "     |      The probability inputs should be normalized. As an implementation\n",
      "     |      detail, the value of the last entry is ignored and assumed to take\n",
      "     |      up any leftover probability mass, but this should not be relied on.\n",
      "     |      A biased coin which has twice as much weight on one side as on the\n",
      "     |      other should be sampled like so:\n",
      "     |      \n",
      "     |      >>> rng.multinomial(100, [1.0 / 3, 2.0 / 3])  # RIGHT\n",
      "     |      array([38, 62])  # random\n",
      "     |      \n",
      "     |      not like:\n",
      "     |      \n",
      "     |      >>> rng.multinomial(100, [1.0, 2.0])  # WRONG\n",
      "     |      Traceback (most recent call last):\n",
      "     |      ValueError: pvals < 0, pvals > 1 or pvals contains NaNs\n",
      "     |  \n",
      "     |  multivariate_hypergeometric(...)\n",
      "     |      multivariate_hypergeometric(colors, nsample, size=None,\n",
      "     |                                  method='marginals')\n",
      "     |      \n",
      "     |      Generate variates from a multivariate hypergeometric distribution.\n",
      "     |      \n",
      "     |      The multivariate hypergeometric distribution is a generalization\n",
      "     |      of the hypergeometric distribution.\n",
      "     |      \n",
      "     |      Choose ``nsample`` items at random without replacement from a\n",
      "     |      collection with ``N`` distinct types.  ``N`` is the length of\n",
      "     |      ``colors``, and the values in ``colors`` are the number of occurrences\n",
      "     |      of that type in the collection.  The total number of items in the\n",
      "     |      collection is ``sum(colors)``.  Each random variate generated by this\n",
      "     |      function is a vector of length ``N`` holding the counts of the\n",
      "     |      different types that occurred in the ``nsample`` items.\n",
      "     |      \n",
      "     |      The name ``colors`` comes from a common description of the\n",
      "     |      distribution: it is the probability distribution of the number of\n",
      "     |      marbles of each color selected without replacement from an urn\n",
      "     |      containing marbles of different colors; ``colors[i]`` is the number\n",
      "     |      of marbles in the urn with color ``i``.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      colors : sequence of integers\n",
      "     |          The number of each type of item in the collection from which\n",
      "     |          a sample is drawn.  The values in ``colors`` must be nonnegative.\n",
      "     |          To avoid loss of precision in the algorithm, ``sum(colors)``\n",
      "     |          must be less than ``10**9`` when `method` is \"marginals\".\n",
      "     |      nsample : int\n",
      "     |          The number of items selected.  ``nsample`` must not be greater\n",
      "     |          than ``sum(colors)``.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          The number of variates to generate, either an integer or a tuple\n",
      "     |          holding the shape of the array of variates.  If the given size is,\n",
      "     |          e.g., ``(k, m)``, then ``k * m`` variates are drawn, where one\n",
      "     |          variate is a vector of length ``len(colors)``, and the return value\n",
      "     |          has shape ``(k, m, len(colors))``.  If `size` is an integer, the\n",
      "     |          output has shape ``(size, len(colors))``.  Default is None, in\n",
      "     |          which case a single variate is returned as an array with shape\n",
      "     |          ``(len(colors),)``.\n",
      "     |      method : string, optional\n",
      "     |          Specify the algorithm that is used to generate the variates.\n",
      "     |          Must be 'count' or 'marginals' (the default).  See the Notes\n",
      "     |          for a description of the methods.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      variates : ndarray\n",
      "     |          Array of variates drawn from the multivariate hypergeometric\n",
      "     |          distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      hypergeometric : Draw samples from the (univariate) hypergeometric\n",
      "     |          distribution.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The two methods do not return the same sequence of variates.\n",
      "     |      \n",
      "     |      The \"count\" algorithm is roughly equivalent to the following numpy\n",
      "     |      code::\n",
      "     |      \n",
      "     |          choices = np.repeat(np.arange(len(colors)), colors)\n",
      "     |          selection = np.random.choice(choices, nsample, replace=False)\n",
      "     |          variate = np.bincount(selection, minlength=len(colors))\n",
      "     |      \n",
      "     |      The \"count\" algorithm uses a temporary array of integers with length\n",
      "     |      ``sum(colors)``.\n",
      "     |      \n",
      "     |      The \"marginals\" algorithm generates a variate by using repeated\n",
      "     |      calls to the univariate hypergeometric sampler.  It is roughly\n",
      "     |      equivalent to::\n",
      "     |      \n",
      "     |          variate = np.zeros(len(colors), dtype=np.int64)\n",
      "     |          # `remaining` is the cumulative sum of `colors` from the last\n",
      "     |          # element to the first; e.g. if `colors` is [3, 1, 5], then\n",
      "     |          # `remaining` is [9, 6, 5].\n",
      "     |          remaining = np.cumsum(colors[::-1])[::-1]\n",
      "     |          for i in range(len(colors)-1):\n",
      "     |              if nsample < 1:\n",
      "     |                  break\n",
      "     |              variate[i] = hypergeometric(colors[i], remaining[i+1],\n",
      "     |                                         nsample)\n",
      "     |              nsample -= variate[i]\n",
      "     |          variate[-1] = nsample\n",
      "     |      \n",
      "     |      The default method is \"marginals\".  For some cases (e.g. when\n",
      "     |      `colors` contains relatively small integers), the \"count\" method\n",
      "     |      can be significantly faster than the \"marginals\" method.  If\n",
      "     |      performance of the algorithm is important, test the two methods\n",
      "     |      with typical inputs to decide which works best.\n",
      "     |      \n",
      "     |      .. versionadded:: 1.18.0\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> colors = [16, 8, 4]\n",
      "     |      >>> seed = 4861946401452\n",
      "     |      >>> gen = np.random.Generator(np.random.PCG64(seed))\n",
      "     |      >>> gen.multivariate_hypergeometric(colors, 6)\n",
      "     |      array([5, 0, 1])\n",
      "     |      >>> gen.multivariate_hypergeometric(colors, 6, size=3)\n",
      "     |      array([[5, 0, 1],\n",
      "     |             [2, 2, 2],\n",
      "     |             [3, 3, 0]])\n",
      "     |      >>> gen.multivariate_hypergeometric(colors, 6, size=(2, 2))\n",
      "     |      array([[[3, 2, 1],\n",
      "     |              [3, 2, 1]],\n",
      "     |             [[4, 1, 1],\n",
      "     |              [3, 2, 1]]])\n",
      "     |  \n",
      "     |  multivariate_normal(...)\n",
      "     |      multivariate_normal(mean, cov, size=None, check_valid='warn', tol=1e-8)\n",
      "     |      \n",
      "     |      Draw random samples from a multivariate normal distribution.\n",
      "     |      \n",
      "     |      The multivariate normal, multinormal or Gaussian distribution is a\n",
      "     |      generalization of the one-dimensional normal distribution to higher\n",
      "     |      dimensions.  Such a distribution is specified by its mean and\n",
      "     |      covariance matrix.  These parameters are analogous to the mean\n",
      "     |      (average or \"center\") and variance (standard deviation, or \"width,\"\n",
      "     |      squared) of the one-dimensional normal distribution.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      mean : 1-D array_like, of length N\n",
      "     |          Mean of the N-dimensional distribution.\n",
      "     |      cov : 2-D array_like, of shape (N, N)\n",
      "     |          Covariance matrix of the distribution. It must be symmetric and\n",
      "     |          positive-semidefinite for proper sampling.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Given a shape of, for example, ``(m,n,k)``, ``m*n*k`` samples are\n",
      "     |          generated, and packed in an `m`-by-`n`-by-`k` arrangement.  Because\n",
      "     |          each sample is `N`-dimensional, the output shape is ``(m,n,k,N)``.\n",
      "     |          If no shape is specified, a single (`N`-D) sample is returned.\n",
      "     |      check_valid : { 'warn', 'raise', 'ignore' }, optional\n",
      "     |          Behavior when the covariance matrix is not positive semidefinite.\n",
      "     |      tol : float, optional\n",
      "     |          Tolerance when checking the singular values in covariance matrix.\n",
      "     |          cov is cast to double before the check.\n",
      "     |      method : { 'svd', 'eigh', 'cholesky'}, optional\n",
      "     |          The cov input is used to compute a factor matrix A such that\n",
      "     |          ``A @ A.T = cov``. This argument is used to select the method\n",
      "     |          used to compute the factor matrix A. The default method 'svd' is\n",
      "     |          the slowest, while 'cholesky' is the fastest but less robust than\n",
      "     |          the slowest method. The method `eigh` uses eigen decomposition to\n",
      "     |          compute A and is faster than svd but slower than cholesky.\n",
      "     |      \n",
      "     |          .. versionadded:: 1.18.0\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray\n",
      "     |          The drawn samples, of shape *size*, if that was provided.  If not,\n",
      "     |          the shape is ``(N,)``.\n",
      "     |      \n",
      "     |          In other words, each entry ``out[i,j,...,:]`` is an N-dimensional\n",
      "     |          value drawn from the distribution.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The mean is a coordinate in N-dimensional space, which represents the\n",
      "     |      location where samples are most likely to be generated.  This is\n",
      "     |      analogous to the peak of the bell curve for the one-dimensional or\n",
      "     |      univariate normal distribution.\n",
      "     |      \n",
      "     |      Covariance indicates the level to which two variables vary together.\n",
      "     |      From the multivariate normal distribution, we draw N-dimensional\n",
      "     |      samples, :math:`X = [x_1, x_2, ... x_N]`.  The covariance matrix\n",
      "     |      element :math:`C_{ij}` is the covariance of :math:`x_i` and :math:`x_j`.\n",
      "     |      The element :math:`C_{ii}` is the variance of :math:`x_i` (i.e. its\n",
      "     |      \"spread\").\n",
      "     |      \n",
      "     |      Instead of specifying the full covariance matrix, popular\n",
      "     |      approximations include:\n",
      "     |      \n",
      "     |        - Spherical covariance (`cov` is a multiple of the identity matrix)\n",
      "     |        - Diagonal covariance (`cov` has non-negative elements, and only on\n",
      "     |          the diagonal)\n",
      "     |      \n",
      "     |      This geometrical property can be seen in two dimensions by plotting\n",
      "     |      generated data-points:\n",
      "     |      \n",
      "     |      >>> mean = [0, 0]\n",
      "     |      >>> cov = [[1, 0], [0, 100]]  # diagonal covariance\n",
      "     |      \n",
      "     |      Diagonal covariance means that points are oriented along x or y-axis:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> x, y = np.random.default_rng().multivariate_normal(mean, cov, 5000).T\n",
      "     |      >>> plt.plot(x, y, 'x')\n",
      "     |      >>> plt.axis('equal')\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Note that the covariance matrix must be positive semidefinite (a.k.a.\n",
      "     |      nonnegative-definite). Otherwise, the behavior of this method is\n",
      "     |      undefined and backwards compatibility is not guaranteed.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Papoulis, A., \"Probability, Random Variables, and Stochastic\n",
      "     |             Processes,\" 3rd ed., New York: McGraw-Hill, 1991.\n",
      "     |      .. [2] Duda, R. O., Hart, P. E., and Stork, D. G., \"Pattern\n",
      "     |             Classification,\" 2nd ed., New York: Wiley, 2001.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> mean = (1, 2)\n",
      "     |      >>> cov = [[1, 0], [0, 1]]\n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> x = rng.multivariate_normal(mean, cov, (3, 3))\n",
      "     |      >>> x.shape\n",
      "     |      (3, 3, 2)\n",
      "     |      \n",
      "     |      We can use a different method other than the default to factorize cov:\n",
      "     |      >>> y = rng.multivariate_normal(mean, cov, (3, 3), method='cholesky')\n",
      "     |      >>> y.shape\n",
      "     |      (3, 3, 2)\n",
      "     |      \n",
      "     |      The following is probably true, given that 0.6 is roughly twice the\n",
      "     |      standard deviation:\n",
      "     |      \n",
      "     |      >>> list((x[0,0,:] - mean) < 0.6)\n",
      "     |      [True, True] # random\n",
      "     |  \n",
      "     |  negative_binomial(...)\n",
      "     |      negative_binomial(n, p, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a negative binomial distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a negative binomial distribution with specified\n",
      "     |      parameters, `n` successes and `p` probability of success where `n`\n",
      "     |      is > 0 and `p` is in the interval (0, 1].\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      n : float or array_like of floats\n",
      "     |          Parameter of the distribution, > 0.\n",
      "     |      p : float or array_like of floats\n",
      "     |          Parameter of the distribution. Must satisfy 0 < p <= 1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``n`` and ``p`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized negative binomial distribution,\n",
      "     |          where each sample is equal to N, the number of failures that\n",
      "     |          occurred before a total of n successes was reached.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability mass function of the negative binomial distribution is\n",
      "     |      \n",
      "     |      .. math:: P(N;n,p) = \\frac{\\Gamma(N+n)}{N!\\Gamma(n)}p^{n}(1-p)^{N},\n",
      "     |      \n",
      "     |      where :math:`n` is the number of successes, :math:`p` is the\n",
      "     |      probability of success, :math:`N+n` is the number of trials, and\n",
      "     |      :math:`\\Gamma` is the gamma function. When :math:`n` is an integer,\n",
      "     |      :math:`\\frac{\\Gamma(N+n)}{N!\\Gamma(n)} = \\binom{N+n-1}{N}`, which is\n",
      "     |      the more common form of this term in the the pmf. The negative\n",
      "     |      binomial distribution gives the probability of N failures given n\n",
      "     |      successes, with a success on the last trial.\n",
      "     |      \n",
      "     |      If one throws a die repeatedly until the third time a \"1\" appears,\n",
      "     |      then the probability distribution of the number of non-\"1\"s that\n",
      "     |      appear before the third \"1\" is a negative binomial distribution.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Weisstein, Eric W. \"Negative Binomial Distribution.\" From\n",
      "     |             MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/NegativeBinomialDistribution.html\n",
      "     |      .. [2] Wikipedia, \"Negative binomial distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Negative_binomial_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      A real world example. A company drills wild-cat oil\n",
      "     |      exploration wells, each with an estimated probability of\n",
      "     |      success of 0.1.  What is the probability of having one success\n",
      "     |      for each successive well, that is what is the probability of a\n",
      "     |      single success after drilling 5 wells, after 6 wells, etc.?\n",
      "     |      \n",
      "     |      >>> s = np.random.default_rng().negative_binomial(1, 0.1, 100000)\n",
      "     |      >>> for i in range(1, 11): # doctest: +SKIP\n",
      "     |      ...    probability = sum(s<i) / 100000.\n",
      "     |      ...    print(i, \"wells drilled, probability of one success =\", probability)\n",
      "     |  \n",
      "     |  noncentral_chisquare(...)\n",
      "     |      noncentral_chisquare(df, nonc, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a noncentral chi-square distribution.\n",
      "     |      \n",
      "     |      The noncentral :math:`\\chi^2` distribution is a generalization of\n",
      "     |      the :math:`\\chi^2` distribution.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      df : float or array_like of floats\n",
      "     |          Degrees of freedom, must be > 0.\n",
      "     |      \n",
      "     |          .. versionchanged:: 1.10.0\n",
      "     |             Earlier NumPy versions required dfnum > 1.\n",
      "     |      nonc : float or array_like of floats\n",
      "     |          Non-centrality, must be non-negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``df`` and ``nonc`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(df, nonc).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized noncentral chi-square distribution.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the noncentral Chi-square\n",
      "     |      distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x;df,nonc) = \\sum^{\\infty}_{i=0}\n",
      "     |                             \\frac{e^{-nonc/2}(nonc/2)^{i}}{i!}\n",
      "     |                             P_{Y_{df+2i}}(x),\n",
      "     |      \n",
      "     |      where :math:`Y_{q}` is the Chi-square with q degrees of freedom.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Wikipedia, \"Noncentral chi-squared distribution\"\n",
      "     |             https://en.wikipedia.org/wiki/Noncentral_chi-squared_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw values from the distribution and plot the histogram\n",
      "     |      \n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> values = plt.hist(rng.noncentral_chisquare(3, 20, 100000),\n",
      "     |      ...                   bins=200, density=True)\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Draw values from a noncentral chisquare with very small noncentrality,\n",
      "     |      and compare to a chisquare.\n",
      "     |      \n",
      "     |      >>> plt.figure()\n",
      "     |      >>> values = plt.hist(rng.noncentral_chisquare(3, .0000001, 100000),\n",
      "     |      ...                   bins=np.arange(0., 25, .1), density=True)\n",
      "     |      >>> values2 = plt.hist(rng.chisquare(3, 100000),\n",
      "     |      ...                    bins=np.arange(0., 25, .1), density=True)\n",
      "     |      >>> plt.plot(values[1][0:-1], values[0]-values2[0], 'ob')\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Demonstrate how large values of non-centrality lead to a more symmetric\n",
      "     |      distribution.\n",
      "     |      \n",
      "     |      >>> plt.figure()\n",
      "     |      >>> values = plt.hist(rng.noncentral_chisquare(3, 20, 100000),\n",
      "     |      ...                   bins=200, density=True)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  noncentral_f(...)\n",
      "     |      noncentral_f(dfnum, dfden, nonc, size=None)\n",
      "     |      \n",
      "     |      Draw samples from the noncentral F distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from an F distribution with specified parameters,\n",
      "     |      `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n",
      "     |      freedom in denominator), where both parameters > 1.\n",
      "     |      `nonc` is the non-centrality parameter.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      dfnum : float or array_like of floats\n",
      "     |          Numerator degrees of freedom, must be > 0.\n",
      "     |      \n",
      "     |          .. versionchanged:: 1.14.0\n",
      "     |             Earlier NumPy versions required dfnum > 1.\n",
      "     |      dfden : float or array_like of floats\n",
      "     |          Denominator degrees of freedom, must be > 0.\n",
      "     |      nonc : float or array_like of floats\n",
      "     |          Non-centrality parameter, the sum of the squares of the numerator\n",
      "     |          means, must be >= 0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``dfnum``, ``dfden``, and ``nonc``\n",
      "     |          are all scalars.  Otherwise, ``np.broadcast(dfnum, dfden, nonc).size``\n",
      "     |          samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized noncentral Fisher distribution.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      When calculating the power of an experiment (power = probability of\n",
      "     |      rejecting the null hypothesis when a specific alternative is true) the\n",
      "     |      non-central F statistic becomes important.  When the null hypothesis is\n",
      "     |      true, the F statistic follows a central F distribution. When the null\n",
      "     |      hypothesis is not true, then it follows a non-central F statistic.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Weisstein, Eric W. \"Noncentral F-Distribution.\"\n",
      "     |             From MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/NoncentralF-Distribution.html\n",
      "     |      .. [2] Wikipedia, \"Noncentral F-distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Noncentral_F-distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      In a study, testing for a specific alternative to the null hypothesis\n",
      "     |      requires use of the Noncentral F distribution. We need to calculate the\n",
      "     |      area in the tail of the distribution that exceeds the value of the F\n",
      "     |      distribution for the null hypothesis.  We'll plot the two probability\n",
      "     |      distributions for comparison.\n",
      "     |      \n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> dfnum = 3 # between group deg of freedom\n",
      "     |      >>> dfden = 20 # within groups degrees of freedom\n",
      "     |      >>> nonc = 3.0\n",
      "     |      >>> nc_vals = rng.noncentral_f(dfnum, dfden, nonc, 1000000)\n",
      "     |      >>> NF = np.histogram(nc_vals, bins=50, density=True)\n",
      "     |      >>> c_vals = rng.f(dfnum, dfden, 1000000)\n",
      "     |      >>> F = np.histogram(c_vals, bins=50, density=True)\n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> plt.plot(F[1][1:], F[0])\n",
      "     |      >>> plt.plot(NF[1][1:], NF[0])\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  normal(...)\n",
      "     |      normal(loc=0.0, scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw random samples from a normal (Gaussian) distribution.\n",
      "     |      \n",
      "     |      The probability density function of the normal distribution, first\n",
      "     |      derived by De Moivre and 200 years later by both Gauss and Laplace\n",
      "     |      independently [2]_, is often called the bell curve because of\n",
      "     |      its characteristic shape (see the example below).\n",
      "     |      \n",
      "     |      The normal distributions occurs often in nature.  For example, it\n",
      "     |      describes the commonly occurring distribution of samples influenced\n",
      "     |      by a large number of tiny, random disturbances, each with its own\n",
      "     |      unique distribution [2]_.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      loc : float or array_like of floats\n",
      "     |          Mean (\"centre\") of the distribution.\n",
      "     |      scale : float or array_like of floats\n",
      "     |          Standard deviation (spread or \"width\") of the distribution. Must be\n",
      "     |          non-negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized normal distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.norm : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Gaussian distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{1}{\\sqrt{ 2 \\pi \\sigma^2 }}\n",
      "     |                       e^{ - \\frac{ (x - \\mu)^2 } {2 \\sigma^2} },\n",
      "     |      \n",
      "     |      where :math:`\\mu` is the mean and :math:`\\sigma` the standard\n",
      "     |      deviation. The square of the standard deviation, :math:`\\sigma^2`,\n",
      "     |      is called the variance.\n",
      "     |      \n",
      "     |      The function has its peak at the mean, and its \"spread\" increases with\n",
      "     |      the standard deviation (the function reaches 0.607 times its maximum at\n",
      "     |      :math:`x + \\sigma` and :math:`x - \\sigma` [2]_).  This implies that\n",
      "     |      :meth:`normal` is more likely to return samples lying close to the\n",
      "     |      mean, rather than those far away.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Wikipedia, \"Normal distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Normal_distribution\n",
      "     |      .. [2] P. R. Peebles Jr., \"Central Limit Theorem\" in \"Probability,\n",
      "     |             Random Variables and Random Signal Principles\", 4th ed., 2001,\n",
      "     |             pp. 51, 51, 125.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> mu, sigma = 0, 0.1 # mean and standard deviation\n",
      "     |      >>> s = np.random.default_rng().normal(mu, sigma, 1000)\n",
      "     |      \n",
      "     |      Verify the mean and the variance:\n",
      "     |      \n",
      "     |      >>> abs(mu - np.mean(s))\n",
      "     |      0.0  # may vary\n",
      "     |      \n",
      "     |      >>> abs(sigma - np.std(s, ddof=1))\n",
      "     |      0.1  # may vary\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 30, density=True)\n",
      "     |      >>> plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *\n",
      "     |      ...                np.exp( - (bins - mu)**2 / (2 * sigma**2) ),\n",
      "     |      ...          linewidth=2, color='r')\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Two-by-four array of samples from N(3, 6.25):\n",
      "     |      \n",
      "     |      >>> np.random.default_rng().normal(3, 2.5, size=(2, 4))\n",
      "     |      array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random\n",
      "     |             [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]])  # random\n",
      "     |  \n",
      "     |  pareto(...)\n",
      "     |      pareto(a, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Pareto II or Lomax distribution with\n",
      "     |      specified shape.\n",
      "     |      \n",
      "     |      The Lomax or Pareto II distribution is a shifted Pareto\n",
      "     |      distribution. The classical Pareto distribution can be\n",
      "     |      obtained from the Lomax distribution by adding 1 and\n",
      "     |      multiplying by the scale parameter ``m`` (see Notes).  The\n",
      "     |      smallest value of the Lomax distribution is zero while for the\n",
      "     |      classical Pareto distribution it is ``mu``, where the standard\n",
      "     |      Pareto distribution has location ``mu = 1``.  Lomax can also\n",
      "     |      be considered as a simplified version of the Generalized\n",
      "     |      Pareto distribution (available in SciPy), with the scale set\n",
      "     |      to one and the location set to zero.\n",
      "     |      \n",
      "     |      The Pareto distribution must be greater than zero, and is\n",
      "     |      unbounded above.  It is also known as the \"80-20 rule\".  In\n",
      "     |      this distribution, 80 percent of the weights are in the lowest\n",
      "     |      20 percent of the range, while the other 20 percent fill the\n",
      "     |      remaining 80 percent of the range.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : float or array_like of floats\n",
      "     |          Shape of the distribution. Must be positive.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``a`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(a).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Pareto distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.lomax : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      scipy.stats.genpareto : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Pareto distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{am^a}{x^{a+1}}\n",
      "     |      \n",
      "     |      where :math:`a` is the shape and :math:`m` the scale.\n",
      "     |      \n",
      "     |      The Pareto distribution, named after the Italian economist\n",
      "     |      Vilfredo Pareto, is a power law probability distribution\n",
      "     |      useful in many real world problems.  Outside the field of\n",
      "     |      economics it is generally referred to as the Bradford\n",
      "     |      distribution. Pareto developed the distribution to describe\n",
      "     |      the distribution of wealth in an economy.  It has also found\n",
      "     |      use in insurance, web page access statistics, oil field sizes,\n",
      "     |      and many other problems, including the download frequency for\n",
      "     |      projects in Sourceforge [1]_.  It is one of the so-called\n",
      "     |      \"fat-tailed\" distributions.\n",
      "     |      \n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Francis Hunt and Paul Johnson, On the Pareto Distribution of\n",
      "     |             Sourceforge projects.\n",
      "     |      .. [2] Pareto, V. (1896). Course of Political Economy. Lausanne.\n",
      "     |      .. [3] Reiss, R.D., Thomas, M.(2001), Statistical Analysis of Extreme\n",
      "     |             Values, Birkhauser Verlag, Basel, pp 23-30.\n",
      "     |      .. [4] Wikipedia, \"Pareto distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Pareto_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> a, m = 3., 2.  # shape and mode\n",
      "     |      >>> s = (np.random.default_rng().pareto(a, 1000) + 1) * m\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with the probability\n",
      "     |      density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, _ = plt.hist(s, 100, density=True)\n",
      "     |      >>> fit = a*m**a / bins**(a+1)\n",
      "     |      >>> plt.plot(bins, max(count)*fit/max(fit), linewidth=2, color='r')\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  permutation(...)\n",
      "     |      permutation(x, axis=0)\n",
      "     |      \n",
      "     |      Randomly permute a sequence, or return a permuted range.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      x : int or array_like\n",
      "     |          If `x` is an integer, randomly permute ``np.arange(x)``.\n",
      "     |          If `x` is an array, make a copy and shuffle the elements\n",
      "     |          randomly.\n",
      "     |      axis : int, optional\n",
      "     |          The axis which `x` is shuffled along. Default is 0.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray\n",
      "     |          Permuted sequence or array range.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> rng.permutation(10)\n",
      "     |      array([1, 7, 4, 3, 0, 9, 2, 5, 8, 6]) # random\n",
      "     |      \n",
      "     |      >>> rng.permutation([1, 4, 9, 12, 15])\n",
      "     |      array([15,  1,  9,  4, 12]) # random\n",
      "     |      \n",
      "     |      >>> arr = np.arange(9).reshape((3, 3))\n",
      "     |      >>> rng.permutation(arr)\n",
      "     |      array([[6, 7, 8], # random\n",
      "     |             [0, 1, 2],\n",
      "     |             [3, 4, 5]])\n",
      "     |      \n",
      "     |      >>> rng.permutation(\"abc\")\n",
      "     |      Traceback (most recent call last):\n",
      "     |          ...\n",
      "     |      numpy.AxisError: axis 0 is out of bounds for array of dimension 0\n",
      "     |      \n",
      "     |      >>> arr = np.arange(9).reshape((3, 3))\n",
      "     |      >>> rng.permutation(arr, axis=1)\n",
      "     |      array([[0, 2, 1], # random\n",
      "     |             [3, 5, 4],\n",
      "     |             [6, 8, 7]])\n",
      "     |  \n",
      "     |  poisson(...)\n",
      "     |      poisson(lam=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Poisson distribution.\n",
      "     |      \n",
      "     |      The Poisson distribution is the limit of the binomial distribution\n",
      "     |      for large N.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      lam : float or array_like of floats\n",
      "     |          Expectation of interval, must be >= 0. A sequence of expectation\n",
      "     |          intervals must be broadcastable over the requested size.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``lam`` is a scalar. Otherwise,\n",
      "     |          ``np.array(lam).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Poisson distribution.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The Poisson distribution\n",
      "     |      \n",
      "     |      .. math:: f(k; \\lambda)=\\frac{\\lambda^k e^{-\\lambda}}{k!}\n",
      "     |      \n",
      "     |      For events with an expected separation :math:`\\lambda` the Poisson\n",
      "     |      distribution :math:`f(k; \\lambda)` describes the probability of\n",
      "     |      :math:`k` events occurring within the observed\n",
      "     |      interval :math:`\\lambda`.\n",
      "     |      \n",
      "     |      Because the output is limited to the range of the C int64 type, a\n",
      "     |      ValueError is raised when `lam` is within 10 sigma of the maximum\n",
      "     |      representable value.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Weisstein, Eric W. \"Poisson Distribution.\"\n",
      "     |             From MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/PoissonDistribution.html\n",
      "     |      .. [2] Wikipedia, \"Poisson distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Poisson_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> import numpy as np\n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> s = rng.poisson(5, 10000)\n",
      "     |      \n",
      "     |      Display histogram of the sample:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 14, density=True)\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Draw each 100 values for lambda 100 and 500:\n",
      "     |      \n",
      "     |      >>> s = rng.poisson(lam=(100., 500.), size=(100, 2))\n",
      "     |  \n",
      "     |  power(...)\n",
      "     |      power(a, size=None)\n",
      "     |      \n",
      "     |      Draws samples in [0, 1] from a power distribution with positive\n",
      "     |      exponent a - 1.\n",
      "     |      \n",
      "     |      Also known as the power function distribution.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : float or array_like of floats\n",
      "     |          Parameter of the distribution. Must be non-negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``a`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(a).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized power distribution.\n",
      "     |      \n",
      "     |      Raises\n",
      "     |      ------\n",
      "     |      ValueError\n",
      "     |          If a < 1.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function is\n",
      "     |      \n",
      "     |      .. math:: P(x; a) = ax^{a-1}, 0 \\le x \\le 1, a>0.\n",
      "     |      \n",
      "     |      The power function distribution is just the inverse of the Pareto\n",
      "     |      distribution. It may also be seen as a special case of the Beta\n",
      "     |      distribution.\n",
      "     |      \n",
      "     |      It is used, for example, in modeling the over-reporting of insurance\n",
      "     |      claims.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Christian Kleiber, Samuel Kotz, \"Statistical size distributions\n",
      "     |             in economics and actuarial sciences\", Wiley, 2003.\n",
      "     |      .. [2] Heckert, N. A. and Filliben, James J. \"NIST Handbook 148:\n",
      "     |             Dataplot Reference Manual, Volume 2: Let Subcommands and Library\n",
      "     |             Functions\", National Institute of Standards and Technology\n",
      "     |             Handbook Series, June 2003.\n",
      "     |             https://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/powpdf.pdf\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> a = 5. # shape\n",
      "     |      >>> samples = 1000\n",
      "     |      >>> s = rng.power(a, samples)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, bins=30)\n",
      "     |      >>> x = np.linspace(0, 1, 100)\n",
      "     |      >>> y = a*x**(a-1.)\n",
      "     |      >>> normed_y = samples*np.diff(bins)[0]*y\n",
      "     |      >>> plt.plot(x, normed_y)\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Compare the power function distribution to the inverse of the Pareto.\n",
      "     |      \n",
      "     |      >>> from scipy import stats  # doctest: +SKIP\n",
      "     |      >>> rvs = rng.power(5, 1000000)\n",
      "     |      >>> rvsp = rng.pareto(5, 1000000)\n",
      "     |      >>> xx = np.linspace(0,1,100)\n",
      "     |      >>> powpdf = stats.powerlaw.pdf(xx,5)  # doctest: +SKIP\n",
      "     |      \n",
      "     |      >>> plt.figure()\n",
      "     |      >>> plt.hist(rvs, bins=50, density=True)\n",
      "     |      >>> plt.plot(xx,powpdf,'r-')  # doctest: +SKIP\n",
      "     |      >>> plt.title('power(5)')\n",
      "     |      \n",
      "     |      >>> plt.figure()\n",
      "     |      >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n",
      "     |      >>> plt.plot(xx,powpdf,'r-')  # doctest: +SKIP\n",
      "     |      >>> plt.title('inverse of 1 + Generator.pareto(5)')\n",
      "     |      \n",
      "     |      >>> plt.figure()\n",
      "     |      >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n",
      "     |      >>> plt.plot(xx,powpdf,'r-')  # doctest: +SKIP\n",
      "     |      >>> plt.title('inverse of stats.pareto(5)')\n",
      "     |  \n",
      "     |  random(...)\n",
      "     |      random(size=None, dtype=np.float64, out=None)\n",
      "     |      \n",
      "     |      Return random floats in the half-open interval [0.0, 1.0).\n",
      "     |      \n",
      "     |      Results are from the \"continuous uniform\" distribution over the\n",
      "     |      stated interval.  To sample :math:`Unif[a, b), b > a` multiply\n",
      "     |      the output of `random` by `(b-a)` and add `a`::\n",
      "     |      \n",
      "     |        (b - a) * random() + a\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      dtype : dtype, optional\n",
      "     |          Desired dtype of the result, only `float64` and `float32` are supported.\n",
      "     |          Byteorder must be native. The default value is np.float64.\n",
      "     |      out : ndarray, optional\n",
      "     |          Alternative output array in which to place the result. If size is not None,\n",
      "     |          it must have the same shape as the provided size and must match the type of\n",
      "     |          the output values.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : float or ndarray of floats\n",
      "     |          Array of random floats of shape `size` (unless ``size=None``, in which\n",
      "     |          case a single float is returned).\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> rng.random()\n",
      "     |      0.47108547995356098 # random\n",
      "     |      >>> type(rng.random())\n",
      "     |      <class 'float'>\n",
      "     |      >>> rng.random((5,))\n",
      "     |      array([ 0.30220482,  0.86820401,  0.1654503 ,  0.11659149,  0.54323428]) # random\n",
      "     |      \n",
      "     |      Three-by-two array of random numbers from [-5, 0):\n",
      "     |      \n",
      "     |      >>> 5 * rng.random((3, 2)) - 5\n",
      "     |      array([[-3.99149989, -0.52338984], # random\n",
      "     |             [-2.99091858, -0.79479508],\n",
      "     |             [-1.23204345, -1.75224494]])\n",
      "     |  \n",
      "     |  rayleigh(...)\n",
      "     |      rayleigh(scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Rayleigh distribution.\n",
      "     |      \n",
      "     |      The :math:`\\chi` and Weibull distributions are generalizations of the\n",
      "     |      Rayleigh.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      scale : float or array_like of floats, optional\n",
      "     |          Scale, also equals the mode. Must be non-negative. Default is 1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``scale`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Rayleigh distribution.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the Rayleigh distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x;scale) = \\frac{x}{scale^2}e^{\\frac{-x^2}{2 \\cdotp scale^2}}\n",
      "     |      \n",
      "     |      The Rayleigh distribution would arise, for example, if the East\n",
      "     |      and North components of the wind velocity had identical zero-mean\n",
      "     |      Gaussian distributions.  Then the wind speed would have a Rayleigh\n",
      "     |      distribution.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Brighton Webs Ltd., \"Rayleigh Distribution,\"\n",
      "     |             https://web.archive.org/web/20090514091424/http://brighton-webs.co.uk:80/distributions/rayleigh.asp\n",
      "     |      .. [2] Wikipedia, \"Rayleigh distribution\"\n",
      "     |             https://en.wikipedia.org/wiki/Rayleigh_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw values from the distribution and plot the histogram\n",
      "     |      \n",
      "     |      >>> from matplotlib.pyplot import hist\n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> values = hist(rng.rayleigh(3, 100000), bins=200, density=True)\n",
      "     |      \n",
      "     |      Wave heights tend to follow a Rayleigh distribution. If the mean wave\n",
      "     |      height is 1 meter, what fraction of waves are likely to be larger than 3\n",
      "     |      meters?\n",
      "     |      \n",
      "     |      >>> meanvalue = 1\n",
      "     |      >>> modevalue = np.sqrt(2 / np.pi) * meanvalue\n",
      "     |      >>> s = rng.rayleigh(modevalue, 1000000)\n",
      "     |      \n",
      "     |      The percentage of waves larger than 3 meters is:\n",
      "     |      \n",
      "     |      >>> 100.*sum(s>3)/1000000.\n",
      "     |      0.087300000000000003 # random\n",
      "     |  \n",
      "     |  shuffle(...)\n",
      "     |      shuffle(x, axis=0)\n",
      "     |      \n",
      "     |      Modify a sequence in-place by shuffling its contents.\n",
      "     |      \n",
      "     |      The order of sub-arrays is changed but their contents remains the same.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      x : array_like\n",
      "     |          The array or list to be shuffled.\n",
      "     |      axis : int, optional\n",
      "     |          The axis which `x` is shuffled along. Default is 0.\n",
      "     |          It is only supported on `ndarray` objects.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      None\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> arr = np.arange(10)\n",
      "     |      >>> rng.shuffle(arr)\n",
      "     |      >>> arr\n",
      "     |      [1 7 5 2 9 4 3 6 0 8] # random\n",
      "     |      \n",
      "     |      >>> arr = np.arange(9).reshape((3, 3))\n",
      "     |      >>> rng.shuffle(arr)\n",
      "     |      >>> arr\n",
      "     |      array([[3, 4, 5], # random\n",
      "     |             [6, 7, 8],\n",
      "     |             [0, 1, 2]])\n",
      "     |      \n",
      "     |      >>> arr = np.arange(9).reshape((3, 3))\n",
      "     |      >>> rng.shuffle(arr, axis=1)\n",
      "     |      >>> arr\n",
      "     |      array([[2, 0, 1], # random\n",
      "     |             [5, 3, 4],\n",
      "     |             [8, 6, 7]])\n",
      "     |  \n",
      "     |  standard_cauchy(...)\n",
      "     |      standard_cauchy(size=None)\n",
      "     |      \n",
      "     |      Draw samples from a standard Cauchy distribution with mode = 0.\n",
      "     |      \n",
      "     |      Also known as the Lorentz distribution.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      samples : ndarray or scalar\n",
      "     |          The drawn samples.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the full Cauchy distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x; x_0, \\gamma) = \\frac{1}{\\pi \\gamma \\bigl[ 1+\n",
      "     |                (\\frac{x-x_0}{\\gamma})^2 \\bigr] }\n",
      "     |      \n",
      "     |      and the Standard Cauchy distribution just sets :math:`x_0=0` and\n",
      "     |      :math:`\\gamma=1`\n",
      "     |      \n",
      "     |      The Cauchy distribution arises in the solution to the driven harmonic\n",
      "     |      oscillator problem, and also describes spectral line broadening. It\n",
      "     |      also describes the distribution of values at which a line tilted at\n",
      "     |      a random angle will cut the x axis.\n",
      "     |      \n",
      "     |      When studying hypothesis tests that assume normality, seeing how the\n",
      "     |      tests perform on data from a Cauchy distribution is a good indicator of\n",
      "     |      their sensitivity to a heavy-tailed distribution, since the Cauchy looks\n",
      "     |      very much like a Gaussian distribution, but with heavier tails.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] NIST/SEMATECH e-Handbook of Statistical Methods, \"Cauchy\n",
      "     |            Distribution\",\n",
      "     |            https://www.itl.nist.gov/div898/handbook/eda/section3/eda3663.htm\n",
      "     |      .. [2] Weisstein, Eric W. \"Cauchy Distribution.\" From MathWorld--A\n",
      "     |            Wolfram Web Resource.\n",
      "     |            http://mathworld.wolfram.com/CauchyDistribution.html\n",
      "     |      .. [3] Wikipedia, \"Cauchy distribution\"\n",
      "     |            https://en.wikipedia.org/wiki/Cauchy_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples and plot the distribution:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> s = np.random.default_rng().standard_cauchy(1000000)\n",
      "     |      >>> s = s[(s>-25) & (s<25)]  # truncate distribution so it plots well\n",
      "     |      >>> plt.hist(s, bins=100)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  standard_exponential(...)\n",
      "     |      standard_exponential(size=None, dtype=np.float64, method='zig', out=None)\n",
      "     |      \n",
      "     |      Draw samples from the standard exponential distribution.\n",
      "     |      \n",
      "     |      `standard_exponential` is identical to the exponential distribution\n",
      "     |      with a scale parameter of 1.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      dtype : dtype, optional\n",
      "     |          Desired dtype of the result, only `float64` and `float32` are supported.\n",
      "     |          Byteorder must be native. The default value is np.float64.\n",
      "     |      method : str, optional\n",
      "     |          Either 'inv' or 'zig'. 'inv' uses the default inverse CDF method.\n",
      "     |          'zig' uses the much faster Ziggurat method of Marsaglia and Tsang.\n",
      "     |      out : ndarray, optional\n",
      "     |          Alternative output array in which to place the result. If size is not None,\n",
      "     |          it must have the same shape as the provided size and must match the type of\n",
      "     |          the output values.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : float or ndarray\n",
      "     |          Drawn samples.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Output a 3x8000 array:\n",
      "     |      \n",
      "     |      >>> n = np.random.default_rng().standard_exponential((3, 8000))\n",
      "     |  \n",
      "     |  standard_gamma(...)\n",
      "     |      standard_gamma(shape, size=None, dtype=np.float64, out=None)\n",
      "     |      \n",
      "     |      Draw samples from a standard Gamma distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a Gamma distribution with specified parameters,\n",
      "     |      shape (sometimes designated \"k\") and scale=1.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      shape : float or array_like of floats\n",
      "     |          Parameter, must be non-negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``shape`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(shape).size`` samples are drawn.\n",
      "     |      dtype : dtype, optional\n",
      "     |          Desired dtype of the result, only `float64` and `float32` are supported.\n",
      "     |          Byteorder must be native. The default value is np.float64.\n",
      "     |      out : ndarray, optional\n",
      "     |          Alternative output array in which to place the result. If size is\n",
      "     |          not None, it must have the same shape as the provided size and\n",
      "     |          must match the type of the output values.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized standard gamma distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.gamma : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Gamma distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n",
      "     |      \n",
      "     |      where :math:`k` is the shape and :math:`\\theta` the scale,\n",
      "     |      and :math:`\\Gamma` is the Gamma function.\n",
      "     |      \n",
      "     |      The Gamma distribution is often used to model the times to failure of\n",
      "     |      electronic components, and arises naturally in processes for which the\n",
      "     |      waiting times between Poisson distributed events are relevant.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n",
      "     |             Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/GammaDistribution.html\n",
      "     |      .. [2] Wikipedia, \"Gamma distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Gamma_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> shape, scale = 2., 1. # mean and width\n",
      "     |      >>> s = np.random.default_rng().standard_gamma(shape, 1000000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> import scipy.special as sps  # doctest: +SKIP\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 50, density=True)\n",
      "     |      >>> y = bins**(shape-1) * ((np.exp(-bins/scale))/  # doctest: +SKIP\n",
      "     |      ...                       (sps.gamma(shape) * scale**shape))\n",
      "     |      >>> plt.plot(bins, y, linewidth=2, color='r')  # doctest: +SKIP\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  standard_normal(...)\n",
      "     |      standard_normal(size=None, dtype=np.float64, out=None)\n",
      "     |      \n",
      "     |      Draw samples from a standard Normal distribution (mean=0, stdev=1).\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      dtype : dtype, optional\n",
      "     |          Desired dtype of the result, only `float64` and `float32` are supported.\n",
      "     |          Byteorder must be native. The default value is np.float64.\n",
      "     |      out : ndarray, optional\n",
      "     |          Alternative output array in which to place the result. If size is not None,\n",
      "     |          it must have the same shape as the provided size and must match the type of\n",
      "     |          the output values.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : float or ndarray\n",
      "     |          A floating-point array of shape ``size`` of drawn samples, or a\n",
      "     |          single sample if ``size`` was not specified.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      normal :\n",
      "     |          Equivalent function with additional ``loc`` and ``scale`` arguments\n",
      "     |          for setting the mean and standard deviation.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      For random samples from :math:`N(\\mu, \\sigma^2)`, use one of::\n",
      "     |      \n",
      "     |          mu + sigma * gen.standard_normal(size=...)\n",
      "     |          gen.normal(mu, sigma, size=...)\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> rng.standard_normal()\n",
      "     |      2.1923875335537315 #random\n",
      "     |      \n",
      "     |      >>> s = rng.standard_normal(8000)\n",
      "     |      >>> s\n",
      "     |      array([ 0.6888893 ,  0.78096262, -0.89086505, ...,  0.49876311,  # random\n",
      "     |             -0.38672696, -0.4685006 ])                                # random\n",
      "     |      >>> s.shape\n",
      "     |      (8000,)\n",
      "     |      >>> s = rng.standard_normal(size=(3, 4, 2))\n",
      "     |      >>> s.shape\n",
      "     |      (3, 4, 2)\n",
      "     |      \n",
      "     |      Two-by-four array of samples from :math:`N(3, 6.25)`:\n",
      "     |      \n",
      "     |      >>> 3 + 2.5 * rng.standard_normal(size=(2, 4))\n",
      "     |      array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random\n",
      "     |             [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]])  # random\n",
      "     |  \n",
      "     |  standard_t(...)\n",
      "     |      standard_t(df, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a standard Student's t distribution with `df` degrees\n",
      "     |      of freedom.\n",
      "     |      \n",
      "     |      A special case of the hyperbolic distribution.  As `df` gets\n",
      "     |      large, the result resembles that of the standard normal\n",
      "     |      distribution (`standard_normal`).\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      df : float or array_like of floats\n",
      "     |          Degrees of freedom, must be > 0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``df`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(df).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized standard Student's t distribution.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the t distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x, df) = \\frac{\\Gamma(\\frac{df+1}{2})}{\\sqrt{\\pi df}\n",
      "     |                \\Gamma(\\frac{df}{2})}\\Bigl( 1+\\frac{x^2}{df} \\Bigr)^{-(df+1)/2}\n",
      "     |      \n",
      "     |      The t test is based on an assumption that the data come from a\n",
      "     |      Normal distribution. The t test provides a way to test whether\n",
      "     |      the sample mean (that is the mean calculated from the data) is\n",
      "     |      a good estimate of the true mean.\n",
      "     |      \n",
      "     |      The derivation of the t-distribution was first published in\n",
      "     |      1908 by William Gosset while working for the Guinness Brewery\n",
      "     |      in Dublin. Due to proprietary issues, he had to publish under\n",
      "     |      a pseudonym, and so he used the name Student.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Dalgaard, Peter, \"Introductory Statistics With R\",\n",
      "     |             Springer, 2002.\n",
      "     |      .. [2] Wikipedia, \"Student's t-distribution\"\n",
      "     |             https://en.wikipedia.org/wiki/Student's_t-distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      From Dalgaard page 83 [1]_, suppose the daily energy intake for 11\n",
      "     |      women in kilojoules (kJ) is:\n",
      "     |      \n",
      "     |      >>> intake = np.array([5260., 5470, 5640, 6180, 6390, 6515, 6805, 7515, \\\n",
      "     |      ...                    7515, 8230, 8770])\n",
      "     |      \n",
      "     |      Does their energy intake deviate systematically from the recommended\n",
      "     |      value of 7725 kJ?\n",
      "     |      \n",
      "     |      We have 10 degrees of freedom, so is the sample mean within 95% of the\n",
      "     |      recommended value?\n",
      "     |      \n",
      "     |      >>> s = np.random.default_rng().standard_t(10, size=100000)\n",
      "     |      >>> np.mean(intake)\n",
      "     |      6753.636363636364\n",
      "     |      >>> intake.std(ddof=1)\n",
      "     |      1142.1232221373727\n",
      "     |      \n",
      "     |      Calculate the t statistic, setting the ddof parameter to the unbiased\n",
      "     |      value so the divisor in the standard deviation will be degrees of\n",
      "     |      freedom, N-1.\n",
      "     |      \n",
      "     |      >>> t = (np.mean(intake)-7725)/(intake.std(ddof=1)/np.sqrt(len(intake)))\n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> h = plt.hist(s, bins=100, density=True)\n",
      "     |      \n",
      "     |      For a one-sided t-test, how far out in the distribution does the t\n",
      "     |      statistic appear?\n",
      "     |      \n",
      "     |      >>> np.sum(s<t) / float(len(s))\n",
      "     |      0.0090699999999999999  #random\n",
      "     |      \n",
      "     |      So the p-value is about 0.009, which says the null hypothesis has a\n",
      "     |      probability of about 99% of being true.\n",
      "     |  \n",
      "     |  triangular(...)\n",
      "     |      triangular(left, mode, right, size=None)\n",
      "     |      \n",
      "     |      Draw samples from the triangular distribution over the\n",
      "     |      interval ``[left, right]``.\n",
      "     |      \n",
      "     |      The triangular distribution is a continuous probability\n",
      "     |      distribution with lower limit left, peak at mode, and upper\n",
      "     |      limit right. Unlike the other distributions, these parameters\n",
      "     |      directly define the shape of the pdf.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      left : float or array_like of floats\n",
      "     |          Lower limit.\n",
      "     |      mode : float or array_like of floats\n",
      "     |          The value where the peak of the distribution occurs.\n",
      "     |          The value must fulfill the condition ``left <= mode <= right``.\n",
      "     |      right : float or array_like of floats\n",
      "     |          Upper limit, must be larger than `left`.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``left``, ``mode``, and ``right``\n",
      "     |          are all scalars.  Otherwise, ``np.broadcast(left, mode, right).size``\n",
      "     |          samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized triangular distribution.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the triangular distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x;l, m, r) = \\begin{cases}\n",
      "     |                \\frac{2(x-l)}{(r-l)(m-l)}& \\text{for $l \\leq x \\leq m$},\\\\\n",
      "     |                \\frac{2(r-x)}{(r-l)(r-m)}& \\text{for $m \\leq x \\leq r$},\\\\\n",
      "     |                0& \\text{otherwise}.\n",
      "     |                \\end{cases}\n",
      "     |      \n",
      "     |      The triangular distribution is often used in ill-defined\n",
      "     |      problems where the underlying distribution is not known, but\n",
      "     |      some knowledge of the limits and mode exists. Often it is used\n",
      "     |      in simulations.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Wikipedia, \"Triangular distribution\"\n",
      "     |             https://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw values from the distribution and plot the histogram:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> h = plt.hist(np.random.default_rng().triangular(-3, 0, 8, 100000), bins=200,\n",
      "     |      ...              density=True)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  uniform(...)\n",
      "     |      uniform(low=0.0, high=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a uniform distribution.\n",
      "     |      \n",
      "     |      Samples are uniformly distributed over the half-open interval\n",
      "     |      ``[low, high)`` (includes low, but excludes high).  In other words,\n",
      "     |      any value within the given interval is equally likely to be drawn\n",
      "     |      by `uniform`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      low : float or array_like of floats, optional\n",
      "     |          Lower boundary of the output interval.  All values generated will be\n",
      "     |          greater than or equal to low.  The default value is 0.\n",
      "     |      high : float or array_like of floats\n",
      "     |          Upper boundary of the output interval.  All values generated will be\n",
      "     |          less than high.  The default value is 1.0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``low`` and ``high`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(low, high).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized uniform distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      integers : Discrete uniform distribution, yielding integers.\n",
      "     |      random : Floats uniformly distributed over ``[0, 1)``.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function of the uniform distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{1}{b - a}\n",
      "     |      \n",
      "     |      anywhere within the interval ``[a, b)``, and zero elsewhere.\n",
      "     |      \n",
      "     |      When ``high`` == ``low``, values of ``low`` will be returned.\n",
      "     |      If ``high`` < ``low``, the results are officially undefined\n",
      "     |      and may eventually raise an error, i.e. do not rely on this\n",
      "     |      function to behave when passed arguments satisfying that\n",
      "     |      inequality condition.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> s = np.random.default_rng().uniform(-1,0,1000)\n",
      "     |      \n",
      "     |      All values are within the given interval:\n",
      "     |      \n",
      "     |      >>> np.all(s >= -1)\n",
      "     |      True\n",
      "     |      >>> np.all(s < 0)\n",
      "     |      True\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with the\n",
      "     |      probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 15, density=True)\n",
      "     |      >>> plt.plot(bins, np.ones_like(bins), linewidth=2, color='r')\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  vonmises(...)\n",
      "     |      vonmises(mu, kappa, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a von Mises distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a von Mises distribution with specified mode\n",
      "     |      (mu) and dispersion (kappa), on the interval [-pi, pi].\n",
      "     |      \n",
      "     |      The von Mises distribution (also known as the circular normal\n",
      "     |      distribution) is a continuous probability distribution on the unit\n",
      "     |      circle.  It may be thought of as the circular analogue of the normal\n",
      "     |      distribution.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      mu : float or array_like of floats\n",
      "     |          Mode (\"center\") of the distribution.\n",
      "     |      kappa : float or array_like of floats\n",
      "     |          Dispersion of the distribution, has to be >=0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``mu`` and ``kappa`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(mu, kappa).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized von Mises distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.vonmises : probability density function, distribution, or\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the von Mises distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{e^{\\kappa cos(x-\\mu)}}{2\\pi I_0(\\kappa)},\n",
      "     |      \n",
      "     |      where :math:`\\mu` is the mode and :math:`\\kappa` the dispersion,\n",
      "     |      and :math:`I_0(\\kappa)` is the modified Bessel function of order 0.\n",
      "     |      \n",
      "     |      The von Mises is named for Richard Edler von Mises, who was born in\n",
      "     |      Austria-Hungary, in what is now the Ukraine.  He fled to the United\n",
      "     |      States in 1939 and became a professor at Harvard.  He worked in\n",
      "     |      probability theory, aerodynamics, fluid mechanics, and philosophy of\n",
      "     |      science.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n",
      "     |             Mathematical Functions with Formulas, Graphs, and Mathematical\n",
      "     |             Tables, 9th printing,\" New York: Dover, 1972.\n",
      "     |      .. [2] von Mises, R., \"Mathematical Theory of Probability\n",
      "     |             and Statistics\", New York: Academic Press, 1964.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> mu, kappa = 0.0, 4.0 # mean and dispersion\n",
      "     |      >>> s = np.random.default_rng().vonmises(mu, kappa, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> from scipy.special import i0  # doctest: +SKIP\n",
      "     |      >>> plt.hist(s, 50, density=True)\n",
      "     |      >>> x = np.linspace(-np.pi, np.pi, num=51)\n",
      "     |      >>> y = np.exp(kappa*np.cos(x-mu))/(2*np.pi*i0(kappa))  # doctest: +SKIP\n",
      "     |      >>> plt.plot(x, y, linewidth=2, color='r')  # doctest: +SKIP\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  wald(...)\n",
      "     |      wald(mean, scale, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Wald, or inverse Gaussian, distribution.\n",
      "     |      \n",
      "     |      As the scale approaches infinity, the distribution becomes more like a\n",
      "     |      Gaussian. Some references claim that the Wald is an inverse Gaussian\n",
      "     |      with mean equal to 1, but this is by no means universal.\n",
      "     |      \n",
      "     |      The inverse Gaussian distribution was first studied in relationship to\n",
      "     |      Brownian motion. In 1956 M.C.K. Tweedie used the name inverse Gaussian\n",
      "     |      because there is an inverse relationship between the time to cover a\n",
      "     |      unit distance and distance covered in unit time.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      mean : float or array_like of floats\n",
      "     |          Distribution mean, must be > 0.\n",
      "     |      scale : float or array_like of floats\n",
      "     |          Scale parameter, must be > 0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``mean`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(mean, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Wald distribution.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the Wald distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x;mean,scale) = \\sqrt{\\frac{scale}{2\\pi x^3}}e^\n",
      "     |                                  \\frac{-scale(x-mean)^2}{2\\cdotp mean^2x}\n",
      "     |      \n",
      "     |      As noted above the inverse Gaussian distribution first arise\n",
      "     |      from attempts to model Brownian motion. It is also a\n",
      "     |      competitor to the Weibull for use in reliability modeling and\n",
      "     |      modeling stock returns and interest rate processes.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Brighton Webs Ltd., Wald Distribution,\n",
      "     |             https://web.archive.org/web/20090423014010/http://www.brighton-webs.co.uk:80/distributions/wald.asp\n",
      "     |      .. [2] Chhikara, Raj S., and Folks, J. Leroy, \"The Inverse Gaussian\n",
      "     |             Distribution: Theory : Methodology, and Applications\", CRC Press,\n",
      "     |             1988.\n",
      "     |      .. [3] Wikipedia, \"Inverse Gaussian distribution\"\n",
      "     |             https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw values from the distribution and plot the histogram:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> h = plt.hist(np.random.default_rng().wald(3, 2, 100000), bins=200, density=True)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  weibull(...)\n",
      "     |      weibull(a, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Weibull distribution.\n",
      "     |      \n",
      "     |      Draw samples from a 1-parameter Weibull distribution with the given\n",
      "     |      shape parameter `a`.\n",
      "     |      \n",
      "     |      .. math:: X = (-ln(U))^{1/a}\n",
      "     |      \n",
      "     |      Here, U is drawn from the uniform distribution over (0,1].\n",
      "     |      \n",
      "     |      The more common 2-parameter Weibull, including a scale parameter\n",
      "     |      :math:`\\lambda` is just :math:`X = \\lambda(-ln(U))^{1/a}`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : float or array_like of floats\n",
      "     |          Shape parameter of the distribution.  Must be nonnegative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``a`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(a).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Weibull distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.weibull_max\n",
      "     |      scipy.stats.weibull_min\n",
      "     |      scipy.stats.genextreme\n",
      "     |      gumbel\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The Weibull (or Type III asymptotic extreme value distribution\n",
      "     |      for smallest values, SEV Type III, or Rosin-Rammler\n",
      "     |      distribution) is one of a class of Generalized Extreme Value\n",
      "     |      (GEV) distributions used in modeling extreme value problems.\n",
      "     |      This class includes the Gumbel and Frechet distributions.\n",
      "     |      \n",
      "     |      The probability density for the Weibull distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{a}\n",
      "     |                       {\\lambda}(\\frac{x}{\\lambda})^{a-1}e^{-(x/\\lambda)^a},\n",
      "     |      \n",
      "     |      where :math:`a` is the shape and :math:`\\lambda` the scale.\n",
      "     |      \n",
      "     |      The function has its peak (the mode) at\n",
      "     |      :math:`\\lambda(\\frac{a-1}{a})^{1/a}`.\n",
      "     |      \n",
      "     |      When ``a = 1``, the Weibull distribution reduces to the exponential\n",
      "     |      distribution.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Waloddi Weibull, Royal Technical University, Stockholm,\n",
      "     |             1939 \"A Statistical Theory Of The Strength Of Materials\",\n",
      "     |             Ingeniorsvetenskapsakademiens Handlingar Nr 151, 1939,\n",
      "     |             Generalstabens Litografiska Anstalts Forlag, Stockholm.\n",
      "     |      .. [2] Waloddi Weibull, \"A Statistical Distribution Function of\n",
      "     |             Wide Applicability\", Journal Of Applied Mechanics ASME Paper\n",
      "     |             1951.\n",
      "     |      .. [3] Wikipedia, \"Weibull distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Weibull_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> rng = np.random.default_rng()\n",
      "     |      >>> a = 5. # shape\n",
      "     |      >>> s = rng.weibull(a, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> x = np.arange(1,100.)/50.\n",
      "     |      >>> def weib(x,n,a):\n",
      "     |      ...     return (a / n) * (x / n)**(a - 1) * np.exp(-(x / n)**a)\n",
      "     |      \n",
      "     |      >>> count, bins, ignored = plt.hist(rng.weibull(5.,1000))\n",
      "     |      >>> x = np.arange(1,100.)/50.\n",
      "     |      >>> scale = count.max()/weib(x, 1., 5.).max()\n",
      "     |      >>> plt.plot(x, weib(x, 1., 5.)*scale)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  zipf(...)\n",
      "     |      zipf(a, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Zipf distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a Zipf distribution with specified parameter\n",
      "     |      `a` > 1.\n",
      "     |      \n",
      "     |      The Zipf distribution (also known as the zeta distribution) is a\n",
      "     |      continuous probability distribution that satisfies Zipf's law: the\n",
      "     |      frequency of an item is inversely proportional to its rank in a\n",
      "     |      frequency table.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : float or array_like of floats\n",
      "     |          Distribution parameter. Must be greater than 1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``a`` is a scalar. Otherwise,\n",
      "     |          ``np.array(a).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Zipf distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.zipf : probability density function, distribution, or\n",
      "     |          cumulative density function, etc.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Zipf distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{x^{-a}}{\\zeta(a)},\n",
      "     |      \n",
      "     |      where :math:`\\zeta` is the Riemann Zeta function.\n",
      "     |      \n",
      "     |      It is named for the American linguist George Kingsley Zipf, who noted\n",
      "     |      that the frequency of any word in a sample of a language is inversely\n",
      "     |      proportional to its rank in the frequency table.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Zipf, G. K., \"Selected Studies of the Principle of Relative\n",
      "     |             Frequency in Language,\" Cambridge, MA: Harvard Univ. Press,\n",
      "     |             1932.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> a = 2. # parameter\n",
      "     |      >>> s = np.random.default_rng().zipf(a, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> from scipy import special  # doctest: +SKIP\n",
      "     |      \n",
      "     |      Truncate s values at 50 so plot is interesting:\n",
      "     |      \n",
      "     |      >>> count, bins, ignored = plt.hist(s[s<50],\n",
      "     |      ...         50, density=True)\n",
      "     |      >>> x = np.arange(1., 50.)\n",
      "     |      >>> y = x**(-a) / special.zetac(a)  # doctest: +SKIP\n",
      "     |      >>> plt.plot(x, y/max(y), linewidth=2, color='r')  # doctest: +SKIP\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  bit_generator\n",
      "     |      Gets the bit generator instance used by the generator\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      bit_generator : BitGenerator\n",
      "     |          The bit generator instance used by the generator\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  __pyx_vtable__ = <capsule object NULL>\n",
      "    \n",
      "    class MT19937(numpy.random.bit_generator.BitGenerator)\n",
      "     |  MT19937(seed=None)\n",
      "     |  \n",
      "     |  Container for the Mersenne Twister pseudo-random number generator.\n",
      "     |  \n",
      "     |  Parameters\n",
      "     |  ----------\n",
      "     |  seed : {None, int, array_like[ints], SeedSequence}, optional\n",
      "     |      A seed to initialize the `BitGenerator`. If None, then fresh,\n",
      "     |      unpredictable entropy will be pulled from the OS. If an ``int`` or\n",
      "     |      ``array_like[ints]`` is passed, then it will be passed to\n",
      "     |      `SeedSequence` to derive the initial `BitGenerator` state. One may also\n",
      "     |      pass in a `SeedSequence` instance.\n",
      "     |  \n",
      "     |  Attributes\n",
      "     |  ----------\n",
      "     |  lock: threading.Lock\n",
      "     |      Lock instance that is shared so that the same bit git generator can\n",
      "     |      be used in multiple Generators without corrupting the state. Code that\n",
      "     |      generates values from a bit generator should hold the bit generator's\n",
      "     |      lock.\n",
      "     |  \n",
      "     |  Notes\n",
      "     |  -----\n",
      "     |  ``MT19937`` provides a capsule containing function pointers that produce\n",
      "     |  doubles, and unsigned 32 and 64- bit integers [1]_. These are not\n",
      "     |  directly consumable in Python and must be consumed by a ``Generator``\n",
      "     |  or similar object that supports low-level access.\n",
      "     |  \n",
      "     |  The Python stdlib module \"random\" also contains a Mersenne Twister\n",
      "     |  pseudo-random number generator.\n",
      "     |  \n",
      "     |  **State and Seeding**\n",
      "     |  \n",
      "     |  The ``MT19937`` state vector consists of a 624-element array of\n",
      "     |  32-bit unsigned integers plus a single integer value between 0 and 624\n",
      "     |  that indexes the current position within the main array.\n",
      "     |  \n",
      "     |  The input seed is processed by `SeedSequence` to fill the whole state. The\n",
      "     |  first element is reset such that only its most significant bit is set.\n",
      "     |  \n",
      "     |  **Parallel Features**\n",
      "     |  \n",
      "     |  The preferred way to use a BitGenerator in parallel applications is to use\n",
      "     |  the `SeedSequence.spawn` method to obtain entropy values, and to use these\n",
      "     |  to generate new BitGenerators:\n",
      "     |  \n",
      "     |  >>> from numpy.random import Generator, MT19937, SeedSequence\n",
      "     |  >>> sg = SeedSequence(1234)\n",
      "     |  >>> rg = [Generator(MT19937(s)) for s in sg.spawn(10)]\n",
      "     |  \n",
      "     |  Another method is to use `MT19937.jumped` which advances the state as-if\n",
      "     |  :math:`2^{128}` random numbers have been generated ([1]_, [2]_). This\n",
      "     |  allows the original sequence to be split so that distinct segments can be\n",
      "     |  used in each worker process. All generators should be chained to ensure\n",
      "     |  that the segments come from the same sequence.\n",
      "     |  \n",
      "     |  >>> from numpy.random import Generator, MT19937, SeedSequence\n",
      "     |  >>> sg = SeedSequence(1234)\n",
      "     |  >>> bit_generator = MT19937(sg)\n",
      "     |  >>> rg = []\n",
      "     |  >>> for _ in range(10):\n",
      "     |  ...    rg.append(Generator(bit_generator))\n",
      "     |  ...    # Chain the BitGenerators\n",
      "     |  ...    bit_generator = bit_generator.jumped()\n",
      "     |  \n",
      "     |  **Compatibility Guarantee**\n",
      "     |  \n",
      "     |  ``MT19937`` makes a guarantee that a fixed seed and will always produce\n",
      "     |  the same random integer stream.\n",
      "     |  \n",
      "     |  References\n",
      "     |  ----------\n",
      "     |  .. [1] Hiroshi Haramoto, Makoto Matsumoto, and Pierre L'Ecuyer, \"A Fast\n",
      "     |      Jump Ahead Algorithm for Linear Recurrences in a Polynomial Space\",\n",
      "     |      Sequences and Their Applications - SETA, 290--298, 2008.\n",
      "     |  .. [2] Hiroshi Haramoto, Makoto Matsumoto, Takuji Nishimura, François\n",
      "     |      Panneton, Pierre L'Ecuyer, \"Efficient Jump Ahead for F2-Linear\n",
      "     |      Random Number Generators\", INFORMS JOURNAL ON COMPUTING, Vol. 20,\n",
      "     |      No. 3, Summer 2008, pp. 385-390.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      MT19937\n",
      "     |      numpy.random.bit_generator.BitGenerator\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce_cython__(...)\n",
      "     |  \n",
      "     |  __setstate_cython__(...)\n",
      "     |  \n",
      "     |  jumped(...)\n",
      "     |      jumped(jumps=1)\n",
      "     |      \n",
      "     |      Returns a new bit generator with the state jumped\n",
      "     |      \n",
      "     |      The state of the returned big generator is jumped as-if\n",
      "     |      2**(128 * jumps) random numbers have been generated.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      jumps : integer, positive\n",
      "     |          Number of times to jump the state of the bit generator returned\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      bit_generator : MT19937\n",
      "     |          New instance of generator jumped iter times\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The jump step is computed using a modified version of Matsumoto's\n",
      "     |      implementation of Horner's method. The step polynomial is precomputed\n",
      "     |      to perform 2**128 steps. The jumped state has been verified to match\n",
      "     |      the state produced using Matsumoto's original code.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Matsumoto, M, Generating multiple disjoint streams of\n",
      "     |         pseudorandom number sequences.  Accessed on: May 6, 2020.\n",
      "     |         http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/JUMP/\n",
      "     |      .. [2] Hiroshi Haramoto, Makoto Matsumoto, Takuji Nishimura, François\n",
      "     |         Panneton, Pierre L'Ecuyer, \"Efficient Jump Ahead for F2-Linear\n",
      "     |         Random Number Generators\", INFORMS JOURNAL ON COMPUTING, Vol. 20,\n",
      "     |         No. 3, Summer 2008, pp. 385-390.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  state\n",
      "     |      Get or set the PRNG state\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      state : dict\n",
      "     |          Dictionary containing the information required to describe the\n",
      "     |          state of the PRNG\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  __pyx_vtable__ = <capsule object NULL>\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from numpy.random.bit_generator.BitGenerator:\n",
      "     |  \n",
      "     |  __getstate__(...)\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  random_raw(...)\n",
      "     |      random_raw(self, size=None)\n",
      "     |      \n",
      "     |      Return randoms as generated by the underlying BitGenerator\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      output : bool, optional\n",
      "     |          Output values.  Used for performance testing since the generated\n",
      "     |          values are not returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : uint or ndarray\n",
      "     |          Drawn samples.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      This method directly exposes the the raw underlying pseudo-random\n",
      "     |      number generator. All values are returned as unsigned 64-bit\n",
      "     |      values irrespective of the number of bits produced by the PRNG.\n",
      "     |      \n",
      "     |      See the class docstring for the number of bits returned.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from numpy.random.bit_generator.BitGenerator:\n",
      "     |  \n",
      "     |  capsule\n",
      "     |  \n",
      "     |  cffi\n",
      "     |      CFFI interface\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      interface : namedtuple\n",
      "     |          Named tuple containing CFFI wrapper\n",
      "     |      \n",
      "     |          * state_address - Memory address of the state struct\n",
      "     |          * state - pointer to the state struct\n",
      "     |          * next_uint64 - function pointer to produce 64 bit integers\n",
      "     |          * next_uint32 - function pointer to produce 32 bit integers\n",
      "     |          * next_double - function pointer to produce doubles\n",
      "     |          * bitgen - pointer to the bit generator struct\n",
      "     |  \n",
      "     |  ctypes\n",
      "     |      ctypes interface\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      interface : namedtuple\n",
      "     |          Named tuple containing ctypes wrapper\n",
      "     |      \n",
      "     |          * state_address - Memory address of the state struct\n",
      "     |          * state - pointer to the state struct\n",
      "     |          * next_uint64 - function pointer to produce 64 bit integers\n",
      "     |          * next_uint32 - function pointer to produce 32 bit integers\n",
      "     |          * next_double - function pointer to produce doubles\n",
      "     |          * bitgen - pointer to the bit generator struct\n",
      "     |  \n",
      "     |  lock\n",
      "    \n",
      "    class PCG64(numpy.random.bit_generator.BitGenerator)\n",
      "     |  PCG64(seed=None)\n",
      "     |  \n",
      "     |  BitGenerator for the PCG-64 pseudo-random number generator.\n",
      "     |  \n",
      "     |  Parameters\n",
      "     |  ----------\n",
      "     |  seed : {None, int, array_like[ints], SeedSequence}, optional\n",
      "     |      A seed to initialize the `BitGenerator`. If None, then fresh,\n",
      "     |      unpredictable entropy will be pulled from the OS. If an ``int`` or\n",
      "     |      ``array_like[ints]`` is passed, then it will be passed to\n",
      "     |      `SeedSequence` to derive the initial `BitGenerator` state. One may also\n",
      "     |      pass in a `SeedSequence` instance.\n",
      "     |  \n",
      "     |  Notes\n",
      "     |  -----\n",
      "     |  PCG-64 is a 128-bit implementation of O'Neill's permutation congruential\n",
      "     |  generator ([1]_, [2]_). PCG-64 has a period of :math:`2^{128}` and supports\n",
      "     |  advancing an arbitrary number of steps as well as :math:`2^{127}` streams.\n",
      "     |  The specific member of the PCG family that we use is PCG XSL RR 128/64\n",
      "     |  as described in the paper ([2]_).\n",
      "     |  \n",
      "     |  ``PCG64`` provides a capsule containing function pointers that produce\n",
      "     |  doubles, and unsigned 32 and 64- bit integers. These are not\n",
      "     |  directly consumable in Python and must be consumed by a ``Generator``\n",
      "     |  or similar object that supports low-level access.\n",
      "     |  \n",
      "     |  Supports the method :meth:`advance` to advance the RNG an arbitrary number of\n",
      "     |  steps. The state of the PCG-64 RNG is represented by 2 128-bit unsigned\n",
      "     |  integers.\n",
      "     |  \n",
      "     |  **State and Seeding**\n",
      "     |  \n",
      "     |  The ``PCG64`` state vector consists of 2 unsigned 128-bit values,\n",
      "     |  which are represented externally as Python ints. One is the state of the\n",
      "     |  PRNG, which is advanced by a linear congruential generator (LCG). The\n",
      "     |  second is a fixed odd increment used in the LCG.\n",
      "     |  \n",
      "     |  The input seed is processed by `SeedSequence` to generate both values. The\n",
      "     |  increment is not independently settable.\n",
      "     |  \n",
      "     |  **Parallel Features**\n",
      "     |  \n",
      "     |  The preferred way to use a BitGenerator in parallel applications is to use\n",
      "     |  the `SeedSequence.spawn` method to obtain entropy values, and to use these\n",
      "     |  to generate new BitGenerators:\n",
      "     |  \n",
      "     |  >>> from numpy.random import Generator, PCG64, SeedSequence\n",
      "     |  >>> sg = SeedSequence(1234)\n",
      "     |  >>> rg = [Generator(PCG64(s)) for s in sg.spawn(10)]\n",
      "     |  \n",
      "     |  **Compatibility Guarantee**\n",
      "     |  \n",
      "     |  ``PCG64`` makes a guarantee that a fixed seed and will always produce\n",
      "     |  the same random integer stream.\n",
      "     |  \n",
      "     |  References\n",
      "     |  ----------\n",
      "     |  .. [1] `\"PCG, A Family of Better Random Number Generators\"\n",
      "     |         <http://www.pcg-random.org/>`_\n",
      "     |  .. [2] O'Neill, Melissa E. `\"PCG: A Family of Simple Fast Space-Efficient\n",
      "     |         Statistically Good Algorithms for Random Number Generation\"\n",
      "     |         <https://www.cs.hmc.edu/tr/hmc-cs-2014-0905.pdf>`_\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      PCG64\n",
      "     |      numpy.random.bit_generator.BitGenerator\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce_cython__(...)\n",
      "     |  \n",
      "     |  __setstate_cython__(...)\n",
      "     |  \n",
      "     |  advance(...)\n",
      "     |      advance(delta)\n",
      "     |      \n",
      "     |      Advance the underlying RNG as-if delta draws have occurred.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      delta : integer, positive\n",
      "     |          Number of draws to advance the RNG. Must be less than the\n",
      "     |          size state variable in the underlying RNG.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      self : PCG64\n",
      "     |          RNG advanced delta steps\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      Advancing a RNG updates the underlying RNG state as-if a given\n",
      "     |      number of calls to the underlying RNG have been made. In general\n",
      "     |      there is not a one-to-one relationship between the number output\n",
      "     |      random values from a particular distribution and the number of\n",
      "     |      draws from the core RNG.  This occurs for two reasons:\n",
      "     |      \n",
      "     |      * The random values are simulated using a rejection-based method\n",
      "     |        and so, on average, more than one value from the underlying\n",
      "     |        RNG is required to generate an single draw.\n",
      "     |      * The number of bits required to generate a simulated value\n",
      "     |        differs from the number of bits generated by the underlying\n",
      "     |        RNG.  For example, two 16-bit integer values can be simulated\n",
      "     |        from a single draw of a 32-bit RNG.\n",
      "     |      \n",
      "     |      Advancing the RNG state resets any pre-computed random numbers.\n",
      "     |      This is required to ensure exact reproducibility.\n",
      "     |  \n",
      "     |  jumped(...)\n",
      "     |      jumped(jumps=1)\n",
      "     |      \n",
      "     |      Returns a new bit generator with the state jumped.\n",
      "     |      \n",
      "     |      Jumps the state as-if jumps * 210306068529402873165736369884012333109\n",
      "     |      random numbers have been generated.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      jumps : integer, positive\n",
      "     |          Number of times to jump the state of the bit generator returned\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      bit_generator : PCG64\n",
      "     |          New instance of generator jumped iter times\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The step size is phi-1 when multiplied by 2**128 where phi is the\n",
      "     |      golden ratio.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  state\n",
      "     |      Get or set the PRNG state\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      state : dict\n",
      "     |          Dictionary containing the information required to describe the\n",
      "     |          state of the PRNG\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  __pyx_vtable__ = <capsule object NULL>\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from numpy.random.bit_generator.BitGenerator:\n",
      "     |  \n",
      "     |  __getstate__(...)\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  random_raw(...)\n",
      "     |      random_raw(self, size=None)\n",
      "     |      \n",
      "     |      Return randoms as generated by the underlying BitGenerator\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      output : bool, optional\n",
      "     |          Output values.  Used for performance testing since the generated\n",
      "     |          values are not returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : uint or ndarray\n",
      "     |          Drawn samples.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      This method directly exposes the the raw underlying pseudo-random\n",
      "     |      number generator. All values are returned as unsigned 64-bit\n",
      "     |      values irrespective of the number of bits produced by the PRNG.\n",
      "     |      \n",
      "     |      See the class docstring for the number of bits returned.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from numpy.random.bit_generator.BitGenerator:\n",
      "     |  \n",
      "     |  capsule\n",
      "     |  \n",
      "     |  cffi\n",
      "     |      CFFI interface\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      interface : namedtuple\n",
      "     |          Named tuple containing CFFI wrapper\n",
      "     |      \n",
      "     |          * state_address - Memory address of the state struct\n",
      "     |          * state - pointer to the state struct\n",
      "     |          * next_uint64 - function pointer to produce 64 bit integers\n",
      "     |          * next_uint32 - function pointer to produce 32 bit integers\n",
      "     |          * next_double - function pointer to produce doubles\n",
      "     |          * bitgen - pointer to the bit generator struct\n",
      "     |  \n",
      "     |  ctypes\n",
      "     |      ctypes interface\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      interface : namedtuple\n",
      "     |          Named tuple containing ctypes wrapper\n",
      "     |      \n",
      "     |          * state_address - Memory address of the state struct\n",
      "     |          * state - pointer to the state struct\n",
      "     |          * next_uint64 - function pointer to produce 64 bit integers\n",
      "     |          * next_uint32 - function pointer to produce 32 bit integers\n",
      "     |          * next_double - function pointer to produce doubles\n",
      "     |          * bitgen - pointer to the bit generator struct\n",
      "     |  \n",
      "     |  lock\n",
      "    \n",
      "    class Philox(numpy.random.bit_generator.BitGenerator)\n",
      "     |  Philox(seed=None, counter=None, key=None)\n",
      "     |  \n",
      "     |  Container for the Philox (4x64) pseudo-random number generator.\n",
      "     |  \n",
      "     |  Parameters\n",
      "     |  ----------\n",
      "     |  seed : {None, int, array_like[ints], SeedSequence}, optional\n",
      "     |      A seed to initialize the `BitGenerator`. If None, then fresh,\n",
      "     |      unpredictable entropy will be pulled from the OS. If an ``int`` or\n",
      "     |      ``array_like[ints]`` is passed, then it will be passed to\n",
      "     |      `SeedSequence` to derive the initial `BitGenerator` state. One may also\n",
      "     |      pass in a `SeedSequence` instance.\n",
      "     |  counter : {None, int, array_like}, optional\n",
      "     |      Counter to use in the Philox state. Can be either\n",
      "     |      a Python int (long in 2.x) in [0, 2**256) or a 4-element uint64 array.\n",
      "     |      If not provided, the RNG is initialized at 0.\n",
      "     |  key : {None, int, array_like}, optional\n",
      "     |      Key to use in the Philox state.  Unlike ``seed``, the value in key is\n",
      "     |      directly set. Can be either a Python int in [0, 2**128) or a 2-element\n",
      "     |      uint64 array. `key` and ``seed`` cannot both be used.\n",
      "     |  \n",
      "     |  Attributes\n",
      "     |  ----------\n",
      "     |  lock: threading.Lock\n",
      "     |      Lock instance that is shared so that the same bit git generator can\n",
      "     |      be used in multiple Generators without corrupting the state. Code that\n",
      "     |      generates values from a bit generator should hold the bit generator's\n",
      "     |      lock.\n",
      "     |  \n",
      "     |  Notes\n",
      "     |  -----\n",
      "     |  Philox is a 64-bit PRNG that uses a counter-based design based on weaker\n",
      "     |  (and faster) versions of cryptographic functions [1]_. Instances using\n",
      "     |  different values of the key produce independent sequences.  Philox has a\n",
      "     |  period of :math:`2^{256} - 1` and supports arbitrary advancing and jumping\n",
      "     |  the sequence in increments of :math:`2^{128}`. These features allow\n",
      "     |  multiple non-overlapping sequences to be generated.\n",
      "     |  \n",
      "     |  ``Philox`` provides a capsule containing function pointers that produce\n",
      "     |  doubles, and unsigned 32 and 64- bit integers. These are not\n",
      "     |  directly consumable in Python and must be consumed by a ``Generator``\n",
      "     |  or similar object that supports low-level access.\n",
      "     |  \n",
      "     |  **State and Seeding**\n",
      "     |  \n",
      "     |  The ``Philox`` state vector consists of a 256-bit value encoded as\n",
      "     |  a 4-element uint64 array and a 128-bit value encoded as a 2-element uint64\n",
      "     |  array. The former is a counter which is incremented by 1 for every 4 64-bit\n",
      "     |  randoms produced. The second is a key which determined the sequence\n",
      "     |  produced. Using different keys produces independent sequences.\n",
      "     |  \n",
      "     |  The input ``seed`` is processed by `SeedSequence` to generate the key. The\n",
      "     |  counter is set to 0.\n",
      "     |  \n",
      "     |  Alternately, one can omit the ``seed`` parameter and set the ``key`` and\n",
      "     |  ``counter`` directly.\n",
      "     |  \n",
      "     |  **Parallel Features**\n",
      "     |  \n",
      "     |  The preferred way to use a BitGenerator in parallel applications is to use\n",
      "     |  the `SeedSequence.spawn` method to obtain entropy values, and to use these\n",
      "     |  to generate new BitGenerators:\n",
      "     |  \n",
      "     |  >>> from numpy.random import Generator, Philox, SeedSequence\n",
      "     |  >>> sg = SeedSequence(1234)\n",
      "     |  >>> rg = [Generator(Philox(s)) for s in sg.spawn(10)]\n",
      "     |  \n",
      "     |  ``Philox`` can be used in parallel applications by calling the ``jumped``\n",
      "     |  method  to advances the state as-if :math:`2^{128}` random numbers have\n",
      "     |  been generated. Alternatively, ``advance`` can be used to advance the\n",
      "     |  counter for any positive step in [0, 2**256). When using ``jumped``, all\n",
      "     |  generators should be chained to ensure that the segments come from the same\n",
      "     |  sequence.\n",
      "     |  \n",
      "     |  >>> from numpy.random import Generator, Philox\n",
      "     |  >>> bit_generator = Philox(1234)\n",
      "     |  >>> rg = []\n",
      "     |  >>> for _ in range(10):\n",
      "     |  ...    rg.append(Generator(bit_generator))\n",
      "     |  ...    bit_generator = bit_generator.jumped()\n",
      "     |  \n",
      "     |  Alternatively, ``Philox`` can be used in parallel applications by using\n",
      "     |  a sequence of distinct keys where each instance uses different key.\n",
      "     |  \n",
      "     |  >>> key = 2**96 + 2**33 + 2**17 + 2**9\n",
      "     |  >>> rg = [Generator(Philox(key=key+i)) for i in range(10)]\n",
      "     |  \n",
      "     |  **Compatibility Guarantee**\n",
      "     |  \n",
      "     |  ``Philox`` makes a guarantee that a fixed ``seed`` will always produce\n",
      "     |  the same random integer stream.\n",
      "     |  \n",
      "     |  Examples\n",
      "     |  --------\n",
      "     |  >>> from numpy.random import Generator, Philox\n",
      "     |  >>> rg = Generator(Philox(1234))\n",
      "     |  >>> rg.standard_normal()\n",
      "     |  0.123  # random\n",
      "     |  \n",
      "     |  References\n",
      "     |  ----------\n",
      "     |  .. [1] John K. Salmon, Mark A. Moraes, Ron O. Dror, and David E. Shaw,\n",
      "     |         \"Parallel Random Numbers: As Easy as 1, 2, 3,\" Proceedings of\n",
      "     |         the International Conference for High Performance Computing,\n",
      "     |         Networking, Storage and Analysis (SC11), New York, NY: ACM, 2011.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      Philox\n",
      "     |      numpy.random.bit_generator.BitGenerator\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce_cython__(...)\n",
      "     |  \n",
      "     |  __setstate_cython__(...)\n",
      "     |  \n",
      "     |  advance(...)\n",
      "     |      advance(delta)\n",
      "     |      \n",
      "     |      Advance the underlying RNG as-if delta draws have occurred.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      delta : integer, positive\n",
      "     |          Number of draws to advance the RNG. Must be less than the\n",
      "     |          size state variable in the underlying RNG.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      self : Philox\n",
      "     |          RNG advanced delta steps\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      Advancing a RNG updates the underlying RNG state as-if a given\n",
      "     |      number of calls to the underlying RNG have been made. In general\n",
      "     |      there is not a one-to-one relationship between the number output\n",
      "     |      random values from a particular distribution and the number of\n",
      "     |      draws from the core RNG.  This occurs for two reasons:\n",
      "     |      \n",
      "     |      * The random values are simulated using a rejection-based method\n",
      "     |        and so, on average, more than one value from the underlying\n",
      "     |        RNG is required to generate an single draw.\n",
      "     |      * The number of bits required to generate a simulated value\n",
      "     |        differs from the number of bits generated by the underlying\n",
      "     |        RNG.  For example, two 16-bit integer values can be simulated\n",
      "     |        from a single draw of a 32-bit RNG.\n",
      "     |      \n",
      "     |      Advancing the RNG state resets any pre-computed random numbers.\n",
      "     |      This is required to ensure exact reproducibility.\n",
      "     |  \n",
      "     |  jumped(...)\n",
      "     |      jumped(jumps=1)\n",
      "     |      \n",
      "     |      Returns a new bit generator with the state jumped\n",
      "     |      \n",
      "     |      The state of the returned big generator is jumped as-if\n",
      "     |      2**(128 * jumps) random numbers have been generated.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      jumps : integer, positive\n",
      "     |          Number of times to jump the state of the bit generator returned\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      bit_generator : Philox\n",
      "     |          New instance of generator jumped iter times\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  state\n",
      "     |      Get or set the PRNG state\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      state : dict\n",
      "     |          Dictionary containing the information required to describe the\n",
      "     |          state of the PRNG\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  __pyx_vtable__ = <capsule object NULL>\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from numpy.random.bit_generator.BitGenerator:\n",
      "     |  \n",
      "     |  __getstate__(...)\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  random_raw(...)\n",
      "     |      random_raw(self, size=None)\n",
      "     |      \n",
      "     |      Return randoms as generated by the underlying BitGenerator\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      output : bool, optional\n",
      "     |          Output values.  Used for performance testing since the generated\n",
      "     |          values are not returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : uint or ndarray\n",
      "     |          Drawn samples.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      This method directly exposes the the raw underlying pseudo-random\n",
      "     |      number generator. All values are returned as unsigned 64-bit\n",
      "     |      values irrespective of the number of bits produced by the PRNG.\n",
      "     |      \n",
      "     |      See the class docstring for the number of bits returned.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from numpy.random.bit_generator.BitGenerator:\n",
      "     |  \n",
      "     |  capsule\n",
      "     |  \n",
      "     |  cffi\n",
      "     |      CFFI interface\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      interface : namedtuple\n",
      "     |          Named tuple containing CFFI wrapper\n",
      "     |      \n",
      "     |          * state_address - Memory address of the state struct\n",
      "     |          * state - pointer to the state struct\n",
      "     |          * next_uint64 - function pointer to produce 64 bit integers\n",
      "     |          * next_uint32 - function pointer to produce 32 bit integers\n",
      "     |          * next_double - function pointer to produce doubles\n",
      "     |          * bitgen - pointer to the bit generator struct\n",
      "     |  \n",
      "     |  ctypes\n",
      "     |      ctypes interface\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      interface : namedtuple\n",
      "     |          Named tuple containing ctypes wrapper\n",
      "     |      \n",
      "     |          * state_address - Memory address of the state struct\n",
      "     |          * state - pointer to the state struct\n",
      "     |          * next_uint64 - function pointer to produce 64 bit integers\n",
      "     |          * next_uint32 - function pointer to produce 32 bit integers\n",
      "     |          * next_double - function pointer to produce doubles\n",
      "     |          * bitgen - pointer to the bit generator struct\n",
      "     |  \n",
      "     |  lock\n",
      "    \n",
      "    class RandomState(builtins.object)\n",
      "     |  RandomState(seed=None)\n",
      "     |  \n",
      "     |  Container for the slow Mersenne Twister pseudo-random number generator.\n",
      "     |  Consider using a different BitGenerator with the Generator container\n",
      "     |  instead.\n",
      "     |  \n",
      "     |  `RandomState` and `Generator` expose a number of methods for generating\n",
      "     |  random numbers drawn from a variety of probability distributions. In\n",
      "     |  addition to the distribution-specific arguments, each method takes a\n",
      "     |  keyword argument `size` that defaults to ``None``. If `size` is ``None``,\n",
      "     |  then a single value is generated and returned. If `size` is an integer,\n",
      "     |  then a 1-D array filled with generated values is returned. If `size` is a\n",
      "     |  tuple, then an array with that shape is filled and returned.\n",
      "     |  \n",
      "     |  **Compatibility Guarantee**\n",
      "     |  \n",
      "     |  A fixed bit generator using a fixed seed and a fixed series of calls to\n",
      "     |  'RandomState' methods using the same parameters will always produce the\n",
      "     |  same results up to roundoff error except when the values were incorrect.\n",
      "     |  `RandomState` is effectively frozen and will only receive updates that\n",
      "     |  are required by changes in the the internals of Numpy. More substantial\n",
      "     |  changes, including algorithmic improvements, are reserved for\n",
      "     |  `Generator`.\n",
      "     |  \n",
      "     |  Parameters\n",
      "     |  ----------\n",
      "     |  seed : {None, int, array_like, BitGenerator}, optional\n",
      "     |      Random seed used to initialize the pseudo-random number generator or\n",
      "     |      an instantized BitGenerator.  If an integer or array, used as a seed for\n",
      "     |      the MT19937 BitGenerator. Values can be any integer between 0 and\n",
      "     |      2**32 - 1 inclusive, an array (or other sequence) of such integers,\n",
      "     |      or ``None`` (the default).  If `seed` is ``None``, then the `MT19937`\n",
      "     |      BitGenerator is initialized by reading data from ``/dev/urandom``\n",
      "     |      (or the Windows analogue) if available or seed from the clock\n",
      "     |      otherwise.\n",
      "     |  \n",
      "     |  Notes\n",
      "     |  -----\n",
      "     |  The Python stdlib module \"random\" also contains a Mersenne Twister\n",
      "     |  pseudo-random number generator with a number of methods that are similar\n",
      "     |  to the ones available in `RandomState`. `RandomState`, besides being\n",
      "     |  NumPy-aware, has the advantage that it provides a much larger number\n",
      "     |  of probability distributions to choose from.\n",
      "     |  \n",
      "     |  See Also\n",
      "     |  --------\n",
      "     |  Generator\n",
      "     |  MT19937\n",
      "     |  numpy.random.BitGenerator\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getstate__(...)\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  beta(...)\n",
      "     |      beta(a, b, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Beta distribution.\n",
      "     |      \n",
      "     |      The Beta distribution is a special case of the Dirichlet distribution,\n",
      "     |      and is related to the Gamma distribution.  It has the probability\n",
      "     |      distribution function\n",
      "     |      \n",
      "     |      .. math:: f(x; a,b) = \\frac{1}{B(\\alpha, \\beta)} x^{\\alpha - 1}\n",
      "     |                                                       (1 - x)^{\\beta - 1},\n",
      "     |      \n",
      "     |      where the normalization, B, is the beta function,\n",
      "     |      \n",
      "     |      .. math:: B(\\alpha, \\beta) = \\int_0^1 t^{\\alpha - 1}\n",
      "     |                                   (1 - t)^{\\beta - 1} dt.\n",
      "     |      \n",
      "     |      It is often seen in Bayesian inference and order statistics.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``beta`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : float or array_like of floats\n",
      "     |          Alpha, positive (>0).\n",
      "     |      b : float or array_like of floats\n",
      "     |          Beta, positive (>0).\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``a`` and ``b`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(a, b).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized beta distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.beta: which should be used for new code.\n",
      "     |  \n",
      "     |  binomial(...)\n",
      "     |      binomial(n, p, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a binomial distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a binomial distribution with specified\n",
      "     |      parameters, n trials and p probability of success where\n",
      "     |      n an integer >= 0 and p is in the interval [0,1]. (n may be\n",
      "     |      input as a float, but it is truncated to an integer in use)\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``binomial`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      n : int or array_like of ints\n",
      "     |          Parameter of the distribution, >= 0. Floats are also accepted,\n",
      "     |          but they will be truncated to integers.\n",
      "     |      p : float or array_like of floats\n",
      "     |          Parameter of the distribution, >= 0 and <=1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``n`` and ``p`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized binomial distribution, where\n",
      "     |          each sample is equal to the number of successes over the n trials.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.binom : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.binomial: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the binomial distribution is\n",
      "     |      \n",
      "     |      .. math:: P(N) = \\binom{n}{N}p^N(1-p)^{n-N},\n",
      "     |      \n",
      "     |      where :math:`n` is the number of trials, :math:`p` is the probability\n",
      "     |      of success, and :math:`N` is the number of successes.\n",
      "     |      \n",
      "     |      When estimating the standard error of a proportion in a population by\n",
      "     |      using a random sample, the normal distribution works well unless the\n",
      "     |      product p*n <=5, where p = population proportion estimate, and n =\n",
      "     |      number of samples, in which case the binomial distribution is used\n",
      "     |      instead. For example, a sample of 15 people shows 4 who are left\n",
      "     |      handed, and 11 who are right handed. Then p = 4/15 = 27%. 0.27*15 = 4,\n",
      "     |      so the binomial distribution should be used in this case.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Dalgaard, Peter, \"Introductory Statistics with R\",\n",
      "     |             Springer-Verlag, 2002.\n",
      "     |      .. [2] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n",
      "     |             Fifth Edition, 2002.\n",
      "     |      .. [3] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n",
      "     |             and Quigley, 1972.\n",
      "     |      .. [4] Weisstein, Eric W. \"Binomial Distribution.\" From MathWorld--A\n",
      "     |             Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/BinomialDistribution.html\n",
      "     |      .. [5] Wikipedia, \"Binomial distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Binomial_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> n, p = 10, .5  # number of trials, probability of each trial\n",
      "     |      >>> s = np.random.binomial(n, p, 1000)\n",
      "     |      # result of flipping a coin 10 times, tested 1000 times.\n",
      "     |      \n",
      "     |      A real world example. A company drills 9 wild-cat oil exploration\n",
      "     |      wells, each with an estimated probability of success of 0.1. All nine\n",
      "     |      wells fail. What is the probability of that happening?\n",
      "     |      \n",
      "     |      Let's do 20,000 trials of the model, and count the number that\n",
      "     |      generate zero positive results.\n",
      "     |      \n",
      "     |      >>> sum(np.random.binomial(9, 0.1, 20000) == 0)/20000.\n",
      "     |      # answer = 0.38885, or 38%.\n",
      "     |  \n",
      "     |  bytes(...)\n",
      "     |      bytes(length)\n",
      "     |      \n",
      "     |      Return random bytes.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``bytes`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      length : int\n",
      "     |          Number of random bytes.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : str\n",
      "     |          String of length `length`.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.bytes: which should be used for new code.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> np.random.bytes(10)\n",
      "     |      ' eh\\x85\\x022SZ\\xbf\\xa4' #random\n",
      "     |  \n",
      "     |  chisquare(...)\n",
      "     |      chisquare(df, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a chi-square distribution.\n",
      "     |      \n",
      "     |      When `df` independent random variables, each with standard normal\n",
      "     |      distributions (mean 0, variance 1), are squared and summed, the\n",
      "     |      resulting distribution is chi-square (see Notes).  This distribution\n",
      "     |      is often used in hypothesis testing.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``chisquare`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      df : float or array_like of floats\n",
      "     |           Number of degrees of freedom, must be > 0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``df`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(df).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized chi-square distribution.\n",
      "     |      \n",
      "     |      Raises\n",
      "     |      ------\n",
      "     |      ValueError\n",
      "     |          When `df` <= 0 or when an inappropriate `size` (e.g. ``size=-1``)\n",
      "     |          is given.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.chisquare: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The variable obtained by summing the squares of `df` independent,\n",
      "     |      standard normally distributed random variables:\n",
      "     |      \n",
      "     |      .. math:: Q = \\sum_{i=0}^{\\mathtt{df}} X^2_i\n",
      "     |      \n",
      "     |      is chi-square distributed, denoted\n",
      "     |      \n",
      "     |      .. math:: Q \\sim \\chi^2_k.\n",
      "     |      \n",
      "     |      The probability density function of the chi-squared distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{(1/2)^{k/2}}{\\Gamma(k/2)}\n",
      "     |                       x^{k/2 - 1} e^{-x/2},\n",
      "     |      \n",
      "     |      where :math:`\\Gamma` is the gamma function,\n",
      "     |      \n",
      "     |      .. math:: \\Gamma(x) = \\int_0^{-\\infty} t^{x - 1} e^{-t} dt.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] NIST \"Engineering Statistics Handbook\"\n",
      "     |             https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> np.random.chisquare(2,4)\n",
      "     |      array([ 1.89920014,  9.00867716,  3.13710533,  5.62318272]) # random\n",
      "     |  \n",
      "     |  choice(...)\n",
      "     |      choice(a, size=None, replace=True, p=None)\n",
      "     |      \n",
      "     |      Generates a random sample from a given 1-D array\n",
      "     |      \n",
      "     |      .. versionadded:: 1.7.0\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``choice`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : 1-D array-like or int\n",
      "     |          If an ndarray, a random sample is generated from its elements.\n",
      "     |          If an int, the random sample is generated as if a were np.arange(a)\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      replace : boolean, optional\n",
      "     |          Whether the sample is with or without replacement\n",
      "     |      p : 1-D array-like, optional\n",
      "     |          The probabilities associated with each entry in a.\n",
      "     |          If not given the sample assumes a uniform distribution over all\n",
      "     |          entries in a.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      samples : single item or ndarray\n",
      "     |          The generated random samples\n",
      "     |      \n",
      "     |      Raises\n",
      "     |      ------\n",
      "     |      ValueError\n",
      "     |          If a is an int and less than zero, if a or p are not 1-dimensional,\n",
      "     |          if a is an array-like of size 0, if p is not a vector of\n",
      "     |          probabilities, if a and p have different lengths, or if\n",
      "     |          replace=False and the sample size is greater than the population\n",
      "     |          size\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      randint, shuffle, permutation\n",
      "     |      Generator.choice: which should be used in new code\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      Sampling random rows from a 2-D array is not possible with this function,\n",
      "     |      but is possible with `Generator.choice` through its ``axis`` keyword.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Generate a uniform random sample from np.arange(5) of size 3:\n",
      "     |      \n",
      "     |      >>> np.random.choice(5, 3)\n",
      "     |      array([0, 3, 4]) # random\n",
      "     |      >>> #This is equivalent to np.random.randint(0,5,3)\n",
      "     |      \n",
      "     |      Generate a non-uniform random sample from np.arange(5) of size 3:\n",
      "     |      \n",
      "     |      >>> np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])\n",
      "     |      array([3, 3, 0]) # random\n",
      "     |      \n",
      "     |      Generate a uniform random sample from np.arange(5) of size 3 without\n",
      "     |      replacement:\n",
      "     |      \n",
      "     |      >>> np.random.choice(5, 3, replace=False)\n",
      "     |      array([3,1,0]) # random\n",
      "     |      >>> #This is equivalent to np.random.permutation(np.arange(5))[:3]\n",
      "     |      \n",
      "     |      Generate a non-uniform random sample from np.arange(5) of size\n",
      "     |      3 without replacement:\n",
      "     |      \n",
      "     |      >>> np.random.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])\n",
      "     |      array([2, 3, 0]) # random\n",
      "     |      \n",
      "     |      Any of the above can be repeated with an arbitrary array-like\n",
      "     |      instead of just integers. For instance:\n",
      "     |      \n",
      "     |      >>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']\n",
      "     |      >>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])\n",
      "     |      array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], # random\n",
      "     |            dtype='<U11')\n",
      "     |  \n",
      "     |  dirichlet(...)\n",
      "     |      dirichlet(alpha, size=None)\n",
      "     |      \n",
      "     |      Draw samples from the Dirichlet distribution.\n",
      "     |      \n",
      "     |      Draw `size` samples of dimension k from a Dirichlet distribution. A\n",
      "     |      Dirichlet-distributed random variable can be seen as a multivariate\n",
      "     |      generalization of a Beta distribution. The Dirichlet distribution\n",
      "     |      is a conjugate prior of a multinomial distribution in Bayesian\n",
      "     |      inference.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``dirichlet`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      alpha : sequence of floats, length k\n",
      "     |          Parameter of the distribution (length ``k`` for sample of\n",
      "     |          length ``k``).\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          vector of length ``k`` is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      samples : ndarray,\n",
      "     |          The drawn samples, of shape ``(size, k)``.\n",
      "     |      \n",
      "     |      Raises\n",
      "     |      -------\n",
      "     |      ValueError\n",
      "     |          If any value in ``alpha`` is less than or equal to zero\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.dirichlet: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The Dirichlet distribution is a distribution over vectors\n",
      "     |      :math:`x` that fulfil the conditions :math:`x_i>0` and\n",
      "     |      :math:`\\sum_{i=1}^k x_i = 1`.\n",
      "     |      \n",
      "     |      The probability density function :math:`p` of a\n",
      "     |      Dirichlet-distributed random vector :math:`X` is\n",
      "     |      proportional to\n",
      "     |      \n",
      "     |      .. math:: p(x) \\propto \\prod_{i=1}^{k}{x^{\\alpha_i-1}_i},\n",
      "     |      \n",
      "     |      where :math:`\\alpha` is a vector containing the positive\n",
      "     |      concentration parameters.\n",
      "     |      \n",
      "     |      The method uses the following property for computation: let :math:`Y`\n",
      "     |      be a random vector which has components that follow a standard gamma\n",
      "     |      distribution, then :math:`X = \\frac{1}{\\sum_{i=1}^k{Y_i}} Y`\n",
      "     |      is Dirichlet-distributed\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] David McKay, \"Information Theory, Inference and Learning\n",
      "     |             Algorithms,\" chapter 23,\n",
      "     |             http://www.inference.org.uk/mackay/itila/\n",
      "     |      .. [2] Wikipedia, \"Dirichlet distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Dirichlet_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Taking an example cited in Wikipedia, this distribution can be used if\n",
      "     |      one wanted to cut strings (each of initial length 1.0) into K pieces\n",
      "     |      with different lengths, where each piece had, on average, a designated\n",
      "     |      average length, but allowing some variation in the relative sizes of\n",
      "     |      the pieces.\n",
      "     |      \n",
      "     |      >>> s = np.random.dirichlet((10, 5, 3), 20).transpose()\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> plt.barh(range(20), s[0])\n",
      "     |      >>> plt.barh(range(20), s[1], left=s[0], color='g')\n",
      "     |      >>> plt.barh(range(20), s[2], left=s[0]+s[1], color='r')\n",
      "     |      >>> plt.title(\"Lengths of Strings\")\n",
      "     |  \n",
      "     |  exponential(...)\n",
      "     |      exponential(scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from an exponential distribution.\n",
      "     |      \n",
      "     |      Its probability density function is\n",
      "     |      \n",
      "     |      .. math:: f(x; \\frac{1}{\\beta}) = \\frac{1}{\\beta} \\exp(-\\frac{x}{\\beta}),\n",
      "     |      \n",
      "     |      for ``x > 0`` and 0 elsewhere. :math:`\\beta` is the scale parameter,\n",
      "     |      which is the inverse of the rate parameter :math:`\\lambda = 1/\\beta`.\n",
      "     |      The rate parameter is an alternative, widely used parameterization\n",
      "     |      of the exponential distribution [3]_.\n",
      "     |      \n",
      "     |      The exponential distribution is a continuous analogue of the\n",
      "     |      geometric distribution.  It describes many common situations, such as\n",
      "     |      the size of raindrops measured over many rainstorms [1]_, or the time\n",
      "     |      between page requests to Wikipedia [2]_.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``exponential`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      scale : float or array_like of floats\n",
      "     |          The scale parameter, :math:`\\beta = 1/\\lambda`. Must be\n",
      "     |          non-negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``scale`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized exponential distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.exponential: which should be used for new code.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Peyton Z. Peebles Jr., \"Probability, Random Variables and\n",
      "     |             Random Signal Principles\", 4th ed, 2001, p. 57.\n",
      "     |      .. [2] Wikipedia, \"Poisson process\",\n",
      "     |             https://en.wikipedia.org/wiki/Poisson_process\n",
      "     |      .. [3] Wikipedia, \"Exponential distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Exponential_distribution\n",
      "     |  \n",
      "     |  f(...)\n",
      "     |      f(dfnum, dfden, size=None)\n",
      "     |      \n",
      "     |      Draw samples from an F distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from an F distribution with specified parameters,\n",
      "     |      `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n",
      "     |      freedom in denominator), where both parameters must be greater than\n",
      "     |      zero.\n",
      "     |      \n",
      "     |      The random variate of the F distribution (also known as the\n",
      "     |      Fisher distribution) is a continuous probability distribution\n",
      "     |      that arises in ANOVA tests, and is the ratio of two chi-square\n",
      "     |      variates.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``f`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      dfnum : float or array_like of floats\n",
      "     |          Degrees of freedom in numerator, must be > 0.\n",
      "     |      dfden : float or array_like of float\n",
      "     |          Degrees of freedom in denominator, must be > 0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``dfnum`` and ``dfden`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(dfnum, dfden).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Fisher distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.f : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.f: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The F statistic is used to compare in-group variances to between-group\n",
      "     |      variances. Calculating the distribution depends on the sampling, and\n",
      "     |      so it is a function of the respective degrees of freedom in the\n",
      "     |      problem.  The variable `dfnum` is the number of samples minus one, the\n",
      "     |      between-groups degrees of freedom, while `dfden` is the within-groups\n",
      "     |      degrees of freedom, the sum of the number of samples in each group\n",
      "     |      minus the number of groups.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n",
      "     |             Fifth Edition, 2002.\n",
      "     |      .. [2] Wikipedia, \"F-distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/F-distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      An example from Glantz[1], pp 47-40:\n",
      "     |      \n",
      "     |      Two groups, children of diabetics (25 people) and children from people\n",
      "     |      without diabetes (25 controls). Fasting blood glucose was measured,\n",
      "     |      case group had a mean value of 86.1, controls had a mean value of\n",
      "     |      82.2. Standard deviations were 2.09 and 2.49 respectively. Are these\n",
      "     |      data consistent with the null hypothesis that the parents diabetic\n",
      "     |      status does not affect their children's blood glucose levels?\n",
      "     |      Calculating the F statistic from the data gives a value of 36.01.\n",
      "     |      \n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> dfnum = 1. # between group degrees of freedom\n",
      "     |      >>> dfden = 48. # within groups degrees of freedom\n",
      "     |      >>> s = np.random.f(dfnum, dfden, 1000)\n",
      "     |      \n",
      "     |      The lower bound for the top 1% of the samples is :\n",
      "     |      \n",
      "     |      >>> np.sort(s)[-10]\n",
      "     |      7.61988120985 # random\n",
      "     |      \n",
      "     |      So there is about a 1% chance that the F statistic will exceed 7.62,\n",
      "     |      the measured value is 36, so the null hypothesis is rejected at the 1%\n",
      "     |      level.\n",
      "     |  \n",
      "     |  gamma(...)\n",
      "     |      gamma(shape, scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Gamma distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a Gamma distribution with specified parameters,\n",
      "     |      `shape` (sometimes designated \"k\") and `scale` (sometimes designated\n",
      "     |      \"theta\"), where both parameters are > 0.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``gamma`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      shape : float or array_like of floats\n",
      "     |          The shape of the gamma distribution. Must be non-negative.\n",
      "     |      scale : float or array_like of floats, optional\n",
      "     |          The scale of the gamma distribution. Must be non-negative.\n",
      "     |          Default is equal to 1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``shape`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(shape, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized gamma distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.gamma : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.gamma: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Gamma distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n",
      "     |      \n",
      "     |      where :math:`k` is the shape and :math:`\\theta` the scale,\n",
      "     |      and :math:`\\Gamma` is the Gamma function.\n",
      "     |      \n",
      "     |      The Gamma distribution is often used to model the times to failure of\n",
      "     |      electronic components, and arises naturally in processes for which the\n",
      "     |      waiting times between Poisson distributed events are relevant.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n",
      "     |             Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/GammaDistribution.html\n",
      "     |      .. [2] Wikipedia, \"Gamma distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Gamma_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> shape, scale = 2., 2.  # mean=4, std=2*sqrt(2)\n",
      "     |      >>> s = np.random.gamma(shape, scale, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> import scipy.special as sps  # doctest: +SKIP\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 50, density=True)\n",
      "     |      >>> y = bins**(shape-1)*(np.exp(-bins/scale) /  # doctest: +SKIP\n",
      "     |      ...                      (sps.gamma(shape)*scale**shape))\n",
      "     |      >>> plt.plot(bins, y, linewidth=2, color='r')  # doctest: +SKIP\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  geometric(...)\n",
      "     |      geometric(p, size=None)\n",
      "     |      \n",
      "     |      Draw samples from the geometric distribution.\n",
      "     |      \n",
      "     |      Bernoulli trials are experiments with one of two outcomes:\n",
      "     |      success or failure (an example of such an experiment is flipping\n",
      "     |      a coin).  The geometric distribution models the number of trials\n",
      "     |      that must be run in order to achieve success.  It is therefore\n",
      "     |      supported on the positive integers, ``k = 1, 2, ...``.\n",
      "     |      \n",
      "     |      The probability mass function of the geometric distribution is\n",
      "     |      \n",
      "     |      .. math:: f(k) = (1 - p)^{k - 1} p\n",
      "     |      \n",
      "     |      where `p` is the probability of success of an individual trial.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``geometric`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      p : float or array_like of floats\n",
      "     |          The probability of success of an individual trial.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``p`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(p).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized geometric distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.geometric: which should be used for new code.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw ten thousand values from the geometric distribution,\n",
      "     |      with the probability of an individual success equal to 0.35:\n",
      "     |      \n",
      "     |      >>> z = np.random.geometric(p=0.35, size=10000)\n",
      "     |      \n",
      "     |      How many trials succeeded after a single run?\n",
      "     |      \n",
      "     |      >>> (z == 1).sum() / 10000.\n",
      "     |      0.34889999999999999 #random\n",
      "     |  \n",
      "     |  get_state(...)\n",
      "     |      get_state()\n",
      "     |      \n",
      "     |      Return a tuple representing the internal state of the generator.\n",
      "     |      \n",
      "     |      For more details, see `set_state`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      legacy : bool, optional\n",
      "     |          Flag indicating to return a legacy tuple state when the BitGenerator\n",
      "     |          is MT19937, instead of a dict.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : {tuple(str, ndarray of 624 uints, int, int, float), dict}\n",
      "     |          The returned tuple has the following items:\n",
      "     |      \n",
      "     |          1. the string 'MT19937'.\n",
      "     |          2. a 1-D array of 624 unsigned integer keys.\n",
      "     |          3. an integer ``pos``.\n",
      "     |          4. an integer ``has_gauss``.\n",
      "     |          5. a float ``cached_gaussian``.\n",
      "     |      \n",
      "     |          If `legacy` is False, or the BitGenerator is not MT19937, then\n",
      "     |          state is returned as a dictionary.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      set_state\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      `set_state` and `get_state` are not needed to work with any of the\n",
      "     |      random distributions in NumPy. If the internal state is manually altered,\n",
      "     |      the user should know exactly what he/she is doing.\n",
      "     |  \n",
      "     |  gumbel(...)\n",
      "     |      gumbel(loc=0.0, scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Gumbel distribution.\n",
      "     |      \n",
      "     |      Draw samples from a Gumbel distribution with specified location and\n",
      "     |      scale.  For more information on the Gumbel distribution, see\n",
      "     |      Notes and References below.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``gumbel`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      loc : float or array_like of floats, optional\n",
      "     |          The location of the mode of the distribution. Default is 0.\n",
      "     |      scale : float or array_like of floats, optional\n",
      "     |          The scale parameter of the distribution. Default is 1. Must be non-\n",
      "     |          negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Gumbel distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.gumbel_l\n",
      "     |      scipy.stats.gumbel_r\n",
      "     |      scipy.stats.genextreme\n",
      "     |      weibull\n",
      "     |      Generator.gumbel: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The Gumbel (or Smallest Extreme Value (SEV) or the Smallest Extreme\n",
      "     |      Value Type I) distribution is one of a class of Generalized Extreme\n",
      "     |      Value (GEV) distributions used in modeling extreme value problems.\n",
      "     |      The Gumbel is a special case of the Extreme Value Type I distribution\n",
      "     |      for maximums from distributions with \"exponential-like\" tails.\n",
      "     |      \n",
      "     |      The probability density for the Gumbel distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{e^{-(x - \\mu)/ \\beta}}{\\beta} e^{ -e^{-(x - \\mu)/\n",
      "     |                \\beta}},\n",
      "     |      \n",
      "     |      where :math:`\\mu` is the mode, a location parameter, and\n",
      "     |      :math:`\\beta` is the scale parameter.\n",
      "     |      \n",
      "     |      The Gumbel (named for German mathematician Emil Julius Gumbel) was used\n",
      "     |      very early in the hydrology literature, for modeling the occurrence of\n",
      "     |      flood events. It is also used for modeling maximum wind speed and\n",
      "     |      rainfall rates.  It is a \"fat-tailed\" distribution - the probability of\n",
      "     |      an event in the tail of the distribution is larger than if one used a\n",
      "     |      Gaussian, hence the surprisingly frequent occurrence of 100-year\n",
      "     |      floods. Floods were initially modeled as a Gaussian process, which\n",
      "     |      underestimated the frequency of extreme events.\n",
      "     |      \n",
      "     |      It is one of a class of extreme value distributions, the Generalized\n",
      "     |      Extreme Value (GEV) distributions, which also includes the Weibull and\n",
      "     |      Frechet.\n",
      "     |      \n",
      "     |      The function has a mean of :math:`\\mu + 0.57721\\beta` and a variance\n",
      "     |      of :math:`\\frac{\\pi^2}{6}\\beta^2`.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Gumbel, E. J., \"Statistics of Extremes,\"\n",
      "     |             New York: Columbia University Press, 1958.\n",
      "     |      .. [2] Reiss, R.-D. and Thomas, M., \"Statistical Analysis of Extreme\n",
      "     |             Values from Insurance, Finance, Hydrology and Other Fields,\"\n",
      "     |             Basel: Birkhauser Verlag, 2001.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> mu, beta = 0, 0.1 # location and scale\n",
      "     |      >>> s = np.random.gumbel(mu, beta, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 30, density=True)\n",
      "     |      >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n",
      "     |      ...          * np.exp( -np.exp( -(bins - mu) /beta) ),\n",
      "     |      ...          linewidth=2, color='r')\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Show how an extreme value distribution can arise from a Gaussian process\n",
      "     |      and compare to a Gaussian:\n",
      "     |      \n",
      "     |      >>> means = []\n",
      "     |      >>> maxima = []\n",
      "     |      >>> for i in range(0,1000) :\n",
      "     |      ...    a = np.random.normal(mu, beta, 1000)\n",
      "     |      ...    means.append(a.mean())\n",
      "     |      ...    maxima.append(a.max())\n",
      "     |      >>> count, bins, ignored = plt.hist(maxima, 30, density=True)\n",
      "     |      >>> beta = np.std(maxima) * np.sqrt(6) / np.pi\n",
      "     |      >>> mu = np.mean(maxima) - 0.57721*beta\n",
      "     |      >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n",
      "     |      ...          * np.exp(-np.exp(-(bins - mu)/beta)),\n",
      "     |      ...          linewidth=2, color='r')\n",
      "     |      >>> plt.plot(bins, 1/(beta * np.sqrt(2 * np.pi))\n",
      "     |      ...          * np.exp(-(bins - mu)**2 / (2 * beta**2)),\n",
      "     |      ...          linewidth=2, color='g')\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  hypergeometric(...)\n",
      "     |      hypergeometric(ngood, nbad, nsample, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Hypergeometric distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a hypergeometric distribution with specified\n",
      "     |      parameters, `ngood` (ways to make a good selection), `nbad` (ways to make\n",
      "     |      a bad selection), and `nsample` (number of items sampled, which is less\n",
      "     |      than or equal to the sum ``ngood + nbad``).\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``hypergeometric`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      ngood : int or array_like of ints\n",
      "     |          Number of ways to make a good selection.  Must be nonnegative.\n",
      "     |      nbad : int or array_like of ints\n",
      "     |          Number of ways to make a bad selection.  Must be nonnegative.\n",
      "     |      nsample : int or array_like of ints\n",
      "     |          Number of items sampled.  Must be at least 1 and at most\n",
      "     |          ``ngood + nbad``.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if `ngood`, `nbad`, and `nsample`\n",
      "     |          are all scalars.  Otherwise, ``np.broadcast(ngood, nbad, nsample).size``\n",
      "     |          samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized hypergeometric distribution. Each\n",
      "     |          sample is the number of good items within a randomly selected subset of\n",
      "     |          size `nsample` taken from a set of `ngood` good items and `nbad` bad items.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.hypergeom : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.hypergeometric: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Hypergeometric distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x) = \\frac{\\binom{g}{x}\\binom{b}{n-x}}{\\binom{g+b}{n}},\n",
      "     |      \n",
      "     |      where :math:`0 \\le x \\le n` and :math:`n-b \\le x \\le g`\n",
      "     |      \n",
      "     |      for P(x) the probability of ``x`` good results in the drawn sample,\n",
      "     |      g = `ngood`, b = `nbad`, and n = `nsample`.\n",
      "     |      \n",
      "     |      Consider an urn with black and white marbles in it, `ngood` of them\n",
      "     |      are black and `nbad` are white. If you draw `nsample` balls without\n",
      "     |      replacement, then the hypergeometric distribution describes the\n",
      "     |      distribution of black balls in the drawn sample.\n",
      "     |      \n",
      "     |      Note that this distribution is very similar to the binomial\n",
      "     |      distribution, except that in this case, samples are drawn without\n",
      "     |      replacement, whereas in the Binomial case samples are drawn with\n",
      "     |      replacement (or the sample space is infinite). As the sample space\n",
      "     |      becomes large, this distribution approaches the binomial.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n",
      "     |             and Quigley, 1972.\n",
      "     |      .. [2] Weisstein, Eric W. \"Hypergeometric Distribution.\" From\n",
      "     |             MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/HypergeometricDistribution.html\n",
      "     |      .. [3] Wikipedia, \"Hypergeometric distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Hypergeometric_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> ngood, nbad, nsamp = 100, 2, 10\n",
      "     |      # number of good, number of bad, and number of samples\n",
      "     |      >>> s = np.random.hypergeometric(ngood, nbad, nsamp, 1000)\n",
      "     |      >>> from matplotlib.pyplot import hist\n",
      "     |      >>> hist(s)\n",
      "     |      #   note that it is very unlikely to grab both bad items\n",
      "     |      \n",
      "     |      Suppose you have an urn with 15 white and 15 black marbles.\n",
      "     |      If you pull 15 marbles at random, how likely is it that\n",
      "     |      12 or more of them are one color?\n",
      "     |      \n",
      "     |      >>> s = np.random.hypergeometric(15, 15, 15, 100000)\n",
      "     |      >>> sum(s>=12)/100000. + sum(s<=3)/100000.\n",
      "     |      #   answer = 0.003 ... pretty unlikely!\n",
      "     |  \n",
      "     |  laplace(...)\n",
      "     |      laplace(loc=0.0, scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from the Laplace or double exponential distribution with\n",
      "     |      specified location (or mean) and scale (decay).\n",
      "     |      \n",
      "     |      The Laplace distribution is similar to the Gaussian/normal distribution,\n",
      "     |      but is sharper at the peak and has fatter tails. It represents the\n",
      "     |      difference between two independent, identically distributed exponential\n",
      "     |      random variables.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``laplace`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      loc : float or array_like of floats, optional\n",
      "     |          The position, :math:`\\mu`, of the distribution peak. Default is 0.\n",
      "     |      scale : float or array_like of floats, optional\n",
      "     |          :math:`\\lambda`, the exponential decay. Default is 1. Must be non-\n",
      "     |          negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Laplace distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.laplace: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      It has the probability density function\n",
      "     |      \n",
      "     |      .. math:: f(x; \\mu, \\lambda) = \\frac{1}{2\\lambda}\n",
      "     |                                     \\exp\\left(-\\frac{|x - \\mu|}{\\lambda}\\right).\n",
      "     |      \n",
      "     |      The first law of Laplace, from 1774, states that the frequency\n",
      "     |      of an error can be expressed as an exponential function of the\n",
      "     |      absolute magnitude of the error, which leads to the Laplace\n",
      "     |      distribution. For many problems in economics and health\n",
      "     |      sciences, this distribution seems to model the data better\n",
      "     |      than the standard Gaussian distribution.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n",
      "     |             Mathematical Functions with Formulas, Graphs, and Mathematical\n",
      "     |             Tables, 9th printing,\" New York: Dover, 1972.\n",
      "     |      .. [2] Kotz, Samuel, et. al. \"The Laplace Distribution and\n",
      "     |             Generalizations, \" Birkhauser, 2001.\n",
      "     |      .. [3] Weisstein, Eric W. \"Laplace Distribution.\"\n",
      "     |             From MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/LaplaceDistribution.html\n",
      "     |      .. [4] Wikipedia, \"Laplace distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Laplace_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution\n",
      "     |      \n",
      "     |      >>> loc, scale = 0., 1.\n",
      "     |      >>> s = np.random.laplace(loc, scale, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 30, density=True)\n",
      "     |      >>> x = np.arange(-8., 8., .01)\n",
      "     |      >>> pdf = np.exp(-abs(x-loc)/scale)/(2.*scale)\n",
      "     |      >>> plt.plot(x, pdf)\n",
      "     |      \n",
      "     |      Plot Gaussian for comparison:\n",
      "     |      \n",
      "     |      >>> g = (1/(scale * np.sqrt(2 * np.pi)) *\n",
      "     |      ...      np.exp(-(x - loc)**2 / (2 * scale**2)))\n",
      "     |      >>> plt.plot(x,g)\n",
      "     |  \n",
      "     |  logistic(...)\n",
      "     |      logistic(loc=0.0, scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a logistic distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a logistic distribution with specified\n",
      "     |      parameters, loc (location or mean, also median), and scale (>0).\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``logistic`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      loc : float or array_like of floats, optional\n",
      "     |          Parameter of the distribution. Default is 0.\n",
      "     |      scale : float or array_like of floats, optional\n",
      "     |          Parameter of the distribution. Must be non-negative.\n",
      "     |          Default is 1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized logistic distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.logistic : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.logistic: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Logistic distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x) = P(x) = \\frac{e^{-(x-\\mu)/s}}{s(1+e^{-(x-\\mu)/s})^2},\n",
      "     |      \n",
      "     |      where :math:`\\mu` = location and :math:`s` = scale.\n",
      "     |      \n",
      "     |      The Logistic distribution is used in Extreme Value problems where it\n",
      "     |      can act as a mixture of Gumbel distributions, in Epidemiology, and by\n",
      "     |      the World Chess Federation (FIDE) where it is used in the Elo ranking\n",
      "     |      system, assuming the performance of each player is a logistically\n",
      "     |      distributed random variable.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Reiss, R.-D. and Thomas M. (2001), \"Statistical Analysis of\n",
      "     |             Extreme Values, from Insurance, Finance, Hydrology and Other\n",
      "     |             Fields,\" Birkhauser Verlag, Basel, pp 132-133.\n",
      "     |      .. [2] Weisstein, Eric W. \"Logistic Distribution.\" From\n",
      "     |             MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/LogisticDistribution.html\n",
      "     |      .. [3] Wikipedia, \"Logistic-distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Logistic_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> loc, scale = 10, 1\n",
      "     |      >>> s = np.random.logistic(loc, scale, 10000)\n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, bins=50)\n",
      "     |      \n",
      "     |      #   plot against distribution\n",
      "     |      \n",
      "     |      >>> def logist(x, loc, scale):\n",
      "     |      ...     return np.exp((loc-x)/scale)/(scale*(1+np.exp((loc-x)/scale))**2)\n",
      "     |      >>> lgst_val = logist(bins, loc, scale)\n",
      "     |      >>> plt.plot(bins, lgst_val * count.max() / lgst_val.max())\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  lognormal(...)\n",
      "     |      lognormal(mean=0.0, sigma=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a log-normal distribution.\n",
      "     |      \n",
      "     |      Draw samples from a log-normal distribution with specified mean,\n",
      "     |      standard deviation, and array shape.  Note that the mean and standard\n",
      "     |      deviation are not the values for the distribution itself, but of the\n",
      "     |      underlying normal distribution it is derived from.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``lognormal`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      mean : float or array_like of floats, optional\n",
      "     |          Mean value of the underlying normal distribution. Default is 0.\n",
      "     |      sigma : float or array_like of floats, optional\n",
      "     |          Standard deviation of the underlying normal distribution. Must be\n",
      "     |          non-negative. Default is 1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``mean`` and ``sigma`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(mean, sigma).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized log-normal distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.lognorm : probability density function, distribution,\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.lognormal: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      A variable `x` has a log-normal distribution if `log(x)` is normally\n",
      "     |      distributed.  The probability density function for the log-normal\n",
      "     |      distribution is:\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{1}{\\sigma x \\sqrt{2\\pi}}\n",
      "     |                       e^{(-\\frac{(ln(x)-\\mu)^2}{2\\sigma^2})}\n",
      "     |      \n",
      "     |      where :math:`\\mu` is the mean and :math:`\\sigma` is the standard\n",
      "     |      deviation of the normally distributed logarithm of the variable.\n",
      "     |      A log-normal distribution results if a random variable is the *product*\n",
      "     |      of a large number of independent, identically-distributed variables in\n",
      "     |      the same way that a normal distribution results if the variable is the\n",
      "     |      *sum* of a large number of independent, identically-distributed\n",
      "     |      variables.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Limpert, E., Stahel, W. A., and Abbt, M., \"Log-normal\n",
      "     |             Distributions across the Sciences: Keys and Clues,\"\n",
      "     |             BioScience, Vol. 51, No. 5, May, 2001.\n",
      "     |             https://stat.ethz.ch/~stahel/lognormal/bioscience.pdf\n",
      "     |      .. [2] Reiss, R.D. and Thomas, M., \"Statistical Analysis of Extreme\n",
      "     |             Values,\" Basel: Birkhauser Verlag, 2001, pp. 31-32.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> mu, sigma = 3., 1. # mean and standard deviation\n",
      "     |      >>> s = np.random.lognormal(mu, sigma, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 100, density=True, align='mid')\n",
      "     |      \n",
      "     |      >>> x = np.linspace(min(bins), max(bins), 10000)\n",
      "     |      >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n",
      "     |      ...        / (x * sigma * np.sqrt(2 * np.pi)))\n",
      "     |      \n",
      "     |      >>> plt.plot(x, pdf, linewidth=2, color='r')\n",
      "     |      >>> plt.axis('tight')\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Demonstrate that taking the products of random samples from a uniform\n",
      "     |      distribution can be fit well by a log-normal probability density\n",
      "     |      function.\n",
      "     |      \n",
      "     |      >>> # Generate a thousand samples: each is the product of 100 random\n",
      "     |      >>> # values, drawn from a normal distribution.\n",
      "     |      >>> b = []\n",
      "     |      >>> for i in range(1000):\n",
      "     |      ...    a = 10. + np.random.standard_normal(100)\n",
      "     |      ...    b.append(np.product(a))\n",
      "     |      \n",
      "     |      >>> b = np.array(b) / np.min(b) # scale values to be positive\n",
      "     |      >>> count, bins, ignored = plt.hist(b, 100, density=True, align='mid')\n",
      "     |      >>> sigma = np.std(np.log(b))\n",
      "     |      >>> mu = np.mean(np.log(b))\n",
      "     |      \n",
      "     |      >>> x = np.linspace(min(bins), max(bins), 10000)\n",
      "     |      >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n",
      "     |      ...        / (x * sigma * np.sqrt(2 * np.pi)))\n",
      "     |      \n",
      "     |      >>> plt.plot(x, pdf, color='r', linewidth=2)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  logseries(...)\n",
      "     |      logseries(p, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a logarithmic series distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a log series distribution with specified\n",
      "     |      shape parameter, 0 < ``p`` < 1.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``logseries`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      p : float or array_like of floats\n",
      "     |          Shape parameter for the distribution.  Must be in the range (0, 1).\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``p`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(p).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized logarithmic series distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.logser : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.logseries: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Log Series distribution is\n",
      "     |      \n",
      "     |      .. math:: P(k) = \\frac{-p^k}{k \\ln(1-p)},\n",
      "     |      \n",
      "     |      where p = probability.\n",
      "     |      \n",
      "     |      The log series distribution is frequently used to represent species\n",
      "     |      richness and occurrence, first proposed by Fisher, Corbet, and\n",
      "     |      Williams in 1943 [2].  It may also be used to model the numbers of\n",
      "     |      occupants seen in cars [3].\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Buzas, Martin A.; Culver, Stephen J.,  Understanding regional\n",
      "     |             species diversity through the log series distribution of\n",
      "     |             occurrences: BIODIVERSITY RESEARCH Diversity & Distributions,\n",
      "     |             Volume 5, Number 5, September 1999 , pp. 187-195(9).\n",
      "     |      .. [2] Fisher, R.A,, A.S. Corbet, and C.B. Williams. 1943. The\n",
      "     |             relation between the number of species and the number of\n",
      "     |             individuals in a random sample of an animal population.\n",
      "     |             Journal of Animal Ecology, 12:42-58.\n",
      "     |      .. [3] D. J. Hand, F. Daly, D. Lunn, E. Ostrowski, A Handbook of Small\n",
      "     |             Data Sets, CRC Press, 1994.\n",
      "     |      .. [4] Wikipedia, \"Logarithmic distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Logarithmic_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> a = .6\n",
      "     |      >>> s = np.random.logseries(a, 10000)\n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s)\n",
      "     |      \n",
      "     |      #   plot against distribution\n",
      "     |      \n",
      "     |      >>> def logseries(k, p):\n",
      "     |      ...     return -p**k/(k*np.log(1-p))\n",
      "     |      >>> plt.plot(bins, logseries(bins, a)*count.max()/\n",
      "     |      ...          logseries(bins, a).max(), 'r')\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  multinomial(...)\n",
      "     |      multinomial(n, pvals, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a multinomial distribution.\n",
      "     |      \n",
      "     |      The multinomial distribution is a multivariate generalization of the\n",
      "     |      binomial distribution.  Take an experiment with one of ``p``\n",
      "     |      possible outcomes.  An example of such an experiment is throwing a dice,\n",
      "     |      where the outcome can be 1 through 6.  Each sample drawn from the\n",
      "     |      distribution represents `n` such experiments.  Its values,\n",
      "     |      ``X_i = [X_0, X_1, ..., X_p]``, represent the number of times the\n",
      "     |      outcome was ``i``.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``multinomial`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      n : int\n",
      "     |          Number of experiments.\n",
      "     |      pvals : sequence of floats, length p\n",
      "     |          Probabilities of each of the ``p`` different outcomes.  These\n",
      "     |          must sum to 1 (however, the last element is always assumed to\n",
      "     |          account for the remaining probability, as long as\n",
      "     |          ``sum(pvals[:-1]) <= 1)``.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray\n",
      "     |          The drawn samples, of shape *size*, if that was provided.  If not,\n",
      "     |          the shape is ``(N,)``.\n",
      "     |      \n",
      "     |          In other words, each entry ``out[i,j,...,:]`` is an N-dimensional\n",
      "     |          value drawn from the distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.multinomial: which should be used for new code.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Throw a dice 20 times:\n",
      "     |      \n",
      "     |      >>> np.random.multinomial(20, [1/6.]*6, size=1)\n",
      "     |      array([[4, 1, 7, 5, 2, 1]]) # random\n",
      "     |      \n",
      "     |      It landed 4 times on 1, once on 2, etc.\n",
      "     |      \n",
      "     |      Now, throw the dice 20 times, and 20 times again:\n",
      "     |      \n",
      "     |      >>> np.random.multinomial(20, [1/6.]*6, size=2)\n",
      "     |      array([[3, 4, 3, 3, 4, 3], # random\n",
      "     |             [2, 4, 3, 4, 0, 7]])\n",
      "     |      \n",
      "     |      For the first run, we threw 3 times 1, 4 times 2, etc.  For the second,\n",
      "     |      we threw 2 times 1, 4 times 2, etc.\n",
      "     |      \n",
      "     |      A loaded die is more likely to land on number 6:\n",
      "     |      \n",
      "     |      >>> np.random.multinomial(100, [1/7.]*5 + [2/7.])\n",
      "     |      array([11, 16, 14, 17, 16, 26]) # random\n",
      "     |      \n",
      "     |      The probability inputs should be normalized. As an implementation\n",
      "     |      detail, the value of the last entry is ignored and assumed to take\n",
      "     |      up any leftover probability mass, but this should not be relied on.\n",
      "     |      A biased coin which has twice as much weight on one side as on the\n",
      "     |      other should be sampled like so:\n",
      "     |      \n",
      "     |      >>> np.random.multinomial(100, [1.0 / 3, 2.0 / 3])  # RIGHT\n",
      "     |      array([38, 62]) # random\n",
      "     |      \n",
      "     |      not like:\n",
      "     |      \n",
      "     |      >>> np.random.multinomial(100, [1.0, 2.0])  # WRONG\n",
      "     |      Traceback (most recent call last):\n",
      "     |      ValueError: pvals < 0, pvals > 1 or pvals contains NaNs\n",
      "     |  \n",
      "     |  multivariate_normal(...)\n",
      "     |      multivariate_normal(mean, cov, size=None, check_valid='warn', tol=1e-8)\n",
      "     |      \n",
      "     |      Draw random samples from a multivariate normal distribution.\n",
      "     |      \n",
      "     |      The multivariate normal, multinormal or Gaussian distribution is a\n",
      "     |      generalization of the one-dimensional normal distribution to higher\n",
      "     |      dimensions.  Such a distribution is specified by its mean and\n",
      "     |      covariance matrix.  These parameters are analogous to the mean\n",
      "     |      (average or \"center\") and variance (standard deviation, or \"width,\"\n",
      "     |      squared) of the one-dimensional normal distribution.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``multivariate_normal`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      mean : 1-D array_like, of length N\n",
      "     |          Mean of the N-dimensional distribution.\n",
      "     |      cov : 2-D array_like, of shape (N, N)\n",
      "     |          Covariance matrix of the distribution. It must be symmetric and\n",
      "     |          positive-semidefinite for proper sampling.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Given a shape of, for example, ``(m,n,k)``, ``m*n*k`` samples are\n",
      "     |          generated, and packed in an `m`-by-`n`-by-`k` arrangement.  Because\n",
      "     |          each sample is `N`-dimensional, the output shape is ``(m,n,k,N)``.\n",
      "     |          If no shape is specified, a single (`N`-D) sample is returned.\n",
      "     |      check_valid : { 'warn', 'raise', 'ignore' }, optional\n",
      "     |          Behavior when the covariance matrix is not positive semidefinite.\n",
      "     |      tol : float, optional\n",
      "     |          Tolerance when checking the singular values in covariance matrix.\n",
      "     |          cov is cast to double before the check.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray\n",
      "     |          The drawn samples, of shape *size*, if that was provided.  If not,\n",
      "     |          the shape is ``(N,)``.\n",
      "     |      \n",
      "     |          In other words, each entry ``out[i,j,...,:]`` is an N-dimensional\n",
      "     |          value drawn from the distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.multivariate_normal: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The mean is a coordinate in N-dimensional space, which represents the\n",
      "     |      location where samples are most likely to be generated.  This is\n",
      "     |      analogous to the peak of the bell curve for the one-dimensional or\n",
      "     |      univariate normal distribution.\n",
      "     |      \n",
      "     |      Covariance indicates the level to which two variables vary together.\n",
      "     |      From the multivariate normal distribution, we draw N-dimensional\n",
      "     |      samples, :math:`X = [x_1, x_2, ... x_N]`.  The covariance matrix\n",
      "     |      element :math:`C_{ij}` is the covariance of :math:`x_i` and :math:`x_j`.\n",
      "     |      The element :math:`C_{ii}` is the variance of :math:`x_i` (i.e. its\n",
      "     |      \"spread\").\n",
      "     |      \n",
      "     |      Instead of specifying the full covariance matrix, popular\n",
      "     |      approximations include:\n",
      "     |      \n",
      "     |        - Spherical covariance (`cov` is a multiple of the identity matrix)\n",
      "     |        - Diagonal covariance (`cov` has non-negative elements, and only on\n",
      "     |          the diagonal)\n",
      "     |      \n",
      "     |      This geometrical property can be seen in two dimensions by plotting\n",
      "     |      generated data-points:\n",
      "     |      \n",
      "     |      >>> mean = [0, 0]\n",
      "     |      >>> cov = [[1, 0], [0, 100]]  # diagonal covariance\n",
      "     |      \n",
      "     |      Diagonal covariance means that points are oriented along x or y-axis:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> x, y = np.random.multivariate_normal(mean, cov, 5000).T\n",
      "     |      >>> plt.plot(x, y, 'x')\n",
      "     |      >>> plt.axis('equal')\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Note that the covariance matrix must be positive semidefinite (a.k.a.\n",
      "     |      nonnegative-definite). Otherwise, the behavior of this method is\n",
      "     |      undefined and backwards compatibility is not guaranteed.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Papoulis, A., \"Probability, Random Variables, and Stochastic\n",
      "     |             Processes,\" 3rd ed., New York: McGraw-Hill, 1991.\n",
      "     |      .. [2] Duda, R. O., Hart, P. E., and Stork, D. G., \"Pattern\n",
      "     |             Classification,\" 2nd ed., New York: Wiley, 2001.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> mean = (1, 2)\n",
      "     |      >>> cov = [[1, 0], [0, 1]]\n",
      "     |      >>> x = np.random.multivariate_normal(mean, cov, (3, 3))\n",
      "     |      >>> x.shape\n",
      "     |      (3, 3, 2)\n",
      "     |      \n",
      "     |      The following is probably true, given that 0.6 is roughly twice the\n",
      "     |      standard deviation:\n",
      "     |      \n",
      "     |      >>> list((x[0,0,:] - mean) < 0.6)\n",
      "     |      [True, True] # random\n",
      "     |  \n",
      "     |  negative_binomial(...)\n",
      "     |      negative_binomial(n, p, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a negative binomial distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a negative binomial distribution with specified\n",
      "     |      parameters, `n` successes and `p` probability of success where `n`\n",
      "     |      is > 0 and `p` is in the interval [0, 1].\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``negative_binomial`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      n : float or array_like of floats\n",
      "     |          Parameter of the distribution, > 0.\n",
      "     |      p : float or array_like of floats\n",
      "     |          Parameter of the distribution, >= 0 and <=1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``n`` and ``p`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized negative binomial distribution,\n",
      "     |          where each sample is equal to N, the number of failures that\n",
      "     |          occurred before a total of n successes was reached.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.negative_binomial: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability mass function of the negative binomial distribution is\n",
      "     |      \n",
      "     |      .. math:: P(N;n,p) = \\frac{\\Gamma(N+n)}{N!\\Gamma(n)}p^{n}(1-p)^{N},\n",
      "     |      \n",
      "     |      where :math:`n` is the number of successes, :math:`p` is the\n",
      "     |      probability of success, :math:`N+n` is the number of trials, and\n",
      "     |      :math:`\\Gamma` is the gamma function. When :math:`n` is an integer,\n",
      "     |      :math:`\\frac{\\Gamma(N+n)}{N!\\Gamma(n)} = \\binom{N+n-1}{N}`, which is\n",
      "     |      the more common form of this term in the the pmf. The negative\n",
      "     |      binomial distribution gives the probability of N failures given n\n",
      "     |      successes, with a success on the last trial.\n",
      "     |      \n",
      "     |      If one throws a die repeatedly until the third time a \"1\" appears,\n",
      "     |      then the probability distribution of the number of non-\"1\"s that\n",
      "     |      appear before the third \"1\" is a negative binomial distribution.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Weisstein, Eric W. \"Negative Binomial Distribution.\" From\n",
      "     |             MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/NegativeBinomialDistribution.html\n",
      "     |      .. [2] Wikipedia, \"Negative binomial distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Negative_binomial_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      A real world example. A company drills wild-cat oil\n",
      "     |      exploration wells, each with an estimated probability of\n",
      "     |      success of 0.1.  What is the probability of having one success\n",
      "     |      for each successive well, that is what is the probability of a\n",
      "     |      single success after drilling 5 wells, after 6 wells, etc.?\n",
      "     |      \n",
      "     |      >>> s = np.random.negative_binomial(1, 0.1, 100000)\n",
      "     |      >>> for i in range(1, 11): # doctest: +SKIP\n",
      "     |      ...    probability = sum(s<i) / 100000.\n",
      "     |      ...    print(i, \"wells drilled, probability of one success =\", probability)\n",
      "     |  \n",
      "     |  noncentral_chisquare(...)\n",
      "     |      noncentral_chisquare(df, nonc, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a noncentral chi-square distribution.\n",
      "     |      \n",
      "     |      The noncentral :math:`\\chi^2` distribution is a generalization of\n",
      "     |      the :math:`\\chi^2` distribution.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``noncentral_chisquare`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      df : float or array_like of floats\n",
      "     |          Degrees of freedom, must be > 0.\n",
      "     |      \n",
      "     |          .. versionchanged:: 1.10.0\n",
      "     |             Earlier NumPy versions required dfnum > 1.\n",
      "     |      nonc : float or array_like of floats\n",
      "     |          Non-centrality, must be non-negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``df`` and ``nonc`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(df, nonc).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized noncentral chi-square distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.noncentral_chisquare: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the noncentral Chi-square\n",
      "     |      distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x;df,nonc) = \\sum^{\\infty}_{i=0}\n",
      "     |                             \\frac{e^{-nonc/2}(nonc/2)^{i}}{i!}\n",
      "     |                             P_{Y_{df+2i}}(x),\n",
      "     |      \n",
      "     |      where :math:`Y_{q}` is the Chi-square with q degrees of freedom.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Wikipedia, \"Noncentral chi-squared distribution\"\n",
      "     |             https://en.wikipedia.org/wiki/Noncentral_chi-squared_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw values from the distribution and plot the histogram\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> values = plt.hist(np.random.noncentral_chisquare(3, 20, 100000),\n",
      "     |      ...                   bins=200, density=True)\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Draw values from a noncentral chisquare with very small noncentrality,\n",
      "     |      and compare to a chisquare.\n",
      "     |      \n",
      "     |      >>> plt.figure()\n",
      "     |      >>> values = plt.hist(np.random.noncentral_chisquare(3, .0000001, 100000),\n",
      "     |      ...                   bins=np.arange(0., 25, .1), density=True)\n",
      "     |      >>> values2 = plt.hist(np.random.chisquare(3, 100000),\n",
      "     |      ...                    bins=np.arange(0., 25, .1), density=True)\n",
      "     |      >>> plt.plot(values[1][0:-1], values[0]-values2[0], 'ob')\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Demonstrate how large values of non-centrality lead to a more symmetric\n",
      "     |      distribution.\n",
      "     |      \n",
      "     |      >>> plt.figure()\n",
      "     |      >>> values = plt.hist(np.random.noncentral_chisquare(3, 20, 100000),\n",
      "     |      ...                   bins=200, density=True)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  noncentral_f(...)\n",
      "     |      noncentral_f(dfnum, dfden, nonc, size=None)\n",
      "     |      \n",
      "     |      Draw samples from the noncentral F distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from an F distribution with specified parameters,\n",
      "     |      `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n",
      "     |      freedom in denominator), where both parameters > 1.\n",
      "     |      `nonc` is the non-centrality parameter.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``noncentral_f`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      dfnum : float or array_like of floats\n",
      "     |          Numerator degrees of freedom, must be > 0.\n",
      "     |      \n",
      "     |          .. versionchanged:: 1.14.0\n",
      "     |             Earlier NumPy versions required dfnum > 1.\n",
      "     |      dfden : float or array_like of floats\n",
      "     |          Denominator degrees of freedom, must be > 0.\n",
      "     |      nonc : float or array_like of floats\n",
      "     |          Non-centrality parameter, the sum of the squares of the numerator\n",
      "     |          means, must be >= 0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``dfnum``, ``dfden``, and ``nonc``\n",
      "     |          are all scalars.  Otherwise, ``np.broadcast(dfnum, dfden, nonc).size``\n",
      "     |          samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized noncentral Fisher distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.noncentral_f: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      When calculating the power of an experiment (power = probability of\n",
      "     |      rejecting the null hypothesis when a specific alternative is true) the\n",
      "     |      non-central F statistic becomes important.  When the null hypothesis is\n",
      "     |      true, the F statistic follows a central F distribution. When the null\n",
      "     |      hypothesis is not true, then it follows a non-central F statistic.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Weisstein, Eric W. \"Noncentral F-Distribution.\"\n",
      "     |             From MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/NoncentralF-Distribution.html\n",
      "     |      .. [2] Wikipedia, \"Noncentral F-distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Noncentral_F-distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      In a study, testing for a specific alternative to the null hypothesis\n",
      "     |      requires use of the Noncentral F distribution. We need to calculate the\n",
      "     |      area in the tail of the distribution that exceeds the value of the F\n",
      "     |      distribution for the null hypothesis.  We'll plot the two probability\n",
      "     |      distributions for comparison.\n",
      "     |      \n",
      "     |      >>> dfnum = 3 # between group deg of freedom\n",
      "     |      >>> dfden = 20 # within groups degrees of freedom\n",
      "     |      >>> nonc = 3.0\n",
      "     |      >>> nc_vals = np.random.noncentral_f(dfnum, dfden, nonc, 1000000)\n",
      "     |      >>> NF = np.histogram(nc_vals, bins=50, density=True)\n",
      "     |      >>> c_vals = np.random.f(dfnum, dfden, 1000000)\n",
      "     |      >>> F = np.histogram(c_vals, bins=50, density=True)\n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> plt.plot(F[1][1:], F[0])\n",
      "     |      >>> plt.plot(NF[1][1:], NF[0])\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  normal(...)\n",
      "     |      normal(loc=0.0, scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw random samples from a normal (Gaussian) distribution.\n",
      "     |      \n",
      "     |      The probability density function of the normal distribution, first\n",
      "     |      derived by De Moivre and 200 years later by both Gauss and Laplace\n",
      "     |      independently [2]_, is often called the bell curve because of\n",
      "     |      its characteristic shape (see the example below).\n",
      "     |      \n",
      "     |      The normal distributions occurs often in nature.  For example, it\n",
      "     |      describes the commonly occurring distribution of samples influenced\n",
      "     |      by a large number of tiny, random disturbances, each with its own\n",
      "     |      unique distribution [2]_.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``normal`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      loc : float or array_like of floats\n",
      "     |          Mean (\"centre\") of the distribution.\n",
      "     |      scale : float or array_like of floats\n",
      "     |          Standard deviation (spread or \"width\") of the distribution. Must be\n",
      "     |          non-negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized normal distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.norm : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.normal: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Gaussian distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{1}{\\sqrt{ 2 \\pi \\sigma^2 }}\n",
      "     |                       e^{ - \\frac{ (x - \\mu)^2 } {2 \\sigma^2} },\n",
      "     |      \n",
      "     |      where :math:`\\mu` is the mean and :math:`\\sigma` the standard\n",
      "     |      deviation. The square of the standard deviation, :math:`\\sigma^2`,\n",
      "     |      is called the variance.\n",
      "     |      \n",
      "     |      The function has its peak at the mean, and its \"spread\" increases with\n",
      "     |      the standard deviation (the function reaches 0.607 times its maximum at\n",
      "     |      :math:`x + \\sigma` and :math:`x - \\sigma` [2]_).  This implies that\n",
      "     |      normal is more likely to return samples lying close to the mean, rather\n",
      "     |      than those far away.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Wikipedia, \"Normal distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Normal_distribution\n",
      "     |      .. [2] P. R. Peebles Jr., \"Central Limit Theorem\" in \"Probability,\n",
      "     |             Random Variables and Random Signal Principles\", 4th ed., 2001,\n",
      "     |             pp. 51, 51, 125.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> mu, sigma = 0, 0.1 # mean and standard deviation\n",
      "     |      >>> s = np.random.normal(mu, sigma, 1000)\n",
      "     |      \n",
      "     |      Verify the mean and the variance:\n",
      "     |      \n",
      "     |      >>> abs(mu - np.mean(s))\n",
      "     |      0.0  # may vary\n",
      "     |      \n",
      "     |      >>> abs(sigma - np.std(s, ddof=1))\n",
      "     |      0.1  # may vary\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 30, density=True)\n",
      "     |      >>> plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *\n",
      "     |      ...                np.exp( - (bins - mu)**2 / (2 * sigma**2) ),\n",
      "     |      ...          linewidth=2, color='r')\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Two-by-four array of samples from N(3, 6.25):\n",
      "     |      \n",
      "     |      >>> np.random.normal(3, 2.5, size=(2, 4))\n",
      "     |      array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random\n",
      "     |             [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]])  # random\n",
      "     |  \n",
      "     |  pareto(...)\n",
      "     |      pareto(a, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Pareto II or Lomax distribution with\n",
      "     |      specified shape.\n",
      "     |      \n",
      "     |      The Lomax or Pareto II distribution is a shifted Pareto\n",
      "     |      distribution. The classical Pareto distribution can be\n",
      "     |      obtained from the Lomax distribution by adding 1 and\n",
      "     |      multiplying by the scale parameter ``m`` (see Notes).  The\n",
      "     |      smallest value of the Lomax distribution is zero while for the\n",
      "     |      classical Pareto distribution it is ``mu``, where the standard\n",
      "     |      Pareto distribution has location ``mu = 1``.  Lomax can also\n",
      "     |      be considered as a simplified version of the Generalized\n",
      "     |      Pareto distribution (available in SciPy), with the scale set\n",
      "     |      to one and the location set to zero.\n",
      "     |      \n",
      "     |      The Pareto distribution must be greater than zero, and is\n",
      "     |      unbounded above.  It is also known as the \"80-20 rule\".  In\n",
      "     |      this distribution, 80 percent of the weights are in the lowest\n",
      "     |      20 percent of the range, while the other 20 percent fill the\n",
      "     |      remaining 80 percent of the range.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``pareto`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : float or array_like of floats\n",
      "     |          Shape of the distribution. Must be positive.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``a`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(a).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Pareto distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.lomax : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      scipy.stats.genpareto : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.pareto: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Pareto distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{am^a}{x^{a+1}}\n",
      "     |      \n",
      "     |      where :math:`a` is the shape and :math:`m` the scale.\n",
      "     |      \n",
      "     |      The Pareto distribution, named after the Italian economist\n",
      "     |      Vilfredo Pareto, is a power law probability distribution\n",
      "     |      useful in many real world problems.  Outside the field of\n",
      "     |      economics it is generally referred to as the Bradford\n",
      "     |      distribution. Pareto developed the distribution to describe\n",
      "     |      the distribution of wealth in an economy.  It has also found\n",
      "     |      use in insurance, web page access statistics, oil field sizes,\n",
      "     |      and many other problems, including the download frequency for\n",
      "     |      projects in Sourceforge [1]_.  It is one of the so-called\n",
      "     |      \"fat-tailed\" distributions.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Francis Hunt and Paul Johnson, On the Pareto Distribution of\n",
      "     |             Sourceforge projects.\n",
      "     |      .. [2] Pareto, V. (1896). Course of Political Economy. Lausanne.\n",
      "     |      .. [3] Reiss, R.D., Thomas, M.(2001), Statistical Analysis of Extreme\n",
      "     |             Values, Birkhauser Verlag, Basel, pp 23-30.\n",
      "     |      .. [4] Wikipedia, \"Pareto distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Pareto_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> a, m = 3., 2.  # shape and mode\n",
      "     |      >>> s = (np.random.pareto(a, 1000) + 1) * m\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with the probability\n",
      "     |      density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, _ = plt.hist(s, 100, density=True)\n",
      "     |      >>> fit = a*m**a / bins**(a+1)\n",
      "     |      >>> plt.plot(bins, max(count)*fit/max(fit), linewidth=2, color='r')\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  permutation(...)\n",
      "     |      permutation(x)\n",
      "     |      \n",
      "     |      Randomly permute a sequence, or return a permuted range.\n",
      "     |      \n",
      "     |      If `x` is a multi-dimensional array, it is only shuffled along its\n",
      "     |      first index.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``permutation`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      x : int or array_like\n",
      "     |          If `x` is an integer, randomly permute ``np.arange(x)``.\n",
      "     |          If `x` is an array, make a copy and shuffle the elements\n",
      "     |          randomly.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray\n",
      "     |          Permuted sequence or array range.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.permutation: which should be used for new code.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> np.random.permutation(10)\n",
      "     |      array([1, 7, 4, 3, 0, 9, 2, 5, 8, 6]) # random\n",
      "     |      \n",
      "     |      >>> np.random.permutation([1, 4, 9, 12, 15])\n",
      "     |      array([15,  1,  9,  4, 12]) # random\n",
      "     |      \n",
      "     |      >>> arr = np.arange(9).reshape((3, 3))\n",
      "     |      >>> np.random.permutation(arr)\n",
      "     |      array([[6, 7, 8], # random\n",
      "     |             [0, 1, 2],\n",
      "     |             [3, 4, 5]])\n",
      "     |  \n",
      "     |  poisson(...)\n",
      "     |      poisson(lam=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Poisson distribution.\n",
      "     |      \n",
      "     |      The Poisson distribution is the limit of the binomial distribution\n",
      "     |      for large N.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``poisson`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      lam : float or array_like of floats\n",
      "     |          Expectation of interval, must be >= 0. A sequence of expectation\n",
      "     |          intervals must be broadcastable over the requested size.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``lam`` is a scalar. Otherwise,\n",
      "     |          ``np.array(lam).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Poisson distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.poisson: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The Poisson distribution\n",
      "     |      \n",
      "     |      .. math:: f(k; \\lambda)=\\frac{\\lambda^k e^{-\\lambda}}{k!}\n",
      "     |      \n",
      "     |      For events with an expected separation :math:`\\lambda` the Poisson\n",
      "     |      distribution :math:`f(k; \\lambda)` describes the probability of\n",
      "     |      :math:`k` events occurring within the observed\n",
      "     |      interval :math:`\\lambda`.\n",
      "     |      \n",
      "     |      Because the output is limited to the range of the C int64 type, a\n",
      "     |      ValueError is raised when `lam` is within 10 sigma of the maximum\n",
      "     |      representable value.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Weisstein, Eric W. \"Poisson Distribution.\"\n",
      "     |             From MathWorld--A Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/PoissonDistribution.html\n",
      "     |      .. [2] Wikipedia, \"Poisson distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Poisson_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> import numpy as np\n",
      "     |      >>> s = np.random.poisson(5, 10000)\n",
      "     |      \n",
      "     |      Display histogram of the sample:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 14, density=True)\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Draw each 100 values for lambda 100 and 500:\n",
      "     |      \n",
      "     |      >>> s = np.random.poisson(lam=(100., 500.), size=(100, 2))\n",
      "     |  \n",
      "     |  power(...)\n",
      "     |      power(a, size=None)\n",
      "     |      \n",
      "     |      Draws samples in [0, 1] from a power distribution with positive\n",
      "     |      exponent a - 1.\n",
      "     |      \n",
      "     |      Also known as the power function distribution.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``power`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : float or array_like of floats\n",
      "     |          Parameter of the distribution. Must be non-negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``a`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(a).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized power distribution.\n",
      "     |      \n",
      "     |      Raises\n",
      "     |      ------\n",
      "     |      ValueError\n",
      "     |          If a < 1.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.power: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function is\n",
      "     |      \n",
      "     |      .. math:: P(x; a) = ax^{a-1}, 0 \\le x \\le 1, a>0.\n",
      "     |      \n",
      "     |      The power function distribution is just the inverse of the Pareto\n",
      "     |      distribution. It may also be seen as a special case of the Beta\n",
      "     |      distribution.\n",
      "     |      \n",
      "     |      It is used, for example, in modeling the over-reporting of insurance\n",
      "     |      claims.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Christian Kleiber, Samuel Kotz, \"Statistical size distributions\n",
      "     |             in economics and actuarial sciences\", Wiley, 2003.\n",
      "     |      .. [2] Heckert, N. A. and Filliben, James J. \"NIST Handbook 148:\n",
      "     |             Dataplot Reference Manual, Volume 2: Let Subcommands and Library\n",
      "     |             Functions\", National Institute of Standards and Technology\n",
      "     |             Handbook Series, June 2003.\n",
      "     |             https://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/powpdf.pdf\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> a = 5. # shape\n",
      "     |      >>> samples = 1000\n",
      "     |      >>> s = np.random.power(a, samples)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, bins=30)\n",
      "     |      >>> x = np.linspace(0, 1, 100)\n",
      "     |      >>> y = a*x**(a-1.)\n",
      "     |      >>> normed_y = samples*np.diff(bins)[0]*y\n",
      "     |      >>> plt.plot(x, normed_y)\n",
      "     |      >>> plt.show()\n",
      "     |      \n",
      "     |      Compare the power function distribution to the inverse of the Pareto.\n",
      "     |      \n",
      "     |      >>> from scipy import stats # doctest: +SKIP\n",
      "     |      >>> rvs = np.random.power(5, 1000000)\n",
      "     |      >>> rvsp = np.random.pareto(5, 1000000)\n",
      "     |      >>> xx = np.linspace(0,1,100)\n",
      "     |      >>> powpdf = stats.powerlaw.pdf(xx,5)  # doctest: +SKIP\n",
      "     |      \n",
      "     |      >>> plt.figure()\n",
      "     |      >>> plt.hist(rvs, bins=50, density=True)\n",
      "     |      >>> plt.plot(xx,powpdf,'r-')  # doctest: +SKIP\n",
      "     |      >>> plt.title('np.random.power(5)')\n",
      "     |      \n",
      "     |      >>> plt.figure()\n",
      "     |      >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n",
      "     |      >>> plt.plot(xx,powpdf,'r-')  # doctest: +SKIP\n",
      "     |      >>> plt.title('inverse of 1 + np.random.pareto(5)')\n",
      "     |      \n",
      "     |      >>> plt.figure()\n",
      "     |      >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n",
      "     |      >>> plt.plot(xx,powpdf,'r-')  # doctest: +SKIP\n",
      "     |      >>> plt.title('inverse of stats.pareto(5)')\n",
      "     |  \n",
      "     |  rand(...)\n",
      "     |      rand(d0, d1, ..., dn)\n",
      "     |      \n",
      "     |      Random values in a given shape.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          This is a convenience function for users porting code from Matlab,\n",
      "     |          and wraps `random_sample`. That function takes a\n",
      "     |          tuple to specify the size of the output, which is consistent with\n",
      "     |          other NumPy functions like `numpy.zeros` and `numpy.ones`.\n",
      "     |      \n",
      "     |      Create an array of the given shape and populate it with\n",
      "     |      random samples from a uniform distribution\n",
      "     |      over ``[0, 1)``.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      d0, d1, ..., dn : int, optional\n",
      "     |          The dimensions of the returned array, must be non-negative.\n",
      "     |          If no argument is given a single Python float is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray, shape ``(d0, d1, ..., dn)``\n",
      "     |          Random values.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      random\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> np.random.rand(3,2)\n",
      "     |      array([[ 0.14022471,  0.96360618],  #random\n",
      "     |             [ 0.37601032,  0.25528411],  #random\n",
      "     |             [ 0.49313049,  0.94909878]]) #random\n",
      "     |  \n",
      "     |  randint(...)\n",
      "     |      randint(low, high=None, size=None, dtype=int)\n",
      "     |      \n",
      "     |      Return random integers from `low` (inclusive) to `high` (exclusive).\n",
      "     |      \n",
      "     |      Return random integers from the \"discrete uniform\" distribution of\n",
      "     |      the specified dtype in the \"half-open\" interval [`low`, `high`). If\n",
      "     |      `high` is None (the default), then results are from [0, `low`).\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``integers`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      low : int or array-like of ints\n",
      "     |          Lowest (signed) integers to be drawn from the distribution (unless\n",
      "     |          ``high=None``, in which case this parameter is one above the\n",
      "     |          *highest* such integer).\n",
      "     |      high : int or array-like of ints, optional\n",
      "     |          If provided, one above the largest (signed) integer to be drawn\n",
      "     |          from the distribution (see above for behavior if ``high=None``).\n",
      "     |          If array-like, must contain integer values\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      dtype : dtype, optional\n",
      "     |          Desired dtype of the result. Byteorder must be native.\n",
      "     |          The default value is int.\n",
      "     |      \n",
      "     |          .. versionadded:: 1.11.0\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : int or ndarray of ints\n",
      "     |          `size`-shaped array of random integers from the appropriate\n",
      "     |          distribution, or a single such random int if `size` not provided.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      random_integers : similar to `randint`, only for the closed\n",
      "     |          interval [`low`, `high`], and 1 is the lowest value if `high` is\n",
      "     |          omitted.\n",
      "     |      Generator.integers: which should be used for new code.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> np.random.randint(2, size=10)\n",
      "     |      array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random\n",
      "     |      >>> np.random.randint(1, size=10)\n",
      "     |      array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n",
      "     |      \n",
      "     |      Generate a 2 x 4 array of ints between 0 and 4, inclusive:\n",
      "     |      \n",
      "     |      >>> np.random.randint(5, size=(2, 4))\n",
      "     |      array([[4, 0, 2, 1], # random\n",
      "     |             [3, 2, 2, 0]])\n",
      "     |      \n",
      "     |      Generate a 1 x 3 array with 3 different upper bounds\n",
      "     |      \n",
      "     |      >>> np.random.randint(1, [3, 5, 10])\n",
      "     |      array([2, 2, 9]) # random\n",
      "     |      \n",
      "     |      Generate a 1 by 3 array with 3 different lower bounds\n",
      "     |      \n",
      "     |      >>> np.random.randint([1, 5, 7], 10)\n",
      "     |      array([9, 8, 7]) # random\n",
      "     |      \n",
      "     |      Generate a 2 by 4 array using broadcasting with dtype of uint8\n",
      "     |      \n",
      "     |      >>> np.random.randint([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)\n",
      "     |      array([[ 8,  6,  9,  7], # random\n",
      "     |             [ 1, 16,  9, 12]], dtype=uint8)\n",
      "     |  \n",
      "     |  randn(...)\n",
      "     |      randn(d0, d1, ..., dn)\n",
      "     |      \n",
      "     |      Return a sample (or samples) from the \"standard normal\" distribution.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          This is a convenience function for users porting code from Matlab,\n",
      "     |          and wraps `standard_normal`. That function takes a\n",
      "     |          tuple to specify the size of the output, which is consistent with\n",
      "     |          other NumPy functions like `numpy.zeros` and `numpy.ones`.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``standard_normal`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      If positive int_like arguments are provided, `randn` generates an array\n",
      "     |      of shape ``(d0, d1, ..., dn)``, filled\n",
      "     |      with random floats sampled from a univariate \"normal\" (Gaussian)\n",
      "     |      distribution of mean 0 and variance 1. A single float randomly sampled\n",
      "     |      from the distribution is returned if no argument is provided.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      d0, d1, ..., dn : int, optional\n",
      "     |          The dimensions of the returned array, must be non-negative.\n",
      "     |          If no argument is given a single Python float is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      Z : ndarray or float\n",
      "     |          A ``(d0, d1, ..., dn)``-shaped array of floating-point samples from\n",
      "     |          the standard normal distribution, or a single such float if\n",
      "     |          no parameters were supplied.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      standard_normal : Similar, but takes a tuple as its argument.\n",
      "     |      normal : Also accepts mu and sigma arguments.\n",
      "     |      Generator.standard_normal: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      For random samples from :math:`N(\\mu, \\sigma^2)`, use:\n",
      "     |      \n",
      "     |      ``sigma * np.random.randn(...) + mu``\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> np.random.randn()\n",
      "     |      2.1923875335537315  # random\n",
      "     |      \n",
      "     |      Two-by-four array of samples from N(3, 6.25):\n",
      "     |      \n",
      "     |      >>> 3 + 2.5 * np.random.randn(2, 4)\n",
      "     |      array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random\n",
      "     |             [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]])  # random\n",
      "     |  \n",
      "     |  random(...)\n",
      "     |      random(size=None)\n",
      "     |      \n",
      "     |      Return random floats in the half-open interval [0.0, 1.0). Alias for\n",
      "     |      `random_sample` to ease forward-porting to the new random API.\n",
      "     |  \n",
      "     |  random_integers(...)\n",
      "     |      random_integers(low, high=None, size=None)\n",
      "     |      \n",
      "     |      Random integers of type `np.int_` between `low` and `high`, inclusive.\n",
      "     |      \n",
      "     |      Return random integers of type `np.int_` from the \"discrete uniform\"\n",
      "     |      distribution in the closed interval [`low`, `high`].  If `high` is\n",
      "     |      None (the default), then results are from [1, `low`]. The `np.int_`\n",
      "     |      type translates to the C long integer type and its precision\n",
      "     |      is platform dependent.\n",
      "     |      \n",
      "     |      This function has been deprecated. Use randint instead.\n",
      "     |      \n",
      "     |      .. deprecated:: 1.11.0\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      low : int\n",
      "     |          Lowest (signed) integer to be drawn from the distribution (unless\n",
      "     |          ``high=None``, in which case this parameter is the *highest* such\n",
      "     |          integer).\n",
      "     |      high : int, optional\n",
      "     |          If provided, the largest (signed) integer to be drawn from the\n",
      "     |          distribution (see above for behavior if ``high=None``).\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : int or ndarray of ints\n",
      "     |          `size`-shaped array of random integers from the appropriate\n",
      "     |          distribution, or a single such random int if `size` not provided.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      randint : Similar to `random_integers`, only for the half-open\n",
      "     |          interval [`low`, `high`), and 0 is the lowest value if `high` is\n",
      "     |          omitted.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      To sample from N evenly spaced floating-point numbers between a and b,\n",
      "     |      use::\n",
      "     |      \n",
      "     |        a + (b - a) * (np.random.random_integers(N) - 1) / (N - 1.)\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> np.random.random_integers(5)\n",
      "     |      4 # random\n",
      "     |      >>> type(np.random.random_integers(5))\n",
      "     |      <class 'numpy.int64'>\n",
      "     |      >>> np.random.random_integers(5, size=(3,2))\n",
      "     |      array([[5, 4], # random\n",
      "     |             [3, 3],\n",
      "     |             [4, 5]])\n",
      "     |      \n",
      "     |      Choose five random numbers from the set of five evenly-spaced\n",
      "     |      numbers between 0 and 2.5, inclusive (*i.e.*, from the set\n",
      "     |      :math:`{0, 5/8, 10/8, 15/8, 20/8}`):\n",
      "     |      \n",
      "     |      >>> 2.5 * (np.random.random_integers(5, size=(5,)) - 1) / 4.\n",
      "     |      array([ 0.625,  1.25 ,  0.625,  0.625,  2.5  ]) # random\n",
      "     |      \n",
      "     |      Roll two six sided dice 1000 times and sum the results:\n",
      "     |      \n",
      "     |      >>> d1 = np.random.random_integers(1, 6, 1000)\n",
      "     |      >>> d2 = np.random.random_integers(1, 6, 1000)\n",
      "     |      >>> dsums = d1 + d2\n",
      "     |      \n",
      "     |      Display results as a histogram:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(dsums, 11, density=True)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  random_sample(...)\n",
      "     |      random_sample(size=None)\n",
      "     |      \n",
      "     |      Return random floats in the half-open interval [0.0, 1.0).\n",
      "     |      \n",
      "     |      Results are from the \"continuous uniform\" distribution over the\n",
      "     |      stated interval.  To sample :math:`Unif[a, b), b > a` multiply\n",
      "     |      the output of `random_sample` by `(b-a)` and add `a`::\n",
      "     |      \n",
      "     |        (b - a) * random_sample() + a\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``random`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : float or ndarray of floats\n",
      "     |          Array of random floats of shape `size` (unless ``size=None``, in which\n",
      "     |          case a single float is returned).\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.random: which should be used for new code.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> np.random.random_sample()\n",
      "     |      0.47108547995356098 # random\n",
      "     |      >>> type(np.random.random_sample())\n",
      "     |      <class 'float'>\n",
      "     |      >>> np.random.random_sample((5,))\n",
      "     |      array([ 0.30220482,  0.86820401,  0.1654503 ,  0.11659149,  0.54323428]) # random\n",
      "     |      \n",
      "     |      Three-by-two array of random numbers from [-5, 0):\n",
      "     |      \n",
      "     |      >>> 5 * np.random.random_sample((3, 2)) - 5\n",
      "     |      array([[-3.99149989, -0.52338984], # random\n",
      "     |             [-2.99091858, -0.79479508],\n",
      "     |             [-1.23204345, -1.75224494]])\n",
      "     |  \n",
      "     |  rayleigh(...)\n",
      "     |      rayleigh(scale=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Rayleigh distribution.\n",
      "     |      \n",
      "     |      The :math:`\\chi` and Weibull distributions are generalizations of the\n",
      "     |      Rayleigh.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``rayleigh`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      scale : float or array_like of floats, optional\n",
      "     |          Scale, also equals the mode. Must be non-negative. Default is 1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``scale`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Rayleigh distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.rayleigh: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the Rayleigh distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x;scale) = \\frac{x}{scale^2}e^{\\frac{-x^2}{2 \\cdotp scale^2}}\n",
      "     |      \n",
      "     |      The Rayleigh distribution would arise, for example, if the East\n",
      "     |      and North components of the wind velocity had identical zero-mean\n",
      "     |      Gaussian distributions.  Then the wind speed would have a Rayleigh\n",
      "     |      distribution.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Brighton Webs Ltd., \"Rayleigh Distribution,\"\n",
      "     |             https://web.archive.org/web/20090514091424/http://brighton-webs.co.uk:80/distributions/rayleigh.asp\n",
      "     |      .. [2] Wikipedia, \"Rayleigh distribution\"\n",
      "     |             https://en.wikipedia.org/wiki/Rayleigh_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw values from the distribution and plot the histogram\n",
      "     |      \n",
      "     |      >>> from matplotlib.pyplot import hist\n",
      "     |      >>> values = hist(np.random.rayleigh(3, 100000), bins=200, density=True)\n",
      "     |      \n",
      "     |      Wave heights tend to follow a Rayleigh distribution. If the mean wave\n",
      "     |      height is 1 meter, what fraction of waves are likely to be larger than 3\n",
      "     |      meters?\n",
      "     |      \n",
      "     |      >>> meanvalue = 1\n",
      "     |      >>> modevalue = np.sqrt(2 / np.pi) * meanvalue\n",
      "     |      >>> s = np.random.rayleigh(modevalue, 1000000)\n",
      "     |      \n",
      "     |      The percentage of waves larger than 3 meters is:\n",
      "     |      \n",
      "     |      >>> 100.*sum(s>3)/1000000.\n",
      "     |      0.087300000000000003 # random\n",
      "     |  \n",
      "     |  seed(...)\n",
      "     |      seed(self, seed=None)\n",
      "     |      \n",
      "     |      Reseed a legacy MT19937 BitGenerator\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      This is a convenience, legacy function.\n",
      "     |      \n",
      "     |      The best practice is to **not** reseed a BitGenerator, rather to\n",
      "     |      recreate a new one. This method is here for legacy reasons.\n",
      "     |      This example demonstrates best practice.\n",
      "     |      \n",
      "     |      >>> from numpy.random import MT19937\n",
      "     |      >>> from numpy.random import RandomState, SeedSequence\n",
      "     |      >>> rs = RandomState(MT19937(SeedSequence(123456789)))\n",
      "     |      # Later, you want to restart the stream\n",
      "     |      >>> rs = RandomState(MT19937(SeedSequence(987654321)))\n",
      "     |  \n",
      "     |  set_state(...)\n",
      "     |      set_state(state)\n",
      "     |      \n",
      "     |      Set the internal state of the generator from a tuple.\n",
      "     |      \n",
      "     |      For use if one has reason to manually (re-)set the internal state of\n",
      "     |      the bit generator used by the RandomState instance. By default,\n",
      "     |      RandomState uses the \"Mersenne Twister\"[1]_ pseudo-random number\n",
      "     |      generating algorithm.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      state : {tuple(str, ndarray of 624 uints, int, int, float), dict}\n",
      "     |          The `state` tuple has the following items:\n",
      "     |      \n",
      "     |          1. the string 'MT19937', specifying the Mersenne Twister algorithm.\n",
      "     |          2. a 1-D array of 624 unsigned integers ``keys``.\n",
      "     |          3. an integer ``pos``.\n",
      "     |          4. an integer ``has_gauss``.\n",
      "     |          5. a float ``cached_gaussian``.\n",
      "     |      \n",
      "     |          If state is a dictionary, it is directly set using the BitGenerators\n",
      "     |          `state` property.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : None\n",
      "     |          Returns 'None' on success.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      get_state\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      `set_state` and `get_state` are not needed to work with any of the\n",
      "     |      random distributions in NumPy. If the internal state is manually altered,\n",
      "     |      the user should know exactly what he/she is doing.\n",
      "     |      \n",
      "     |      For backwards compatibility, the form (str, array of 624 uints, int) is\n",
      "     |      also accepted although it is missing some information about the cached\n",
      "     |      Gaussian value: ``state = ('MT19937', keys, pos)``.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] M. Matsumoto and T. Nishimura, \"Mersenne Twister: A\n",
      "     |         623-dimensionally equidistributed uniform pseudorandom number\n",
      "     |         generator,\" *ACM Trans. on Modeling and Computer Simulation*,\n",
      "     |         Vol. 8, No. 1, pp. 3-30, Jan. 1998.\n",
      "     |  \n",
      "     |  shuffle(...)\n",
      "     |      shuffle(x)\n",
      "     |      \n",
      "     |      Modify a sequence in-place by shuffling its contents.\n",
      "     |      \n",
      "     |      This function only shuffles the array along the first axis of a\n",
      "     |      multi-dimensional array. The order of sub-arrays is changed but\n",
      "     |      their contents remains the same.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``shuffle`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      x : array_like\n",
      "     |          The array or list to be shuffled.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      None\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.shuffle: which should be used for new code.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> arr = np.arange(10)\n",
      "     |      >>> np.random.shuffle(arr)\n",
      "     |      >>> arr\n",
      "     |      [1 7 5 2 9 4 3 6 0 8] # random\n",
      "     |      \n",
      "     |      Multi-dimensional arrays are only shuffled along the first axis:\n",
      "     |      \n",
      "     |      >>> arr = np.arange(9).reshape((3, 3))\n",
      "     |      >>> np.random.shuffle(arr)\n",
      "     |      >>> arr\n",
      "     |      array([[3, 4, 5], # random\n",
      "     |             [6, 7, 8],\n",
      "     |             [0, 1, 2]])\n",
      "     |  \n",
      "     |  standard_cauchy(...)\n",
      "     |      standard_cauchy(size=None)\n",
      "     |      \n",
      "     |      Draw samples from a standard Cauchy distribution with mode = 0.\n",
      "     |      \n",
      "     |      Also known as the Lorentz distribution.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``standard_cauchy`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      samples : ndarray or scalar\n",
      "     |          The drawn samples.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.standard_cauchy: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the full Cauchy distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x; x_0, \\gamma) = \\frac{1}{\\pi \\gamma \\bigl[ 1+\n",
      "     |                (\\frac{x-x_0}{\\gamma})^2 \\bigr] }\n",
      "     |      \n",
      "     |      and the Standard Cauchy distribution just sets :math:`x_0=0` and\n",
      "     |      :math:`\\gamma=1`\n",
      "     |      \n",
      "     |      The Cauchy distribution arises in the solution to the driven harmonic\n",
      "     |      oscillator problem, and also describes spectral line broadening. It\n",
      "     |      also describes the distribution of values at which a line tilted at\n",
      "     |      a random angle will cut the x axis.\n",
      "     |      \n",
      "     |      When studying hypothesis tests that assume normality, seeing how the\n",
      "     |      tests perform on data from a Cauchy distribution is a good indicator of\n",
      "     |      their sensitivity to a heavy-tailed distribution, since the Cauchy looks\n",
      "     |      very much like a Gaussian distribution, but with heavier tails.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] NIST/SEMATECH e-Handbook of Statistical Methods, \"Cauchy\n",
      "     |            Distribution\",\n",
      "     |            https://www.itl.nist.gov/div898/handbook/eda/section3/eda3663.htm\n",
      "     |      .. [2] Weisstein, Eric W. \"Cauchy Distribution.\" From MathWorld--A\n",
      "     |            Wolfram Web Resource.\n",
      "     |            http://mathworld.wolfram.com/CauchyDistribution.html\n",
      "     |      .. [3] Wikipedia, \"Cauchy distribution\"\n",
      "     |            https://en.wikipedia.org/wiki/Cauchy_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples and plot the distribution:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> s = np.random.standard_cauchy(1000000)\n",
      "     |      >>> s = s[(s>-25) & (s<25)]  # truncate distribution so it plots well\n",
      "     |      >>> plt.hist(s, bins=100)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  standard_exponential(...)\n",
      "     |      standard_exponential(size=None)\n",
      "     |      \n",
      "     |      Draw samples from the standard exponential distribution.\n",
      "     |      \n",
      "     |      `standard_exponential` is identical to the exponential distribution\n",
      "     |      with a scale parameter of 1.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``standard_exponential`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : float or ndarray\n",
      "     |          Drawn samples.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.standard_exponential: which should be used for new code.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Output a 3x8000 array:\n",
      "     |      \n",
      "     |      >>> n = np.random.standard_exponential((3, 8000))\n",
      "     |  \n",
      "     |  standard_gamma(...)\n",
      "     |      standard_gamma(shape, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a standard Gamma distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a Gamma distribution with specified parameters,\n",
      "     |      shape (sometimes designated \"k\") and scale=1.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``standard_gamma`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      shape : float or array_like of floats\n",
      "     |          Parameter, must be non-negative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``shape`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(shape).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized standard gamma distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.gamma : probability density function, distribution or\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.standard_gamma: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Gamma distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n",
      "     |      \n",
      "     |      where :math:`k` is the shape and :math:`\\theta` the scale,\n",
      "     |      and :math:`\\Gamma` is the Gamma function.\n",
      "     |      \n",
      "     |      The Gamma distribution is often used to model the times to failure of\n",
      "     |      electronic components, and arises naturally in processes for which the\n",
      "     |      waiting times between Poisson distributed events are relevant.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n",
      "     |             Wolfram Web Resource.\n",
      "     |             http://mathworld.wolfram.com/GammaDistribution.html\n",
      "     |      .. [2] Wikipedia, \"Gamma distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Gamma_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> shape, scale = 2., 1. # mean and width\n",
      "     |      >>> s = np.random.standard_gamma(shape, 1000000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> import scipy.special as sps  # doctest: +SKIP\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 50, density=True)\n",
      "     |      >>> y = bins**(shape-1) * ((np.exp(-bins/scale))/  # doctest: +SKIP\n",
      "     |      ...                       (sps.gamma(shape) * scale**shape))\n",
      "     |      >>> plt.plot(bins, y, linewidth=2, color='r')  # doctest: +SKIP\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  standard_normal(...)\n",
      "     |      standard_normal(size=None)\n",
      "     |      \n",
      "     |      Draw samples from a standard Normal distribution (mean=0, stdev=1).\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``standard_normal`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : float or ndarray\n",
      "     |          A floating-point array of shape ``size`` of drawn samples, or a\n",
      "     |          single sample if ``size`` was not specified.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      normal :\n",
      "     |          Equivalent function with additional ``loc`` and ``scale`` arguments\n",
      "     |          for setting the mean and standard deviation.\n",
      "     |      Generator.standard_normal: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      For random samples from :math:`N(\\mu, \\sigma^2)`, use one of::\n",
      "     |      \n",
      "     |          mu + sigma * np.random.standard_normal(size=...)\n",
      "     |          np.random.normal(mu, sigma, size=...)\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> np.random.standard_normal()\n",
      "     |      2.1923875335537315 #random\n",
      "     |      \n",
      "     |      >>> s = np.random.standard_normal(8000)\n",
      "     |      >>> s\n",
      "     |      array([ 0.6888893 ,  0.78096262, -0.89086505, ...,  0.49876311,  # random\n",
      "     |             -0.38672696, -0.4685006 ])                                # random\n",
      "     |      >>> s.shape\n",
      "     |      (8000,)\n",
      "     |      >>> s = np.random.standard_normal(size=(3, 4, 2))\n",
      "     |      >>> s.shape\n",
      "     |      (3, 4, 2)\n",
      "     |      \n",
      "     |      Two-by-four array of samples from :math:`N(3, 6.25)`:\n",
      "     |      \n",
      "     |      >>> 3 + 2.5 * np.random.standard_normal(size=(2, 4))\n",
      "     |      array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random\n",
      "     |             [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]])  # random\n",
      "     |  \n",
      "     |  standard_t(...)\n",
      "     |      standard_t(df, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a standard Student's t distribution with `df` degrees\n",
      "     |      of freedom.\n",
      "     |      \n",
      "     |      A special case of the hyperbolic distribution.  As `df` gets\n",
      "     |      large, the result resembles that of the standard normal\n",
      "     |      distribution (`standard_normal`).\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``standard_t`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      df : float or array_like of floats\n",
      "     |          Degrees of freedom, must be > 0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``df`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(df).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized standard Student's t distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.standard_t: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the t distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x, df) = \\frac{\\Gamma(\\frac{df+1}{2})}{\\sqrt{\\pi df}\n",
      "     |                \\Gamma(\\frac{df}{2})}\\Bigl( 1+\\frac{x^2}{df} \\Bigr)^{-(df+1)/2}\n",
      "     |      \n",
      "     |      The t test is based on an assumption that the data come from a\n",
      "     |      Normal distribution. The t test provides a way to test whether\n",
      "     |      the sample mean (that is the mean calculated from the data) is\n",
      "     |      a good estimate of the true mean.\n",
      "     |      \n",
      "     |      The derivation of the t-distribution was first published in\n",
      "     |      1908 by William Gosset while working for the Guinness Brewery\n",
      "     |      in Dublin. Due to proprietary issues, he had to publish under\n",
      "     |      a pseudonym, and so he used the name Student.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Dalgaard, Peter, \"Introductory Statistics With R\",\n",
      "     |             Springer, 2002.\n",
      "     |      .. [2] Wikipedia, \"Student's t-distribution\"\n",
      "     |             https://en.wikipedia.org/wiki/Student's_t-distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      From Dalgaard page 83 [1]_, suppose the daily energy intake for 11\n",
      "     |      women in kilojoules (kJ) is:\n",
      "     |      \n",
      "     |      >>> intake = np.array([5260., 5470, 5640, 6180, 6390, 6515, 6805, 7515, \\\n",
      "     |      ...                    7515, 8230, 8770])\n",
      "     |      \n",
      "     |      Does their energy intake deviate systematically from the recommended\n",
      "     |      value of 7725 kJ?\n",
      "     |      \n",
      "     |      We have 10 degrees of freedom, so is the sample mean within 95% of the\n",
      "     |      recommended value?\n",
      "     |      \n",
      "     |      >>> s = np.random.standard_t(10, size=100000)\n",
      "     |      >>> np.mean(intake)\n",
      "     |      6753.636363636364\n",
      "     |      >>> intake.std(ddof=1)\n",
      "     |      1142.1232221373727\n",
      "     |      \n",
      "     |      Calculate the t statistic, setting the ddof parameter to the unbiased\n",
      "     |      value so the divisor in the standard deviation will be degrees of\n",
      "     |      freedom, N-1.\n",
      "     |      \n",
      "     |      >>> t = (np.mean(intake)-7725)/(intake.std(ddof=1)/np.sqrt(len(intake)))\n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> h = plt.hist(s, bins=100, density=True)\n",
      "     |      \n",
      "     |      For a one-sided t-test, how far out in the distribution does the t\n",
      "     |      statistic appear?\n",
      "     |      \n",
      "     |      >>> np.sum(s<t) / float(len(s))\n",
      "     |      0.0090699999999999999  #random\n",
      "     |      \n",
      "     |      So the p-value is about 0.009, which says the null hypothesis has a\n",
      "     |      probability of about 99% of being true.\n",
      "     |  \n",
      "     |  tomaxint(...)\n",
      "     |      tomaxint(size=None)\n",
      "     |      \n",
      "     |      Return a sample of uniformly distributed random integers in the interval\n",
      "     |      [0, ``np.iinfo(np.int_).max``]. The `np.int_` type translates to the C long\n",
      "     |      integer type and its precision is platform dependent.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray\n",
      "     |          Drawn samples, with shape `size`.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      randint : Uniform sampling over a given half-open interval of integers.\n",
      "     |      random_integers : Uniform sampling over a given closed interval of\n",
      "     |          integers.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      >>> rs = np.random.RandomState() # need a RandomState object\n",
      "     |      >>> rs.tomaxint((2,2,2))\n",
      "     |      array([[[1170048599, 1600360186], # random\n",
      "     |              [ 739731006, 1947757578]],\n",
      "     |             [[1871712945,  752307660],\n",
      "     |              [1601631370, 1479324245]]])\n",
      "     |      >>> rs.tomaxint((2,2,2)) < np.iinfo(np.int_).max\n",
      "     |      array([[[ True,  True],\n",
      "     |              [ True,  True]],\n",
      "     |             [[ True,  True],\n",
      "     |              [ True,  True]]])\n",
      "     |  \n",
      "     |  triangular(...)\n",
      "     |      triangular(left, mode, right, size=None)\n",
      "     |      \n",
      "     |      Draw samples from the triangular distribution over the\n",
      "     |      interval ``[left, right]``.\n",
      "     |      \n",
      "     |      The triangular distribution is a continuous probability\n",
      "     |      distribution with lower limit left, peak at mode, and upper\n",
      "     |      limit right. Unlike the other distributions, these parameters\n",
      "     |      directly define the shape of the pdf.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``triangular`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      left : float or array_like of floats\n",
      "     |          Lower limit.\n",
      "     |      mode : float or array_like of floats\n",
      "     |          The value where the peak of the distribution occurs.\n",
      "     |          The value must fulfill the condition ``left <= mode <= right``.\n",
      "     |      right : float or array_like of floats\n",
      "     |          Upper limit, must be larger than `left`.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``left``, ``mode``, and ``right``\n",
      "     |          are all scalars.  Otherwise, ``np.broadcast(left, mode, right).size``\n",
      "     |          samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized triangular distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.triangular: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the triangular distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x;l, m, r) = \\begin{cases}\n",
      "     |                \\frac{2(x-l)}{(r-l)(m-l)}& \\text{for $l \\leq x \\leq m$},\\\\\n",
      "     |                \\frac{2(r-x)}{(r-l)(r-m)}& \\text{for $m \\leq x \\leq r$},\\\\\n",
      "     |                0& \\text{otherwise}.\n",
      "     |                \\end{cases}\n",
      "     |      \n",
      "     |      The triangular distribution is often used in ill-defined\n",
      "     |      problems where the underlying distribution is not known, but\n",
      "     |      some knowledge of the limits and mode exists. Often it is used\n",
      "     |      in simulations.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Wikipedia, \"Triangular distribution\"\n",
      "     |             https://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw values from the distribution and plot the histogram:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> h = plt.hist(np.random.triangular(-3, 0, 8, 100000), bins=200,\n",
      "     |      ...              density=True)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  uniform(...)\n",
      "     |      uniform(low=0.0, high=1.0, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a uniform distribution.\n",
      "     |      \n",
      "     |      Samples are uniformly distributed over the half-open interval\n",
      "     |      ``[low, high)`` (includes low, but excludes high).  In other words,\n",
      "     |      any value within the given interval is equally likely to be drawn\n",
      "     |      by `uniform`.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``uniform`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      low : float or array_like of floats, optional\n",
      "     |          Lower boundary of the output interval.  All values generated will be\n",
      "     |          greater than or equal to low.  The default value is 0.\n",
      "     |      high : float or array_like of floats\n",
      "     |          Upper boundary of the output interval.  All values generated will be\n",
      "     |          less than or equal to high.  The default value is 1.0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``low`` and ``high`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(low, high).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized uniform distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      randint : Discrete uniform distribution, yielding integers.\n",
      "     |      random_integers : Discrete uniform distribution over the closed\n",
      "     |                        interval ``[low, high]``.\n",
      "     |      random_sample : Floats uniformly distributed over ``[0, 1)``.\n",
      "     |      random : Alias for `random_sample`.\n",
      "     |      rand : Convenience function that accepts dimensions as input, e.g.,\n",
      "     |             ``rand(2,2)`` would generate a 2-by-2 array of floats,\n",
      "     |             uniformly distributed over ``[0, 1)``.\n",
      "     |      Generator.uniform: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function of the uniform distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{1}{b - a}\n",
      "     |      \n",
      "     |      anywhere within the interval ``[a, b)``, and zero elsewhere.\n",
      "     |      \n",
      "     |      When ``high`` == ``low``, values of ``low`` will be returned.\n",
      "     |      If ``high`` < ``low``, the results are officially undefined\n",
      "     |      and may eventually raise an error, i.e. do not rely on this\n",
      "     |      function to behave when passed arguments satisfying that\n",
      "     |      inequality condition. The ``high`` limit may be included in the\n",
      "     |      returned array of floats due to floating-point rounding in the\n",
      "     |      equation ``low + (high-low) * random_sample()``. For example:\n",
      "     |      \n",
      "     |      >>> x = np.float32(5*0.99999999)\n",
      "     |      >>> x\n",
      "     |      5.0\n",
      "     |      \n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> s = np.random.uniform(-1,0,1000)\n",
      "     |      \n",
      "     |      All values are within the given interval:\n",
      "     |      \n",
      "     |      >>> np.all(s >= -1)\n",
      "     |      True\n",
      "     |      >>> np.all(s < 0)\n",
      "     |      True\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with the\n",
      "     |      probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> count, bins, ignored = plt.hist(s, 15, density=True)\n",
      "     |      >>> plt.plot(bins, np.ones_like(bins), linewidth=2, color='r')\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  vonmises(...)\n",
      "     |      vonmises(mu, kappa, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a von Mises distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a von Mises distribution with specified mode\n",
      "     |      (mu) and dispersion (kappa), on the interval [-pi, pi].\n",
      "     |      \n",
      "     |      The von Mises distribution (also known as the circular normal\n",
      "     |      distribution) is a continuous probability distribution on the unit\n",
      "     |      circle.  It may be thought of as the circular analogue of the normal\n",
      "     |      distribution.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``vonmises`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      mu : float or array_like of floats\n",
      "     |          Mode (\"center\") of the distribution.\n",
      "     |      kappa : float or array_like of floats\n",
      "     |          Dispersion of the distribution, has to be >=0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``mu`` and ``kappa`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(mu, kappa).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized von Mises distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.vonmises : probability density function, distribution, or\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.vonmises: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the von Mises distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{e^{\\kappa cos(x-\\mu)}}{2\\pi I_0(\\kappa)},\n",
      "     |      \n",
      "     |      where :math:`\\mu` is the mode and :math:`\\kappa` the dispersion,\n",
      "     |      and :math:`I_0(\\kappa)` is the modified Bessel function of order 0.\n",
      "     |      \n",
      "     |      The von Mises is named for Richard Edler von Mises, who was born in\n",
      "     |      Austria-Hungary, in what is now the Ukraine.  He fled to the United\n",
      "     |      States in 1939 and became a professor at Harvard.  He worked in\n",
      "     |      probability theory, aerodynamics, fluid mechanics, and philosophy of\n",
      "     |      science.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n",
      "     |             Mathematical Functions with Formulas, Graphs, and Mathematical\n",
      "     |             Tables, 9th printing,\" New York: Dover, 1972.\n",
      "     |      .. [2] von Mises, R., \"Mathematical Theory of Probability\n",
      "     |             and Statistics\", New York: Academic Press, 1964.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> mu, kappa = 0.0, 4.0 # mean and dispersion\n",
      "     |      >>> s = np.random.vonmises(mu, kappa, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> from scipy.special import i0  # doctest: +SKIP\n",
      "     |      >>> plt.hist(s, 50, density=True)\n",
      "     |      >>> x = np.linspace(-np.pi, np.pi, num=51)\n",
      "     |      >>> y = np.exp(kappa*np.cos(x-mu))/(2*np.pi*i0(kappa))  # doctest: +SKIP\n",
      "     |      >>> plt.plot(x, y, linewidth=2, color='r')  # doctest: +SKIP\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  wald(...)\n",
      "     |      wald(mean, scale, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Wald, or inverse Gaussian, distribution.\n",
      "     |      \n",
      "     |      As the scale approaches infinity, the distribution becomes more like a\n",
      "     |      Gaussian. Some references claim that the Wald is an inverse Gaussian\n",
      "     |      with mean equal to 1, but this is by no means universal.\n",
      "     |      \n",
      "     |      The inverse Gaussian distribution was first studied in relationship to\n",
      "     |      Brownian motion. In 1956 M.C.K. Tweedie used the name inverse Gaussian\n",
      "     |      because there is an inverse relationship between the time to cover a\n",
      "     |      unit distance and distance covered in unit time.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``wald`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      mean : float or array_like of floats\n",
      "     |          Distribution mean, must be > 0.\n",
      "     |      scale : float or array_like of floats\n",
      "     |          Scale parameter, must be > 0.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``mean`` and ``scale`` are both scalars.\n",
      "     |          Otherwise, ``np.broadcast(mean, scale).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Wald distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      Generator.wald: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density function for the Wald distribution is\n",
      "     |      \n",
      "     |      .. math:: P(x;mean,scale) = \\sqrt{\\frac{scale}{2\\pi x^3}}e^\n",
      "     |                                  \\frac{-scale(x-mean)^2}{2\\cdotp mean^2x}\n",
      "     |      \n",
      "     |      As noted above the inverse Gaussian distribution first arise\n",
      "     |      from attempts to model Brownian motion. It is also a\n",
      "     |      competitor to the Weibull for use in reliability modeling and\n",
      "     |      modeling stock returns and interest rate processes.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Brighton Webs Ltd., Wald Distribution,\n",
      "     |             https://web.archive.org/web/20090423014010/http://www.brighton-webs.co.uk:80/distributions/wald.asp\n",
      "     |      .. [2] Chhikara, Raj S., and Folks, J. Leroy, \"The Inverse Gaussian\n",
      "     |             Distribution: Theory : Methodology, and Applications\", CRC Press,\n",
      "     |             1988.\n",
      "     |      .. [3] Wikipedia, \"Inverse Gaussian distribution\"\n",
      "     |             https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw values from the distribution and plot the histogram:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> h = plt.hist(np.random.wald(3, 2, 100000), bins=200, density=True)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  weibull(...)\n",
      "     |      weibull(a, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Weibull distribution.\n",
      "     |      \n",
      "     |      Draw samples from a 1-parameter Weibull distribution with the given\n",
      "     |      shape parameter `a`.\n",
      "     |      \n",
      "     |      .. math:: X = (-ln(U))^{1/a}\n",
      "     |      \n",
      "     |      Here, U is drawn from the uniform distribution over (0,1].\n",
      "     |      \n",
      "     |      The more common 2-parameter Weibull, including a scale parameter\n",
      "     |      :math:`\\lambda` is just :math:`X = \\lambda(-ln(U))^{1/a}`.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``weibull`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : float or array_like of floats\n",
      "     |          Shape parameter of the distribution.  Must be nonnegative.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``a`` is a scalar.  Otherwise,\n",
      "     |          ``np.array(a).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Weibull distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.weibull_max\n",
      "     |      scipy.stats.weibull_min\n",
      "     |      scipy.stats.genextreme\n",
      "     |      gumbel\n",
      "     |      Generator.weibull: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The Weibull (or Type III asymptotic extreme value distribution\n",
      "     |      for smallest values, SEV Type III, or Rosin-Rammler\n",
      "     |      distribution) is one of a class of Generalized Extreme Value\n",
      "     |      (GEV) distributions used in modeling extreme value problems.\n",
      "     |      This class includes the Gumbel and Frechet distributions.\n",
      "     |      \n",
      "     |      The probability density for the Weibull distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{a}\n",
      "     |                       {\\lambda}(\\frac{x}{\\lambda})^{a-1}e^{-(x/\\lambda)^a},\n",
      "     |      \n",
      "     |      where :math:`a` is the shape and :math:`\\lambda` the scale.\n",
      "     |      \n",
      "     |      The function has its peak (the mode) at\n",
      "     |      :math:`\\lambda(\\frac{a-1}{a})^{1/a}`.\n",
      "     |      \n",
      "     |      When ``a = 1``, the Weibull distribution reduces to the exponential\n",
      "     |      distribution.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Waloddi Weibull, Royal Technical University, Stockholm,\n",
      "     |             1939 \"A Statistical Theory Of The Strength Of Materials\",\n",
      "     |             Ingeniorsvetenskapsakademiens Handlingar Nr 151, 1939,\n",
      "     |             Generalstabens Litografiska Anstalts Forlag, Stockholm.\n",
      "     |      .. [2] Waloddi Weibull, \"A Statistical Distribution Function of\n",
      "     |             Wide Applicability\", Journal Of Applied Mechanics ASME Paper\n",
      "     |             1951.\n",
      "     |      .. [3] Wikipedia, \"Weibull distribution\",\n",
      "     |             https://en.wikipedia.org/wiki/Weibull_distribution\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> a = 5. # shape\n",
      "     |      >>> s = np.random.weibull(a, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> x = np.arange(1,100.)/50.\n",
      "     |      >>> def weib(x,n,a):\n",
      "     |      ...     return (a / n) * (x / n)**(a - 1) * np.exp(-(x / n)**a)\n",
      "     |      \n",
      "     |      >>> count, bins, ignored = plt.hist(np.random.weibull(5.,1000))\n",
      "     |      >>> x = np.arange(1,100.)/50.\n",
      "     |      >>> scale = count.max()/weib(x, 1., 5.).max()\n",
      "     |      >>> plt.plot(x, weib(x, 1., 5.)*scale)\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  zipf(...)\n",
      "     |      zipf(a, size=None)\n",
      "     |      \n",
      "     |      Draw samples from a Zipf distribution.\n",
      "     |      \n",
      "     |      Samples are drawn from a Zipf distribution with specified parameter\n",
      "     |      `a` > 1.\n",
      "     |      \n",
      "     |      The Zipf distribution (also known as the zeta distribution) is a\n",
      "     |      continuous probability distribution that satisfies Zipf's law: the\n",
      "     |      frequency of an item is inversely proportional to its rank in a\n",
      "     |      frequency table.\n",
      "     |      \n",
      "     |      .. note::\n",
      "     |          New code should use the ``zipf`` method of a ``default_rng()``\n",
      "     |          instance instead; please see the :ref:`random-quick-start`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      a : float or array_like of floats\n",
      "     |          Distribution parameter. Must be greater than 1.\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "     |          a single value is returned if ``a`` is a scalar. Otherwise,\n",
      "     |          ``np.array(a).size`` samples are drawn.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : ndarray or scalar\n",
      "     |          Drawn samples from the parameterized Zipf distribution.\n",
      "     |      \n",
      "     |      See Also\n",
      "     |      --------\n",
      "     |      scipy.stats.zipf : probability density function, distribution, or\n",
      "     |          cumulative density function, etc.\n",
      "     |      Generator.zipf: which should be used for new code.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      The probability density for the Zipf distribution is\n",
      "     |      \n",
      "     |      .. math:: p(x) = \\frac{x^{-a}}{\\zeta(a)},\n",
      "     |      \n",
      "     |      where :math:`\\zeta` is the Riemann Zeta function.\n",
      "     |      \n",
      "     |      It is named for the American linguist George Kingsley Zipf, who noted\n",
      "     |      that the frequency of any word in a sample of a language is inversely\n",
      "     |      proportional to its rank in the frequency table.\n",
      "     |      \n",
      "     |      References\n",
      "     |      ----------\n",
      "     |      .. [1] Zipf, G. K., \"Selected Studies of the Principle of Relative\n",
      "     |             Frequency in Language,\" Cambridge, MA: Harvard Univ. Press,\n",
      "     |             1932.\n",
      "     |      \n",
      "     |      Examples\n",
      "     |      --------\n",
      "     |      Draw samples from the distribution:\n",
      "     |      \n",
      "     |      >>> a = 2. # parameter\n",
      "     |      >>> s = np.random.zipf(a, 1000)\n",
      "     |      \n",
      "     |      Display the histogram of the samples, along with\n",
      "     |      the probability density function:\n",
      "     |      \n",
      "     |      >>> import matplotlib.pyplot as plt\n",
      "     |      >>> from scipy import special  # doctest: +SKIP\n",
      "     |      \n",
      "     |      Truncate s values at 50 so plot is interesting:\n",
      "     |      \n",
      "     |      >>> count, bins, ignored = plt.hist(s[s<50], 50, density=True)\n",
      "     |      >>> x = np.arange(1., 50.)\n",
      "     |      >>> y = x**(-a) / special.zetac(a)  # doctest: +SKIP\n",
      "     |      >>> plt.plot(x, y/max(y), linewidth=2, color='r')  # doctest: +SKIP\n",
      "     |      >>> plt.show()\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  __pyx_vtable__ = <capsule object NULL>\n",
      "    \n",
      "    class SFC64(numpy.random.bit_generator.BitGenerator)\n",
      "     |  SFC64(seed=None)\n",
      "     |  \n",
      "     |  BitGenerator for Chris Doty-Humphrey's Small Fast Chaotic PRNG.\n",
      "     |  \n",
      "     |  Parameters\n",
      "     |  ----------\n",
      "     |  seed : {None, int, array_like[ints], SeedSequence}, optional\n",
      "     |      A seed to initialize the `BitGenerator`. If None, then fresh,\n",
      "     |      unpredictable entropy will be pulled from the OS. If an ``int`` or\n",
      "     |      ``array_like[ints]`` is passed, then it will be passed to\n",
      "     |      `SeedSequence` to derive the initial `BitGenerator` state. One may also\n",
      "     |      pass in a `SeedSequence` instance.\n",
      "     |  \n",
      "     |  Notes\n",
      "     |  -----\n",
      "     |  ``SFC64`` is a 256-bit implementation of Chris Doty-Humphrey's Small Fast\n",
      "     |  Chaotic PRNG ([1]_). ``SFC64`` has a few different cycles that one might be\n",
      "     |  on, depending on the seed; the expected period will be about\n",
      "     |  :math:`2^{255}` ([2]_). ``SFC64`` incorporates a 64-bit counter which means\n",
      "     |  that the absolute minimum cycle length is :math:`2^{64}` and that distinct\n",
      "     |  seeds will not run into each other for at least :math:`2^{64}` iterations.\n",
      "     |  \n",
      "     |  ``SFC64`` provides a capsule containing function pointers that produce\n",
      "     |  doubles, and unsigned 32 and 64- bit integers. These are not\n",
      "     |  directly consumable in Python and must be consumed by a ``Generator``\n",
      "     |  or similar object that supports low-level access.\n",
      "     |  \n",
      "     |  **State and Seeding**\n",
      "     |  \n",
      "     |  The ``SFC64`` state vector consists of 4 unsigned 64-bit values. The last\n",
      "     |  is a 64-bit counter that increments by 1 each iteration.\n",
      "     |  \n",
      "     |  The input seed is processed by `SeedSequence` to generate the first\n",
      "     |  3 values, then the ``SFC64`` algorithm is iterated a small number of times\n",
      "     |  to mix.\n",
      "     |  \n",
      "     |  **Compatibility Guarantee**\n",
      "     |  \n",
      "     |  ``SFC64`` makes a guarantee that a fixed seed will always produce the same\n",
      "     |  random integer stream.\n",
      "     |  \n",
      "     |  References\n",
      "     |  ----------\n",
      "     |  .. [1] `\"PractRand\"\n",
      "     |          <http://pracrand.sourceforge.net/RNG_engines.txt>`_\n",
      "     |  .. [2] `\"Random Invertible Mapping Statistics\"\n",
      "     |          <http://www.pcg-random.org/posts/random-invertible-mapping-statistics.html>`_\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      SFC64\n",
      "     |      numpy.random.bit_generator.BitGenerator\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce_cython__(...)\n",
      "     |  \n",
      "     |  __setstate_cython__(...)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  state\n",
      "     |      Get or set the PRNG state\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      state : dict\n",
      "     |          Dictionary containing the information required to describe the\n",
      "     |          state of the PRNG\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  __pyx_vtable__ = <capsule object NULL>\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from numpy.random.bit_generator.BitGenerator:\n",
      "     |  \n",
      "     |  __getstate__(...)\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  random_raw(...)\n",
      "     |      random_raw(self, size=None)\n",
      "     |      \n",
      "     |      Return randoms as generated by the underlying BitGenerator\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      size : int or tuple of ints, optional\n",
      "     |          Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "     |          ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "     |          single value is returned.\n",
      "     |      output : bool, optional\n",
      "     |          Output values.  Used for performance testing since the generated\n",
      "     |          values are not returned.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      out : uint or ndarray\n",
      "     |          Drawn samples.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      This method directly exposes the the raw underlying pseudo-random\n",
      "     |      number generator. All values are returned as unsigned 64-bit\n",
      "     |      values irrespective of the number of bits produced by the PRNG.\n",
      "     |      \n",
      "     |      See the class docstring for the number of bits returned.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from numpy.random.bit_generator.BitGenerator:\n",
      "     |  \n",
      "     |  capsule\n",
      "     |  \n",
      "     |  cffi\n",
      "     |      CFFI interface\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      interface : namedtuple\n",
      "     |          Named tuple containing CFFI wrapper\n",
      "     |      \n",
      "     |          * state_address - Memory address of the state struct\n",
      "     |          * state - pointer to the state struct\n",
      "     |          * next_uint64 - function pointer to produce 64 bit integers\n",
      "     |          * next_uint32 - function pointer to produce 32 bit integers\n",
      "     |          * next_double - function pointer to produce doubles\n",
      "     |          * bitgen - pointer to the bit generator struct\n",
      "     |  \n",
      "     |  ctypes\n",
      "     |      ctypes interface\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      interface : namedtuple\n",
      "     |          Named tuple containing ctypes wrapper\n",
      "     |      \n",
      "     |          * state_address - Memory address of the state struct\n",
      "     |          * state - pointer to the state struct\n",
      "     |          * next_uint64 - function pointer to produce 64 bit integers\n",
      "     |          * next_uint32 - function pointer to produce 32 bit integers\n",
      "     |          * next_double - function pointer to produce doubles\n",
      "     |          * bitgen - pointer to the bit generator struct\n",
      "     |  \n",
      "     |  lock\n",
      "    \n",
      "    class SeedSequence(builtins.object)\n",
      "     |  SeedSequence(entropy=None, *, spawn_key=(), pool_size=4)\n",
      "     |  \n",
      "     |  SeedSequence mixes sources of entropy in a reproducible way to set the\n",
      "     |  initial state for independent and very probably non-overlapping\n",
      "     |  BitGenerators.\n",
      "     |  \n",
      "     |  Once the SeedSequence is instantiated, you can call the `generate_state`\n",
      "     |  method to get an appropriately sized seed. Calling `spawn(n) <spawn>` will\n",
      "     |  create ``n`` SeedSequences that can be used to seed independent\n",
      "     |  BitGenerators, i.e. for different threads.\n",
      "     |  \n",
      "     |  Parameters\n",
      "     |  ----------\n",
      "     |  entropy : {None, int, sequence[int]}, optional\n",
      "     |      The entropy for creating a `SeedSequence`.\n",
      "     |  spawn_key : {(), sequence[int]}, optional\n",
      "     |      A third source of entropy, used internally when calling\n",
      "     |      `SeedSequence.spawn`\n",
      "     |  pool_size : {int}, optional\n",
      "     |      Size of the pooled entropy to store. Default is 4 to give a 128-bit\n",
      "     |      entropy pool. 8 (for 256 bits) is another reasonable choice if working\n",
      "     |      with larger PRNGs, but there is very little to be gained by selecting\n",
      "     |      another value.\n",
      "     |  n_children_spawned : {int}, optional\n",
      "     |      The number of children already spawned. Only pass this if\n",
      "     |      reconstructing a `SeedSequence` from a serialized form.\n",
      "     |  \n",
      "     |  Notes\n",
      "     |  -----\n",
      "     |  \n",
      "     |  Best practice for achieving reproducible bit streams is to use\n",
      "     |  the default ``None`` for the initial entropy, and then use\n",
      "     |  `SeedSequence.entropy` to log/pickle the `entropy` for reproducibility:\n",
      "     |  \n",
      "     |  >>> sq1 = np.random.SeedSequence()\n",
      "     |  >>> sq1.entropy\n",
      "     |  243799254704924441050048792905230269161  # random\n",
      "     |  >>> sq2 = np.random.SeedSequence(sq1.entropy)\n",
      "     |  >>> np.all(sq1.generate_state(10) == sq2.generate_state(10))\n",
      "     |  True\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__ = __reduce_cython__(...)\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __setstate__ = __setstate_cython__(...)\n",
      "     |  \n",
      "     |  generate_state(...)\n",
      "     |      generate_state(n_words, dtype=np.uint32)\n",
      "     |      \n",
      "     |      Return the requested number of words for PRNG seeding.\n",
      "     |      \n",
      "     |      A BitGenerator should call this method in its constructor with\n",
      "     |      an appropriate `n_words` parameter to properly seed itself.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      n_words : int\n",
      "     |      dtype : np.uint32 or np.uint64, optional\n",
      "     |          The size of each word. This should only be either `uint32` or\n",
      "     |          `uint64`. Strings (`'uint32'`, `'uint64'`) are fine. Note that\n",
      "     |          requesting `uint64` will draw twice as many bits as `uint32` for\n",
      "     |          the same `n_words`. This is a convenience for `BitGenerator`s that\n",
      "     |          express their states as `uint64` arrays.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      state : uint32 or uint64 array, shape=(n_words,)\n",
      "     |  \n",
      "     |  spawn(...)\n",
      "     |      spawn(n_children)\n",
      "     |      \n",
      "     |      Spawn a number of child `SeedSequence` s by extending the\n",
      "     |      `spawn_key`.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      n_children : int\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      seqs : list of `SeedSequence` s\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  entropy\n",
      "     |  \n",
      "     |  n_children_spawned\n",
      "     |  \n",
      "     |  pool\n",
      "     |  \n",
      "     |  pool_size\n",
      "     |  \n",
      "     |  spawn_key\n",
      "     |  \n",
      "     |  state\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  __pyx_vtable__ = <capsule object NULL>\n",
      "\n",
      "FUNCTIONS\n",
      "    beta(...) method of numpy.random.mtrand.RandomState instance\n",
      "        beta(a, b, size=None)\n",
      "        \n",
      "        Draw samples from a Beta distribution.\n",
      "        \n",
      "        The Beta distribution is a special case of the Dirichlet distribution,\n",
      "        and is related to the Gamma distribution.  It has the probability\n",
      "        distribution function\n",
      "        \n",
      "        .. math:: f(x; a,b) = \\frac{1}{B(\\alpha, \\beta)} x^{\\alpha - 1}\n",
      "                                                         (1 - x)^{\\beta - 1},\n",
      "        \n",
      "        where the normalization, B, is the beta function,\n",
      "        \n",
      "        .. math:: B(\\alpha, \\beta) = \\int_0^1 t^{\\alpha - 1}\n",
      "                                     (1 - t)^{\\beta - 1} dt.\n",
      "        \n",
      "        It is often seen in Bayesian inference and order statistics.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``beta`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : float or array_like of floats\n",
      "            Alpha, positive (>0).\n",
      "        b : float or array_like of floats\n",
      "            Beta, positive (>0).\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``a`` and ``b`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(a, b).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized beta distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.beta: which should be used for new code.\n",
      "    \n",
      "    binomial(...) method of numpy.random.mtrand.RandomState instance\n",
      "        binomial(n, p, size=None)\n",
      "        \n",
      "        Draw samples from a binomial distribution.\n",
      "        \n",
      "        Samples are drawn from a binomial distribution with specified\n",
      "        parameters, n trials and p probability of success where\n",
      "        n an integer >= 0 and p is in the interval [0,1]. (n may be\n",
      "        input as a float, but it is truncated to an integer in use)\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``binomial`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        n : int or array_like of ints\n",
      "            Parameter of the distribution, >= 0. Floats are also accepted,\n",
      "            but they will be truncated to integers.\n",
      "        p : float or array_like of floats\n",
      "            Parameter of the distribution, >= 0 and <=1.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``n`` and ``p`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized binomial distribution, where\n",
      "            each sample is equal to the number of successes over the n trials.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.binom : probability density function, distribution or\n",
      "            cumulative density function, etc.\n",
      "        Generator.binomial: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density for the binomial distribution is\n",
      "        \n",
      "        .. math:: P(N) = \\binom{n}{N}p^N(1-p)^{n-N},\n",
      "        \n",
      "        where :math:`n` is the number of trials, :math:`p` is the probability\n",
      "        of success, and :math:`N` is the number of successes.\n",
      "        \n",
      "        When estimating the standard error of a proportion in a population by\n",
      "        using a random sample, the normal distribution works well unless the\n",
      "        product p*n <=5, where p = population proportion estimate, and n =\n",
      "        number of samples, in which case the binomial distribution is used\n",
      "        instead. For example, a sample of 15 people shows 4 who are left\n",
      "        handed, and 11 who are right handed. Then p = 4/15 = 27%. 0.27*15 = 4,\n",
      "        so the binomial distribution should be used in this case.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Dalgaard, Peter, \"Introductory Statistics with R\",\n",
      "               Springer-Verlag, 2002.\n",
      "        .. [2] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n",
      "               Fifth Edition, 2002.\n",
      "        .. [3] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n",
      "               and Quigley, 1972.\n",
      "        .. [4] Weisstein, Eric W. \"Binomial Distribution.\" From MathWorld--A\n",
      "               Wolfram Web Resource.\n",
      "               http://mathworld.wolfram.com/BinomialDistribution.html\n",
      "        .. [5] Wikipedia, \"Binomial distribution\",\n",
      "               https://en.wikipedia.org/wiki/Binomial_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> n, p = 10, .5  # number of trials, probability of each trial\n",
      "        >>> s = np.random.binomial(n, p, 1000)\n",
      "        # result of flipping a coin 10 times, tested 1000 times.\n",
      "        \n",
      "        A real world example. A company drills 9 wild-cat oil exploration\n",
      "        wells, each with an estimated probability of success of 0.1. All nine\n",
      "        wells fail. What is the probability of that happening?\n",
      "        \n",
      "        Let's do 20,000 trials of the model, and count the number that\n",
      "        generate zero positive results.\n",
      "        \n",
      "        >>> sum(np.random.binomial(9, 0.1, 20000) == 0)/20000.\n",
      "        # answer = 0.38885, or 38%.\n",
      "    \n",
      "    bytes(...) method of numpy.random.mtrand.RandomState instance\n",
      "        bytes(length)\n",
      "        \n",
      "        Return random bytes.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``bytes`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        length : int\n",
      "            Number of random bytes.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : str\n",
      "            String of length `length`.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.bytes: which should be used for new code.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.bytes(10)\n",
      "        ' eh\\x85\\x022SZ\\xbf\\xa4' #random\n",
      "    \n",
      "    chisquare(...) method of numpy.random.mtrand.RandomState instance\n",
      "        chisquare(df, size=None)\n",
      "        \n",
      "        Draw samples from a chi-square distribution.\n",
      "        \n",
      "        When `df` independent random variables, each with standard normal\n",
      "        distributions (mean 0, variance 1), are squared and summed, the\n",
      "        resulting distribution is chi-square (see Notes).  This distribution\n",
      "        is often used in hypothesis testing.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``chisquare`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        df : float or array_like of floats\n",
      "             Number of degrees of freedom, must be > 0.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``df`` is a scalar.  Otherwise,\n",
      "            ``np.array(df).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized chi-square distribution.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        ValueError\n",
      "            When `df` <= 0 or when an inappropriate `size` (e.g. ``size=-1``)\n",
      "            is given.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.chisquare: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The variable obtained by summing the squares of `df` independent,\n",
      "        standard normally distributed random variables:\n",
      "        \n",
      "        .. math:: Q = \\sum_{i=0}^{\\mathtt{df}} X^2_i\n",
      "        \n",
      "        is chi-square distributed, denoted\n",
      "        \n",
      "        .. math:: Q \\sim \\chi^2_k.\n",
      "        \n",
      "        The probability density function of the chi-squared distribution is\n",
      "        \n",
      "        .. math:: p(x) = \\frac{(1/2)^{k/2}}{\\Gamma(k/2)}\n",
      "                         x^{k/2 - 1} e^{-x/2},\n",
      "        \n",
      "        where :math:`\\Gamma` is the gamma function,\n",
      "        \n",
      "        .. math:: \\Gamma(x) = \\int_0^{-\\infty} t^{x - 1} e^{-t} dt.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] NIST \"Engineering Statistics Handbook\"\n",
      "               https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.chisquare(2,4)\n",
      "        array([ 1.89920014,  9.00867716,  3.13710533,  5.62318272]) # random\n",
      "    \n",
      "    choice(...) method of numpy.random.mtrand.RandomState instance\n",
      "        choice(a, size=None, replace=True, p=None)\n",
      "        \n",
      "        Generates a random sample from a given 1-D array\n",
      "        \n",
      "        .. versionadded:: 1.7.0\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``choice`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : 1-D array-like or int\n",
      "            If an ndarray, a random sample is generated from its elements.\n",
      "            If an int, the random sample is generated as if a were np.arange(a)\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "            single value is returned.\n",
      "        replace : boolean, optional\n",
      "            Whether the sample is with or without replacement\n",
      "        p : 1-D array-like, optional\n",
      "            The probabilities associated with each entry in a.\n",
      "            If not given the sample assumes a uniform distribution over all\n",
      "            entries in a.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        samples : single item or ndarray\n",
      "            The generated random samples\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        ValueError\n",
      "            If a is an int and less than zero, if a or p are not 1-dimensional,\n",
      "            if a is an array-like of size 0, if p is not a vector of\n",
      "            probabilities, if a and p have different lengths, or if\n",
      "            replace=False and the sample size is greater than the population\n",
      "            size\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        randint, shuffle, permutation\n",
      "        Generator.choice: which should be used in new code\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Sampling random rows from a 2-D array is not possible with this function,\n",
      "        but is possible with `Generator.choice` through its ``axis`` keyword.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Generate a uniform random sample from np.arange(5) of size 3:\n",
      "        \n",
      "        >>> np.random.choice(5, 3)\n",
      "        array([0, 3, 4]) # random\n",
      "        >>> #This is equivalent to np.random.randint(0,5,3)\n",
      "        \n",
      "        Generate a non-uniform random sample from np.arange(5) of size 3:\n",
      "        \n",
      "        >>> np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])\n",
      "        array([3, 3, 0]) # random\n",
      "        \n",
      "        Generate a uniform random sample from np.arange(5) of size 3 without\n",
      "        replacement:\n",
      "        \n",
      "        >>> np.random.choice(5, 3, replace=False)\n",
      "        array([3,1,0]) # random\n",
      "        >>> #This is equivalent to np.random.permutation(np.arange(5))[:3]\n",
      "        \n",
      "        Generate a non-uniform random sample from np.arange(5) of size\n",
      "        3 without replacement:\n",
      "        \n",
      "        >>> np.random.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])\n",
      "        array([2, 3, 0]) # random\n",
      "        \n",
      "        Any of the above can be repeated with an arbitrary array-like\n",
      "        instead of just integers. For instance:\n",
      "        \n",
      "        >>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']\n",
      "        >>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])\n",
      "        array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], # random\n",
      "              dtype='<U11')\n",
      "    \n",
      "    default_rng(...)\n",
      "        Construct a new Generator with the default BitGenerator (PCG64).\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        seed : {None, int, array_like[ints], SeedSequence, BitGenerator, Generator}, optional\n",
      "            A seed to initialize the `BitGenerator`. If None, then fresh,\n",
      "            unpredictable entropy will be pulled from the OS. If an ``int`` or\n",
      "            ``array_like[ints]`` is passed, then it will be passed to\n",
      "            `SeedSequence` to derive the initial `BitGenerator` state. One may also\n",
      "            pass in a`SeedSequence` instance\n",
      "            Additionally, when passed a `BitGenerator`, it will be wrapped by\n",
      "            `Generator`. If passed a `Generator`, it will be returned unaltered.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Generator\n",
      "            The initialized generator object.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        If ``seed`` is not a `BitGenerator` or a `Generator`, a new `BitGenerator`\n",
      "        is instantiated. This function does not manage a default global instance.\n",
      "    \n",
      "    dirichlet(...) method of numpy.random.mtrand.RandomState instance\n",
      "        dirichlet(alpha, size=None)\n",
      "        \n",
      "        Draw samples from the Dirichlet distribution.\n",
      "        \n",
      "        Draw `size` samples of dimension k from a Dirichlet distribution. A\n",
      "        Dirichlet-distributed random variable can be seen as a multivariate\n",
      "        generalization of a Beta distribution. The Dirichlet distribution\n",
      "        is a conjugate prior of a multinomial distribution in Bayesian\n",
      "        inference.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``dirichlet`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        alpha : sequence of floats, length k\n",
      "            Parameter of the distribution (length ``k`` for sample of\n",
      "            length ``k``).\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n)``, then\n",
      "            ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "            vector of length ``k`` is returned.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        samples : ndarray,\n",
      "            The drawn samples, of shape ``(size, k)``.\n",
      "        \n",
      "        Raises\n",
      "        -------\n",
      "        ValueError\n",
      "            If any value in ``alpha`` is less than or equal to zero\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.dirichlet: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The Dirichlet distribution is a distribution over vectors\n",
      "        :math:`x` that fulfil the conditions :math:`x_i>0` and\n",
      "        :math:`\\sum_{i=1}^k x_i = 1`.\n",
      "        \n",
      "        The probability density function :math:`p` of a\n",
      "        Dirichlet-distributed random vector :math:`X` is\n",
      "        proportional to\n",
      "        \n",
      "        .. math:: p(x) \\propto \\prod_{i=1}^{k}{x^{\\alpha_i-1}_i},\n",
      "        \n",
      "        where :math:`\\alpha` is a vector containing the positive\n",
      "        concentration parameters.\n",
      "        \n",
      "        The method uses the following property for computation: let :math:`Y`\n",
      "        be a random vector which has components that follow a standard gamma\n",
      "        distribution, then :math:`X = \\frac{1}{\\sum_{i=1}^k{Y_i}} Y`\n",
      "        is Dirichlet-distributed\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] David McKay, \"Information Theory, Inference and Learning\n",
      "               Algorithms,\" chapter 23,\n",
      "               http://www.inference.org.uk/mackay/itila/\n",
      "        .. [2] Wikipedia, \"Dirichlet distribution\",\n",
      "               https://en.wikipedia.org/wiki/Dirichlet_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Taking an example cited in Wikipedia, this distribution can be used if\n",
      "        one wanted to cut strings (each of initial length 1.0) into K pieces\n",
      "        with different lengths, where each piece had, on average, a designated\n",
      "        average length, but allowing some variation in the relative sizes of\n",
      "        the pieces.\n",
      "        \n",
      "        >>> s = np.random.dirichlet((10, 5, 3), 20).transpose()\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> plt.barh(range(20), s[0])\n",
      "        >>> plt.barh(range(20), s[1], left=s[0], color='g')\n",
      "        >>> plt.barh(range(20), s[2], left=s[0]+s[1], color='r')\n",
      "        >>> plt.title(\"Lengths of Strings\")\n",
      "    \n",
      "    exponential(...) method of numpy.random.mtrand.RandomState instance\n",
      "        exponential(scale=1.0, size=None)\n",
      "        \n",
      "        Draw samples from an exponential distribution.\n",
      "        \n",
      "        Its probability density function is\n",
      "        \n",
      "        .. math:: f(x; \\frac{1}{\\beta}) = \\frac{1}{\\beta} \\exp(-\\frac{x}{\\beta}),\n",
      "        \n",
      "        for ``x > 0`` and 0 elsewhere. :math:`\\beta` is the scale parameter,\n",
      "        which is the inverse of the rate parameter :math:`\\lambda = 1/\\beta`.\n",
      "        The rate parameter is an alternative, widely used parameterization\n",
      "        of the exponential distribution [3]_.\n",
      "        \n",
      "        The exponential distribution is a continuous analogue of the\n",
      "        geometric distribution.  It describes many common situations, such as\n",
      "        the size of raindrops measured over many rainstorms [1]_, or the time\n",
      "        between page requests to Wikipedia [2]_.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``exponential`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        scale : float or array_like of floats\n",
      "            The scale parameter, :math:`\\beta = 1/\\lambda`. Must be\n",
      "            non-negative.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``scale`` is a scalar.  Otherwise,\n",
      "            ``np.array(scale).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized exponential distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.exponential: which should be used for new code.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Peyton Z. Peebles Jr., \"Probability, Random Variables and\n",
      "               Random Signal Principles\", 4th ed, 2001, p. 57.\n",
      "        .. [2] Wikipedia, \"Poisson process\",\n",
      "               https://en.wikipedia.org/wiki/Poisson_process\n",
      "        .. [3] Wikipedia, \"Exponential distribution\",\n",
      "               https://en.wikipedia.org/wiki/Exponential_distribution\n",
      "    \n",
      "    f(...) method of numpy.random.mtrand.RandomState instance\n",
      "        f(dfnum, dfden, size=None)\n",
      "        \n",
      "        Draw samples from an F distribution.\n",
      "        \n",
      "        Samples are drawn from an F distribution with specified parameters,\n",
      "        `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n",
      "        freedom in denominator), where both parameters must be greater than\n",
      "        zero.\n",
      "        \n",
      "        The random variate of the F distribution (also known as the\n",
      "        Fisher distribution) is a continuous probability distribution\n",
      "        that arises in ANOVA tests, and is the ratio of two chi-square\n",
      "        variates.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``f`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        dfnum : float or array_like of floats\n",
      "            Degrees of freedom in numerator, must be > 0.\n",
      "        dfden : float or array_like of float\n",
      "            Degrees of freedom in denominator, must be > 0.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``dfnum`` and ``dfden`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(dfnum, dfden).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized Fisher distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.f : probability density function, distribution or\n",
      "            cumulative density function, etc.\n",
      "        Generator.f: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The F statistic is used to compare in-group variances to between-group\n",
      "        variances. Calculating the distribution depends on the sampling, and\n",
      "        so it is a function of the respective degrees of freedom in the\n",
      "        problem.  The variable `dfnum` is the number of samples minus one, the\n",
      "        between-groups degrees of freedom, while `dfden` is the within-groups\n",
      "        degrees of freedom, the sum of the number of samples in each group\n",
      "        minus the number of groups.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n",
      "               Fifth Edition, 2002.\n",
      "        .. [2] Wikipedia, \"F-distribution\",\n",
      "               https://en.wikipedia.org/wiki/F-distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        An example from Glantz[1], pp 47-40:\n",
      "        \n",
      "        Two groups, children of diabetics (25 people) and children from people\n",
      "        without diabetes (25 controls). Fasting blood glucose was measured,\n",
      "        case group had a mean value of 86.1, controls had a mean value of\n",
      "        82.2. Standard deviations were 2.09 and 2.49 respectively. Are these\n",
      "        data consistent with the null hypothesis that the parents diabetic\n",
      "        status does not affect their children's blood glucose levels?\n",
      "        Calculating the F statistic from the data gives a value of 36.01.\n",
      "        \n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> dfnum = 1. # between group degrees of freedom\n",
      "        >>> dfden = 48. # within groups degrees of freedom\n",
      "        >>> s = np.random.f(dfnum, dfden, 1000)\n",
      "        \n",
      "        The lower bound for the top 1% of the samples is :\n",
      "        \n",
      "        >>> np.sort(s)[-10]\n",
      "        7.61988120985 # random\n",
      "        \n",
      "        So there is about a 1% chance that the F statistic will exceed 7.62,\n",
      "        the measured value is 36, so the null hypothesis is rejected at the 1%\n",
      "        level.\n",
      "    \n",
      "    gamma(...) method of numpy.random.mtrand.RandomState instance\n",
      "        gamma(shape, scale=1.0, size=None)\n",
      "        \n",
      "        Draw samples from a Gamma distribution.\n",
      "        \n",
      "        Samples are drawn from a Gamma distribution with specified parameters,\n",
      "        `shape` (sometimes designated \"k\") and `scale` (sometimes designated\n",
      "        \"theta\"), where both parameters are > 0.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``gamma`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        shape : float or array_like of floats\n",
      "            The shape of the gamma distribution. Must be non-negative.\n",
      "        scale : float or array_like of floats, optional\n",
      "            The scale of the gamma distribution. Must be non-negative.\n",
      "            Default is equal to 1.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``shape`` and ``scale`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(shape, scale).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized gamma distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.gamma : probability density function, distribution or\n",
      "            cumulative density function, etc.\n",
      "        Generator.gamma: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density for the Gamma distribution is\n",
      "        \n",
      "        .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n",
      "        \n",
      "        where :math:`k` is the shape and :math:`\\theta` the scale,\n",
      "        and :math:`\\Gamma` is the Gamma function.\n",
      "        \n",
      "        The Gamma distribution is often used to model the times to failure of\n",
      "        electronic components, and arises naturally in processes for which the\n",
      "        waiting times between Poisson distributed events are relevant.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n",
      "               Wolfram Web Resource.\n",
      "               http://mathworld.wolfram.com/GammaDistribution.html\n",
      "        .. [2] Wikipedia, \"Gamma distribution\",\n",
      "               https://en.wikipedia.org/wiki/Gamma_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> shape, scale = 2., 2.  # mean=4, std=2*sqrt(2)\n",
      "        >>> s = np.random.gamma(shape, scale, 1000)\n",
      "        \n",
      "        Display the histogram of the samples, along with\n",
      "        the probability density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> import scipy.special as sps  # doctest: +SKIP\n",
      "        >>> count, bins, ignored = plt.hist(s, 50, density=True)\n",
      "        >>> y = bins**(shape-1)*(np.exp(-bins/scale) /  # doctest: +SKIP\n",
      "        ...                      (sps.gamma(shape)*scale**shape))\n",
      "        >>> plt.plot(bins, y, linewidth=2, color='r')  # doctest: +SKIP\n",
      "        >>> plt.show()\n",
      "    \n",
      "    geometric(...) method of numpy.random.mtrand.RandomState instance\n",
      "        geometric(p, size=None)\n",
      "        \n",
      "        Draw samples from the geometric distribution.\n",
      "        \n",
      "        Bernoulli trials are experiments with one of two outcomes:\n",
      "        success or failure (an example of such an experiment is flipping\n",
      "        a coin).  The geometric distribution models the number of trials\n",
      "        that must be run in order to achieve success.  It is therefore\n",
      "        supported on the positive integers, ``k = 1, 2, ...``.\n",
      "        \n",
      "        The probability mass function of the geometric distribution is\n",
      "        \n",
      "        .. math:: f(k) = (1 - p)^{k - 1} p\n",
      "        \n",
      "        where `p` is the probability of success of an individual trial.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``geometric`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        p : float or array_like of floats\n",
      "            The probability of success of an individual trial.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``p`` is a scalar.  Otherwise,\n",
      "            ``np.array(p).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized geometric distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.geometric: which should be used for new code.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw ten thousand values from the geometric distribution,\n",
      "        with the probability of an individual success equal to 0.35:\n",
      "        \n",
      "        >>> z = np.random.geometric(p=0.35, size=10000)\n",
      "        \n",
      "        How many trials succeeded after a single run?\n",
      "        \n",
      "        >>> (z == 1).sum() / 10000.\n",
      "        0.34889999999999999 #random\n",
      "    \n",
      "    get_state(...) method of numpy.random.mtrand.RandomState instance\n",
      "        get_state()\n",
      "        \n",
      "        Return a tuple representing the internal state of the generator.\n",
      "        \n",
      "        For more details, see `set_state`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        legacy : bool, optional\n",
      "            Flag indicating to return a legacy tuple state when the BitGenerator\n",
      "            is MT19937, instead of a dict.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : {tuple(str, ndarray of 624 uints, int, int, float), dict}\n",
      "            The returned tuple has the following items:\n",
      "        \n",
      "            1. the string 'MT19937'.\n",
      "            2. a 1-D array of 624 unsigned integer keys.\n",
      "            3. an integer ``pos``.\n",
      "            4. an integer ``has_gauss``.\n",
      "            5. a float ``cached_gaussian``.\n",
      "        \n",
      "            If `legacy` is False, or the BitGenerator is not MT19937, then\n",
      "            state is returned as a dictionary.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        set_state\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        `set_state` and `get_state` are not needed to work with any of the\n",
      "        random distributions in NumPy. If the internal state is manually altered,\n",
      "        the user should know exactly what he/she is doing.\n",
      "    \n",
      "    gumbel(...) method of numpy.random.mtrand.RandomState instance\n",
      "        gumbel(loc=0.0, scale=1.0, size=None)\n",
      "        \n",
      "        Draw samples from a Gumbel distribution.\n",
      "        \n",
      "        Draw samples from a Gumbel distribution with specified location and\n",
      "        scale.  For more information on the Gumbel distribution, see\n",
      "        Notes and References below.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``gumbel`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        loc : float or array_like of floats, optional\n",
      "            The location of the mode of the distribution. Default is 0.\n",
      "        scale : float or array_like of floats, optional\n",
      "            The scale parameter of the distribution. Default is 1. Must be non-\n",
      "            negative.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized Gumbel distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.gumbel_l\n",
      "        scipy.stats.gumbel_r\n",
      "        scipy.stats.genextreme\n",
      "        weibull\n",
      "        Generator.gumbel: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The Gumbel (or Smallest Extreme Value (SEV) or the Smallest Extreme\n",
      "        Value Type I) distribution is one of a class of Generalized Extreme\n",
      "        Value (GEV) distributions used in modeling extreme value problems.\n",
      "        The Gumbel is a special case of the Extreme Value Type I distribution\n",
      "        for maximums from distributions with \"exponential-like\" tails.\n",
      "        \n",
      "        The probability density for the Gumbel distribution is\n",
      "        \n",
      "        .. math:: p(x) = \\frac{e^{-(x - \\mu)/ \\beta}}{\\beta} e^{ -e^{-(x - \\mu)/\n",
      "                  \\beta}},\n",
      "        \n",
      "        where :math:`\\mu` is the mode, a location parameter, and\n",
      "        :math:`\\beta` is the scale parameter.\n",
      "        \n",
      "        The Gumbel (named for German mathematician Emil Julius Gumbel) was used\n",
      "        very early in the hydrology literature, for modeling the occurrence of\n",
      "        flood events. It is also used for modeling maximum wind speed and\n",
      "        rainfall rates.  It is a \"fat-tailed\" distribution - the probability of\n",
      "        an event in the tail of the distribution is larger than if one used a\n",
      "        Gaussian, hence the surprisingly frequent occurrence of 100-year\n",
      "        floods. Floods were initially modeled as a Gaussian process, which\n",
      "        underestimated the frequency of extreme events.\n",
      "        \n",
      "        It is one of a class of extreme value distributions, the Generalized\n",
      "        Extreme Value (GEV) distributions, which also includes the Weibull and\n",
      "        Frechet.\n",
      "        \n",
      "        The function has a mean of :math:`\\mu + 0.57721\\beta` and a variance\n",
      "        of :math:`\\frac{\\pi^2}{6}\\beta^2`.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Gumbel, E. J., \"Statistics of Extremes,\"\n",
      "               New York: Columbia University Press, 1958.\n",
      "        .. [2] Reiss, R.-D. and Thomas, M., \"Statistical Analysis of Extreme\n",
      "               Values from Insurance, Finance, Hydrology and Other Fields,\"\n",
      "               Basel: Birkhauser Verlag, 2001.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> mu, beta = 0, 0.1 # location and scale\n",
      "        >>> s = np.random.gumbel(mu, beta, 1000)\n",
      "        \n",
      "        Display the histogram of the samples, along with\n",
      "        the probability density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> count, bins, ignored = plt.hist(s, 30, density=True)\n",
      "        >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n",
      "        ...          * np.exp( -np.exp( -(bins - mu) /beta) ),\n",
      "        ...          linewidth=2, color='r')\n",
      "        >>> plt.show()\n",
      "        \n",
      "        Show how an extreme value distribution can arise from a Gaussian process\n",
      "        and compare to a Gaussian:\n",
      "        \n",
      "        >>> means = []\n",
      "        >>> maxima = []\n",
      "        >>> for i in range(0,1000) :\n",
      "        ...    a = np.random.normal(mu, beta, 1000)\n",
      "        ...    means.append(a.mean())\n",
      "        ...    maxima.append(a.max())\n",
      "        >>> count, bins, ignored = plt.hist(maxima, 30, density=True)\n",
      "        >>> beta = np.std(maxima) * np.sqrt(6) / np.pi\n",
      "        >>> mu = np.mean(maxima) - 0.57721*beta\n",
      "        >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n",
      "        ...          * np.exp(-np.exp(-(bins - mu)/beta)),\n",
      "        ...          linewidth=2, color='r')\n",
      "        >>> plt.plot(bins, 1/(beta * np.sqrt(2 * np.pi))\n",
      "        ...          * np.exp(-(bins - mu)**2 / (2 * beta**2)),\n",
      "        ...          linewidth=2, color='g')\n",
      "        >>> plt.show()\n",
      "    \n",
      "    hypergeometric(...) method of numpy.random.mtrand.RandomState instance\n",
      "        hypergeometric(ngood, nbad, nsample, size=None)\n",
      "        \n",
      "        Draw samples from a Hypergeometric distribution.\n",
      "        \n",
      "        Samples are drawn from a hypergeometric distribution with specified\n",
      "        parameters, `ngood` (ways to make a good selection), `nbad` (ways to make\n",
      "        a bad selection), and `nsample` (number of items sampled, which is less\n",
      "        than or equal to the sum ``ngood + nbad``).\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``hypergeometric`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        ngood : int or array_like of ints\n",
      "            Number of ways to make a good selection.  Must be nonnegative.\n",
      "        nbad : int or array_like of ints\n",
      "            Number of ways to make a bad selection.  Must be nonnegative.\n",
      "        nsample : int or array_like of ints\n",
      "            Number of items sampled.  Must be at least 1 and at most\n",
      "            ``ngood + nbad``.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if `ngood`, `nbad`, and `nsample`\n",
      "            are all scalars.  Otherwise, ``np.broadcast(ngood, nbad, nsample).size``\n",
      "            samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized hypergeometric distribution. Each\n",
      "            sample is the number of good items within a randomly selected subset of\n",
      "            size `nsample` taken from a set of `ngood` good items and `nbad` bad items.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.hypergeom : probability density function, distribution or\n",
      "            cumulative density function, etc.\n",
      "        Generator.hypergeometric: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density for the Hypergeometric distribution is\n",
      "        \n",
      "        .. math:: P(x) = \\frac{\\binom{g}{x}\\binom{b}{n-x}}{\\binom{g+b}{n}},\n",
      "        \n",
      "        where :math:`0 \\le x \\le n` and :math:`n-b \\le x \\le g`\n",
      "        \n",
      "        for P(x) the probability of ``x`` good results in the drawn sample,\n",
      "        g = `ngood`, b = `nbad`, and n = `nsample`.\n",
      "        \n",
      "        Consider an urn with black and white marbles in it, `ngood` of them\n",
      "        are black and `nbad` are white. If you draw `nsample` balls without\n",
      "        replacement, then the hypergeometric distribution describes the\n",
      "        distribution of black balls in the drawn sample.\n",
      "        \n",
      "        Note that this distribution is very similar to the binomial\n",
      "        distribution, except that in this case, samples are drawn without\n",
      "        replacement, whereas in the Binomial case samples are drawn with\n",
      "        replacement (or the sample space is infinite). As the sample space\n",
      "        becomes large, this distribution approaches the binomial.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n",
      "               and Quigley, 1972.\n",
      "        .. [2] Weisstein, Eric W. \"Hypergeometric Distribution.\" From\n",
      "               MathWorld--A Wolfram Web Resource.\n",
      "               http://mathworld.wolfram.com/HypergeometricDistribution.html\n",
      "        .. [3] Wikipedia, \"Hypergeometric distribution\",\n",
      "               https://en.wikipedia.org/wiki/Hypergeometric_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> ngood, nbad, nsamp = 100, 2, 10\n",
      "        # number of good, number of bad, and number of samples\n",
      "        >>> s = np.random.hypergeometric(ngood, nbad, nsamp, 1000)\n",
      "        >>> from matplotlib.pyplot import hist\n",
      "        >>> hist(s)\n",
      "        #   note that it is very unlikely to grab both bad items\n",
      "        \n",
      "        Suppose you have an urn with 15 white and 15 black marbles.\n",
      "        If you pull 15 marbles at random, how likely is it that\n",
      "        12 or more of them are one color?\n",
      "        \n",
      "        >>> s = np.random.hypergeometric(15, 15, 15, 100000)\n",
      "        >>> sum(s>=12)/100000. + sum(s<=3)/100000.\n",
      "        #   answer = 0.003 ... pretty unlikely!\n",
      "    \n",
      "    laplace(...) method of numpy.random.mtrand.RandomState instance\n",
      "        laplace(loc=0.0, scale=1.0, size=None)\n",
      "        \n",
      "        Draw samples from the Laplace or double exponential distribution with\n",
      "        specified location (or mean) and scale (decay).\n",
      "        \n",
      "        The Laplace distribution is similar to the Gaussian/normal distribution,\n",
      "        but is sharper at the peak and has fatter tails. It represents the\n",
      "        difference between two independent, identically distributed exponential\n",
      "        random variables.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``laplace`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        loc : float or array_like of floats, optional\n",
      "            The position, :math:`\\mu`, of the distribution peak. Default is 0.\n",
      "        scale : float or array_like of floats, optional\n",
      "            :math:`\\lambda`, the exponential decay. Default is 1. Must be non-\n",
      "            negative.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized Laplace distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.laplace: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        It has the probability density function\n",
      "        \n",
      "        .. math:: f(x; \\mu, \\lambda) = \\frac{1}{2\\lambda}\n",
      "                                       \\exp\\left(-\\frac{|x - \\mu|}{\\lambda}\\right).\n",
      "        \n",
      "        The first law of Laplace, from 1774, states that the frequency\n",
      "        of an error can be expressed as an exponential function of the\n",
      "        absolute magnitude of the error, which leads to the Laplace\n",
      "        distribution. For many problems in economics and health\n",
      "        sciences, this distribution seems to model the data better\n",
      "        than the standard Gaussian distribution.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n",
      "               Mathematical Functions with Formulas, Graphs, and Mathematical\n",
      "               Tables, 9th printing,\" New York: Dover, 1972.\n",
      "        .. [2] Kotz, Samuel, et. al. \"The Laplace Distribution and\n",
      "               Generalizations, \" Birkhauser, 2001.\n",
      "        .. [3] Weisstein, Eric W. \"Laplace Distribution.\"\n",
      "               From MathWorld--A Wolfram Web Resource.\n",
      "               http://mathworld.wolfram.com/LaplaceDistribution.html\n",
      "        .. [4] Wikipedia, \"Laplace distribution\",\n",
      "               https://en.wikipedia.org/wiki/Laplace_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution\n",
      "        \n",
      "        >>> loc, scale = 0., 1.\n",
      "        >>> s = np.random.laplace(loc, scale, 1000)\n",
      "        \n",
      "        Display the histogram of the samples, along with\n",
      "        the probability density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> count, bins, ignored = plt.hist(s, 30, density=True)\n",
      "        >>> x = np.arange(-8., 8., .01)\n",
      "        >>> pdf = np.exp(-abs(x-loc)/scale)/(2.*scale)\n",
      "        >>> plt.plot(x, pdf)\n",
      "        \n",
      "        Plot Gaussian for comparison:\n",
      "        \n",
      "        >>> g = (1/(scale * np.sqrt(2 * np.pi)) *\n",
      "        ...      np.exp(-(x - loc)**2 / (2 * scale**2)))\n",
      "        >>> plt.plot(x,g)\n",
      "    \n",
      "    logistic(...) method of numpy.random.mtrand.RandomState instance\n",
      "        logistic(loc=0.0, scale=1.0, size=None)\n",
      "        \n",
      "        Draw samples from a logistic distribution.\n",
      "        \n",
      "        Samples are drawn from a logistic distribution with specified\n",
      "        parameters, loc (location or mean, also median), and scale (>0).\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``logistic`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        loc : float or array_like of floats, optional\n",
      "            Parameter of the distribution. Default is 0.\n",
      "        scale : float or array_like of floats, optional\n",
      "            Parameter of the distribution. Must be non-negative.\n",
      "            Default is 1.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized logistic distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.logistic : probability density function, distribution or\n",
      "            cumulative density function, etc.\n",
      "        Generator.logistic: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density for the Logistic distribution is\n",
      "        \n",
      "        .. math:: P(x) = P(x) = \\frac{e^{-(x-\\mu)/s}}{s(1+e^{-(x-\\mu)/s})^2},\n",
      "        \n",
      "        where :math:`\\mu` = location and :math:`s` = scale.\n",
      "        \n",
      "        The Logistic distribution is used in Extreme Value problems where it\n",
      "        can act as a mixture of Gumbel distributions, in Epidemiology, and by\n",
      "        the World Chess Federation (FIDE) where it is used in the Elo ranking\n",
      "        system, assuming the performance of each player is a logistically\n",
      "        distributed random variable.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Reiss, R.-D. and Thomas M. (2001), \"Statistical Analysis of\n",
      "               Extreme Values, from Insurance, Finance, Hydrology and Other\n",
      "               Fields,\" Birkhauser Verlag, Basel, pp 132-133.\n",
      "        .. [2] Weisstein, Eric W. \"Logistic Distribution.\" From\n",
      "               MathWorld--A Wolfram Web Resource.\n",
      "               http://mathworld.wolfram.com/LogisticDistribution.html\n",
      "        .. [3] Wikipedia, \"Logistic-distribution\",\n",
      "               https://en.wikipedia.org/wiki/Logistic_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> loc, scale = 10, 1\n",
      "        >>> s = np.random.logistic(loc, scale, 10000)\n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> count, bins, ignored = plt.hist(s, bins=50)\n",
      "        \n",
      "        #   plot against distribution\n",
      "        \n",
      "        >>> def logist(x, loc, scale):\n",
      "        ...     return np.exp((loc-x)/scale)/(scale*(1+np.exp((loc-x)/scale))**2)\n",
      "        >>> lgst_val = logist(bins, loc, scale)\n",
      "        >>> plt.plot(bins, lgst_val * count.max() / lgst_val.max())\n",
      "        >>> plt.show()\n",
      "    \n",
      "    lognormal(...) method of numpy.random.mtrand.RandomState instance\n",
      "        lognormal(mean=0.0, sigma=1.0, size=None)\n",
      "        \n",
      "        Draw samples from a log-normal distribution.\n",
      "        \n",
      "        Draw samples from a log-normal distribution with specified mean,\n",
      "        standard deviation, and array shape.  Note that the mean and standard\n",
      "        deviation are not the values for the distribution itself, but of the\n",
      "        underlying normal distribution it is derived from.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``lognormal`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        mean : float or array_like of floats, optional\n",
      "            Mean value of the underlying normal distribution. Default is 0.\n",
      "        sigma : float or array_like of floats, optional\n",
      "            Standard deviation of the underlying normal distribution. Must be\n",
      "            non-negative. Default is 1.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``mean`` and ``sigma`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(mean, sigma).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized log-normal distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.lognorm : probability density function, distribution,\n",
      "            cumulative density function, etc.\n",
      "        Generator.lognormal: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        A variable `x` has a log-normal distribution if `log(x)` is normally\n",
      "        distributed.  The probability density function for the log-normal\n",
      "        distribution is:\n",
      "        \n",
      "        .. math:: p(x) = \\frac{1}{\\sigma x \\sqrt{2\\pi}}\n",
      "                         e^{(-\\frac{(ln(x)-\\mu)^2}{2\\sigma^2})}\n",
      "        \n",
      "        where :math:`\\mu` is the mean and :math:`\\sigma` is the standard\n",
      "        deviation of the normally distributed logarithm of the variable.\n",
      "        A log-normal distribution results if a random variable is the *product*\n",
      "        of a large number of independent, identically-distributed variables in\n",
      "        the same way that a normal distribution results if the variable is the\n",
      "        *sum* of a large number of independent, identically-distributed\n",
      "        variables.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Limpert, E., Stahel, W. A., and Abbt, M., \"Log-normal\n",
      "               Distributions across the Sciences: Keys and Clues,\"\n",
      "               BioScience, Vol. 51, No. 5, May, 2001.\n",
      "               https://stat.ethz.ch/~stahel/lognormal/bioscience.pdf\n",
      "        .. [2] Reiss, R.D. and Thomas, M., \"Statistical Analysis of Extreme\n",
      "               Values,\" Basel: Birkhauser Verlag, 2001, pp. 31-32.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> mu, sigma = 3., 1. # mean and standard deviation\n",
      "        >>> s = np.random.lognormal(mu, sigma, 1000)\n",
      "        \n",
      "        Display the histogram of the samples, along with\n",
      "        the probability density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> count, bins, ignored = plt.hist(s, 100, density=True, align='mid')\n",
      "        \n",
      "        >>> x = np.linspace(min(bins), max(bins), 10000)\n",
      "        >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n",
      "        ...        / (x * sigma * np.sqrt(2 * np.pi)))\n",
      "        \n",
      "        >>> plt.plot(x, pdf, linewidth=2, color='r')\n",
      "        >>> plt.axis('tight')\n",
      "        >>> plt.show()\n",
      "        \n",
      "        Demonstrate that taking the products of random samples from a uniform\n",
      "        distribution can be fit well by a log-normal probability density\n",
      "        function.\n",
      "        \n",
      "        >>> # Generate a thousand samples: each is the product of 100 random\n",
      "        >>> # values, drawn from a normal distribution.\n",
      "        >>> b = []\n",
      "        >>> for i in range(1000):\n",
      "        ...    a = 10. + np.random.standard_normal(100)\n",
      "        ...    b.append(np.product(a))\n",
      "        \n",
      "        >>> b = np.array(b) / np.min(b) # scale values to be positive\n",
      "        >>> count, bins, ignored = plt.hist(b, 100, density=True, align='mid')\n",
      "        >>> sigma = np.std(np.log(b))\n",
      "        >>> mu = np.mean(np.log(b))\n",
      "        \n",
      "        >>> x = np.linspace(min(bins), max(bins), 10000)\n",
      "        >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n",
      "        ...        / (x * sigma * np.sqrt(2 * np.pi)))\n",
      "        \n",
      "        >>> plt.plot(x, pdf, color='r', linewidth=2)\n",
      "        >>> plt.show()\n",
      "    \n",
      "    logseries(...) method of numpy.random.mtrand.RandomState instance\n",
      "        logseries(p, size=None)\n",
      "        \n",
      "        Draw samples from a logarithmic series distribution.\n",
      "        \n",
      "        Samples are drawn from a log series distribution with specified\n",
      "        shape parameter, 0 < ``p`` < 1.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``logseries`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        p : float or array_like of floats\n",
      "            Shape parameter for the distribution.  Must be in the range (0, 1).\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``p`` is a scalar.  Otherwise,\n",
      "            ``np.array(p).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized logarithmic series distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.logser : probability density function, distribution or\n",
      "            cumulative density function, etc.\n",
      "        Generator.logseries: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density for the Log Series distribution is\n",
      "        \n",
      "        .. math:: P(k) = \\frac{-p^k}{k \\ln(1-p)},\n",
      "        \n",
      "        where p = probability.\n",
      "        \n",
      "        The log series distribution is frequently used to represent species\n",
      "        richness and occurrence, first proposed by Fisher, Corbet, and\n",
      "        Williams in 1943 [2].  It may also be used to model the numbers of\n",
      "        occupants seen in cars [3].\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Buzas, Martin A.; Culver, Stephen J.,  Understanding regional\n",
      "               species diversity through the log series distribution of\n",
      "               occurrences: BIODIVERSITY RESEARCH Diversity & Distributions,\n",
      "               Volume 5, Number 5, September 1999 , pp. 187-195(9).\n",
      "        .. [2] Fisher, R.A,, A.S. Corbet, and C.B. Williams. 1943. The\n",
      "               relation between the number of species and the number of\n",
      "               individuals in a random sample of an animal population.\n",
      "               Journal of Animal Ecology, 12:42-58.\n",
      "        .. [3] D. J. Hand, F. Daly, D. Lunn, E. Ostrowski, A Handbook of Small\n",
      "               Data Sets, CRC Press, 1994.\n",
      "        .. [4] Wikipedia, \"Logarithmic distribution\",\n",
      "               https://en.wikipedia.org/wiki/Logarithmic_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> a = .6\n",
      "        >>> s = np.random.logseries(a, 10000)\n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> count, bins, ignored = plt.hist(s)\n",
      "        \n",
      "        #   plot against distribution\n",
      "        \n",
      "        >>> def logseries(k, p):\n",
      "        ...     return -p**k/(k*np.log(1-p))\n",
      "        >>> plt.plot(bins, logseries(bins, a)*count.max()/\n",
      "        ...          logseries(bins, a).max(), 'r')\n",
      "        >>> plt.show()\n",
      "    \n",
      "    multinomial(...) method of numpy.random.mtrand.RandomState instance\n",
      "        multinomial(n, pvals, size=None)\n",
      "        \n",
      "        Draw samples from a multinomial distribution.\n",
      "        \n",
      "        The multinomial distribution is a multivariate generalization of the\n",
      "        binomial distribution.  Take an experiment with one of ``p``\n",
      "        possible outcomes.  An example of such an experiment is throwing a dice,\n",
      "        where the outcome can be 1 through 6.  Each sample drawn from the\n",
      "        distribution represents `n` such experiments.  Its values,\n",
      "        ``X_i = [X_0, X_1, ..., X_p]``, represent the number of times the\n",
      "        outcome was ``i``.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``multinomial`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        n : int\n",
      "            Number of experiments.\n",
      "        pvals : sequence of floats, length p\n",
      "            Probabilities of each of the ``p`` different outcomes.  These\n",
      "            must sum to 1 (however, the last element is always assumed to\n",
      "            account for the remaining probability, as long as\n",
      "            ``sum(pvals[:-1]) <= 1)``.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "            single value is returned.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray\n",
      "            The drawn samples, of shape *size*, if that was provided.  If not,\n",
      "            the shape is ``(N,)``.\n",
      "        \n",
      "            In other words, each entry ``out[i,j,...,:]`` is an N-dimensional\n",
      "            value drawn from the distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.multinomial: which should be used for new code.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Throw a dice 20 times:\n",
      "        \n",
      "        >>> np.random.multinomial(20, [1/6.]*6, size=1)\n",
      "        array([[4, 1, 7, 5, 2, 1]]) # random\n",
      "        \n",
      "        It landed 4 times on 1, once on 2, etc.\n",
      "        \n",
      "        Now, throw the dice 20 times, and 20 times again:\n",
      "        \n",
      "        >>> np.random.multinomial(20, [1/6.]*6, size=2)\n",
      "        array([[3, 4, 3, 3, 4, 3], # random\n",
      "               [2, 4, 3, 4, 0, 7]])\n",
      "        \n",
      "        For the first run, we threw 3 times 1, 4 times 2, etc.  For the second,\n",
      "        we threw 2 times 1, 4 times 2, etc.\n",
      "        \n",
      "        A loaded die is more likely to land on number 6:\n",
      "        \n",
      "        >>> np.random.multinomial(100, [1/7.]*5 + [2/7.])\n",
      "        array([11, 16, 14, 17, 16, 26]) # random\n",
      "        \n",
      "        The probability inputs should be normalized. As an implementation\n",
      "        detail, the value of the last entry is ignored and assumed to take\n",
      "        up any leftover probability mass, but this should not be relied on.\n",
      "        A biased coin which has twice as much weight on one side as on the\n",
      "        other should be sampled like so:\n",
      "        \n",
      "        >>> np.random.multinomial(100, [1.0 / 3, 2.0 / 3])  # RIGHT\n",
      "        array([38, 62]) # random\n",
      "        \n",
      "        not like:\n",
      "        \n",
      "        >>> np.random.multinomial(100, [1.0, 2.0])  # WRONG\n",
      "        Traceback (most recent call last):\n",
      "        ValueError: pvals < 0, pvals > 1 or pvals contains NaNs\n",
      "    \n",
      "    multivariate_normal(...) method of numpy.random.mtrand.RandomState instance\n",
      "        multivariate_normal(mean, cov, size=None, check_valid='warn', tol=1e-8)\n",
      "        \n",
      "        Draw random samples from a multivariate normal distribution.\n",
      "        \n",
      "        The multivariate normal, multinormal or Gaussian distribution is a\n",
      "        generalization of the one-dimensional normal distribution to higher\n",
      "        dimensions.  Such a distribution is specified by its mean and\n",
      "        covariance matrix.  These parameters are analogous to the mean\n",
      "        (average or \"center\") and variance (standard deviation, or \"width,\"\n",
      "        squared) of the one-dimensional normal distribution.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``multivariate_normal`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        mean : 1-D array_like, of length N\n",
      "            Mean of the N-dimensional distribution.\n",
      "        cov : 2-D array_like, of shape (N, N)\n",
      "            Covariance matrix of the distribution. It must be symmetric and\n",
      "            positive-semidefinite for proper sampling.\n",
      "        size : int or tuple of ints, optional\n",
      "            Given a shape of, for example, ``(m,n,k)``, ``m*n*k`` samples are\n",
      "            generated, and packed in an `m`-by-`n`-by-`k` arrangement.  Because\n",
      "            each sample is `N`-dimensional, the output shape is ``(m,n,k,N)``.\n",
      "            If no shape is specified, a single (`N`-D) sample is returned.\n",
      "        check_valid : { 'warn', 'raise', 'ignore' }, optional\n",
      "            Behavior when the covariance matrix is not positive semidefinite.\n",
      "        tol : float, optional\n",
      "            Tolerance when checking the singular values in covariance matrix.\n",
      "            cov is cast to double before the check.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray\n",
      "            The drawn samples, of shape *size*, if that was provided.  If not,\n",
      "            the shape is ``(N,)``.\n",
      "        \n",
      "            In other words, each entry ``out[i,j,...,:]`` is an N-dimensional\n",
      "            value drawn from the distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.multivariate_normal: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The mean is a coordinate in N-dimensional space, which represents the\n",
      "        location where samples are most likely to be generated.  This is\n",
      "        analogous to the peak of the bell curve for the one-dimensional or\n",
      "        univariate normal distribution.\n",
      "        \n",
      "        Covariance indicates the level to which two variables vary together.\n",
      "        From the multivariate normal distribution, we draw N-dimensional\n",
      "        samples, :math:`X = [x_1, x_2, ... x_N]`.  The covariance matrix\n",
      "        element :math:`C_{ij}` is the covariance of :math:`x_i` and :math:`x_j`.\n",
      "        The element :math:`C_{ii}` is the variance of :math:`x_i` (i.e. its\n",
      "        \"spread\").\n",
      "        \n",
      "        Instead of specifying the full covariance matrix, popular\n",
      "        approximations include:\n",
      "        \n",
      "          - Spherical covariance (`cov` is a multiple of the identity matrix)\n",
      "          - Diagonal covariance (`cov` has non-negative elements, and only on\n",
      "            the diagonal)\n",
      "        \n",
      "        This geometrical property can be seen in two dimensions by plotting\n",
      "        generated data-points:\n",
      "        \n",
      "        >>> mean = [0, 0]\n",
      "        >>> cov = [[1, 0], [0, 100]]  # diagonal covariance\n",
      "        \n",
      "        Diagonal covariance means that points are oriented along x or y-axis:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> x, y = np.random.multivariate_normal(mean, cov, 5000).T\n",
      "        >>> plt.plot(x, y, 'x')\n",
      "        >>> plt.axis('equal')\n",
      "        >>> plt.show()\n",
      "        \n",
      "        Note that the covariance matrix must be positive semidefinite (a.k.a.\n",
      "        nonnegative-definite). Otherwise, the behavior of this method is\n",
      "        undefined and backwards compatibility is not guaranteed.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Papoulis, A., \"Probability, Random Variables, and Stochastic\n",
      "               Processes,\" 3rd ed., New York: McGraw-Hill, 1991.\n",
      "        .. [2] Duda, R. O., Hart, P. E., and Stork, D. G., \"Pattern\n",
      "               Classification,\" 2nd ed., New York: Wiley, 2001.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> mean = (1, 2)\n",
      "        >>> cov = [[1, 0], [0, 1]]\n",
      "        >>> x = np.random.multivariate_normal(mean, cov, (3, 3))\n",
      "        >>> x.shape\n",
      "        (3, 3, 2)\n",
      "        \n",
      "        The following is probably true, given that 0.6 is roughly twice the\n",
      "        standard deviation:\n",
      "        \n",
      "        >>> list((x[0,0,:] - mean) < 0.6)\n",
      "        [True, True] # random\n",
      "    \n",
      "    negative_binomial(...) method of numpy.random.mtrand.RandomState instance\n",
      "        negative_binomial(n, p, size=None)\n",
      "        \n",
      "        Draw samples from a negative binomial distribution.\n",
      "        \n",
      "        Samples are drawn from a negative binomial distribution with specified\n",
      "        parameters, `n` successes and `p` probability of success where `n`\n",
      "        is > 0 and `p` is in the interval [0, 1].\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``negative_binomial`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        n : float or array_like of floats\n",
      "            Parameter of the distribution, > 0.\n",
      "        p : float or array_like of floats\n",
      "            Parameter of the distribution, >= 0 and <=1.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``n`` and ``p`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized negative binomial distribution,\n",
      "            where each sample is equal to N, the number of failures that\n",
      "            occurred before a total of n successes was reached.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.negative_binomial: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability mass function of the negative binomial distribution is\n",
      "        \n",
      "        .. math:: P(N;n,p) = \\frac{\\Gamma(N+n)}{N!\\Gamma(n)}p^{n}(1-p)^{N},\n",
      "        \n",
      "        where :math:`n` is the number of successes, :math:`p` is the\n",
      "        probability of success, :math:`N+n` is the number of trials, and\n",
      "        :math:`\\Gamma` is the gamma function. When :math:`n` is an integer,\n",
      "        :math:`\\frac{\\Gamma(N+n)}{N!\\Gamma(n)} = \\binom{N+n-1}{N}`, which is\n",
      "        the more common form of this term in the the pmf. The negative\n",
      "        binomial distribution gives the probability of N failures given n\n",
      "        successes, with a success on the last trial.\n",
      "        \n",
      "        If one throws a die repeatedly until the third time a \"1\" appears,\n",
      "        then the probability distribution of the number of non-\"1\"s that\n",
      "        appear before the third \"1\" is a negative binomial distribution.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Weisstein, Eric W. \"Negative Binomial Distribution.\" From\n",
      "               MathWorld--A Wolfram Web Resource.\n",
      "               http://mathworld.wolfram.com/NegativeBinomialDistribution.html\n",
      "        .. [2] Wikipedia, \"Negative binomial distribution\",\n",
      "               https://en.wikipedia.org/wiki/Negative_binomial_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        A real world example. A company drills wild-cat oil\n",
      "        exploration wells, each with an estimated probability of\n",
      "        success of 0.1.  What is the probability of having one success\n",
      "        for each successive well, that is what is the probability of a\n",
      "        single success after drilling 5 wells, after 6 wells, etc.?\n",
      "        \n",
      "        >>> s = np.random.negative_binomial(1, 0.1, 100000)\n",
      "        >>> for i in range(1, 11): # doctest: +SKIP\n",
      "        ...    probability = sum(s<i) / 100000.\n",
      "        ...    print(i, \"wells drilled, probability of one success =\", probability)\n",
      "    \n",
      "    noncentral_chisquare(...) method of numpy.random.mtrand.RandomState instance\n",
      "        noncentral_chisquare(df, nonc, size=None)\n",
      "        \n",
      "        Draw samples from a noncentral chi-square distribution.\n",
      "        \n",
      "        The noncentral :math:`\\chi^2` distribution is a generalization of\n",
      "        the :math:`\\chi^2` distribution.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``noncentral_chisquare`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        df : float or array_like of floats\n",
      "            Degrees of freedom, must be > 0.\n",
      "        \n",
      "            .. versionchanged:: 1.10.0\n",
      "               Earlier NumPy versions required dfnum > 1.\n",
      "        nonc : float or array_like of floats\n",
      "            Non-centrality, must be non-negative.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``df`` and ``nonc`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(df, nonc).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized noncentral chi-square distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.noncentral_chisquare: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density function for the noncentral Chi-square\n",
      "        distribution is\n",
      "        \n",
      "        .. math:: P(x;df,nonc) = \\sum^{\\infty}_{i=0}\n",
      "                               \\frac{e^{-nonc/2}(nonc/2)^{i}}{i!}\n",
      "                               P_{Y_{df+2i}}(x),\n",
      "        \n",
      "        where :math:`Y_{q}` is the Chi-square with q degrees of freedom.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Wikipedia, \"Noncentral chi-squared distribution\"\n",
      "               https://en.wikipedia.org/wiki/Noncentral_chi-squared_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw values from the distribution and plot the histogram\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> values = plt.hist(np.random.noncentral_chisquare(3, 20, 100000),\n",
      "        ...                   bins=200, density=True)\n",
      "        >>> plt.show()\n",
      "        \n",
      "        Draw values from a noncentral chisquare with very small noncentrality,\n",
      "        and compare to a chisquare.\n",
      "        \n",
      "        >>> plt.figure()\n",
      "        >>> values = plt.hist(np.random.noncentral_chisquare(3, .0000001, 100000),\n",
      "        ...                   bins=np.arange(0., 25, .1), density=True)\n",
      "        >>> values2 = plt.hist(np.random.chisquare(3, 100000),\n",
      "        ...                    bins=np.arange(0., 25, .1), density=True)\n",
      "        >>> plt.plot(values[1][0:-1], values[0]-values2[0], 'ob')\n",
      "        >>> plt.show()\n",
      "        \n",
      "        Demonstrate how large values of non-centrality lead to a more symmetric\n",
      "        distribution.\n",
      "        \n",
      "        >>> plt.figure()\n",
      "        >>> values = plt.hist(np.random.noncentral_chisquare(3, 20, 100000),\n",
      "        ...                   bins=200, density=True)\n",
      "        >>> plt.show()\n",
      "    \n",
      "    noncentral_f(...) method of numpy.random.mtrand.RandomState instance\n",
      "        noncentral_f(dfnum, dfden, nonc, size=None)\n",
      "        \n",
      "        Draw samples from the noncentral F distribution.\n",
      "        \n",
      "        Samples are drawn from an F distribution with specified parameters,\n",
      "        `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n",
      "        freedom in denominator), where both parameters > 1.\n",
      "        `nonc` is the non-centrality parameter.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``noncentral_f`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        dfnum : float or array_like of floats\n",
      "            Numerator degrees of freedom, must be > 0.\n",
      "        \n",
      "            .. versionchanged:: 1.14.0\n",
      "               Earlier NumPy versions required dfnum > 1.\n",
      "        dfden : float or array_like of floats\n",
      "            Denominator degrees of freedom, must be > 0.\n",
      "        nonc : float or array_like of floats\n",
      "            Non-centrality parameter, the sum of the squares of the numerator\n",
      "            means, must be >= 0.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``dfnum``, ``dfden``, and ``nonc``\n",
      "            are all scalars.  Otherwise, ``np.broadcast(dfnum, dfden, nonc).size``\n",
      "            samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized noncentral Fisher distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.noncentral_f: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        When calculating the power of an experiment (power = probability of\n",
      "        rejecting the null hypothesis when a specific alternative is true) the\n",
      "        non-central F statistic becomes important.  When the null hypothesis is\n",
      "        true, the F statistic follows a central F distribution. When the null\n",
      "        hypothesis is not true, then it follows a non-central F statistic.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Weisstein, Eric W. \"Noncentral F-Distribution.\"\n",
      "               From MathWorld--A Wolfram Web Resource.\n",
      "               http://mathworld.wolfram.com/NoncentralF-Distribution.html\n",
      "        .. [2] Wikipedia, \"Noncentral F-distribution\",\n",
      "               https://en.wikipedia.org/wiki/Noncentral_F-distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        In a study, testing for a specific alternative to the null hypothesis\n",
      "        requires use of the Noncentral F distribution. We need to calculate the\n",
      "        area in the tail of the distribution that exceeds the value of the F\n",
      "        distribution for the null hypothesis.  We'll plot the two probability\n",
      "        distributions for comparison.\n",
      "        \n",
      "        >>> dfnum = 3 # between group deg of freedom\n",
      "        >>> dfden = 20 # within groups degrees of freedom\n",
      "        >>> nonc = 3.0\n",
      "        >>> nc_vals = np.random.noncentral_f(dfnum, dfden, nonc, 1000000)\n",
      "        >>> NF = np.histogram(nc_vals, bins=50, density=True)\n",
      "        >>> c_vals = np.random.f(dfnum, dfden, 1000000)\n",
      "        >>> F = np.histogram(c_vals, bins=50, density=True)\n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> plt.plot(F[1][1:], F[0])\n",
      "        >>> plt.plot(NF[1][1:], NF[0])\n",
      "        >>> plt.show()\n",
      "    \n",
      "    normal(...) method of numpy.random.mtrand.RandomState instance\n",
      "        normal(loc=0.0, scale=1.0, size=None)\n",
      "        \n",
      "        Draw random samples from a normal (Gaussian) distribution.\n",
      "        \n",
      "        The probability density function of the normal distribution, first\n",
      "        derived by De Moivre and 200 years later by both Gauss and Laplace\n",
      "        independently [2]_, is often called the bell curve because of\n",
      "        its characteristic shape (see the example below).\n",
      "        \n",
      "        The normal distributions occurs often in nature.  For example, it\n",
      "        describes the commonly occurring distribution of samples influenced\n",
      "        by a large number of tiny, random disturbances, each with its own\n",
      "        unique distribution [2]_.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``normal`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        loc : float or array_like of floats\n",
      "            Mean (\"centre\") of the distribution.\n",
      "        scale : float or array_like of floats\n",
      "            Standard deviation (spread or \"width\") of the distribution. Must be\n",
      "            non-negative.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``loc`` and ``scale`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized normal distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.norm : probability density function, distribution or\n",
      "            cumulative density function, etc.\n",
      "        Generator.normal: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density for the Gaussian distribution is\n",
      "        \n",
      "        .. math:: p(x) = \\frac{1}{\\sqrt{ 2 \\pi \\sigma^2 }}\n",
      "                         e^{ - \\frac{ (x - \\mu)^2 } {2 \\sigma^2} },\n",
      "        \n",
      "        where :math:`\\mu` is the mean and :math:`\\sigma` the standard\n",
      "        deviation. The square of the standard deviation, :math:`\\sigma^2`,\n",
      "        is called the variance.\n",
      "        \n",
      "        The function has its peak at the mean, and its \"spread\" increases with\n",
      "        the standard deviation (the function reaches 0.607 times its maximum at\n",
      "        :math:`x + \\sigma` and :math:`x - \\sigma` [2]_).  This implies that\n",
      "        normal is more likely to return samples lying close to the mean, rather\n",
      "        than those far away.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Wikipedia, \"Normal distribution\",\n",
      "               https://en.wikipedia.org/wiki/Normal_distribution\n",
      "        .. [2] P. R. Peebles Jr., \"Central Limit Theorem\" in \"Probability,\n",
      "               Random Variables and Random Signal Principles\", 4th ed., 2001,\n",
      "               pp. 51, 51, 125.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> mu, sigma = 0, 0.1 # mean and standard deviation\n",
      "        >>> s = np.random.normal(mu, sigma, 1000)\n",
      "        \n",
      "        Verify the mean and the variance:\n",
      "        \n",
      "        >>> abs(mu - np.mean(s))\n",
      "        0.0  # may vary\n",
      "        \n",
      "        >>> abs(sigma - np.std(s, ddof=1))\n",
      "        0.1  # may vary\n",
      "        \n",
      "        Display the histogram of the samples, along with\n",
      "        the probability density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> count, bins, ignored = plt.hist(s, 30, density=True)\n",
      "        >>> plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *\n",
      "        ...                np.exp( - (bins - mu)**2 / (2 * sigma**2) ),\n",
      "        ...          linewidth=2, color='r')\n",
      "        >>> plt.show()\n",
      "        \n",
      "        Two-by-four array of samples from N(3, 6.25):\n",
      "        \n",
      "        >>> np.random.normal(3, 2.5, size=(2, 4))\n",
      "        array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random\n",
      "               [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]])  # random\n",
      "    \n",
      "    pareto(...) method of numpy.random.mtrand.RandomState instance\n",
      "        pareto(a, size=None)\n",
      "        \n",
      "        Draw samples from a Pareto II or Lomax distribution with\n",
      "        specified shape.\n",
      "        \n",
      "        The Lomax or Pareto II distribution is a shifted Pareto\n",
      "        distribution. The classical Pareto distribution can be\n",
      "        obtained from the Lomax distribution by adding 1 and\n",
      "        multiplying by the scale parameter ``m`` (see Notes).  The\n",
      "        smallest value of the Lomax distribution is zero while for the\n",
      "        classical Pareto distribution it is ``mu``, where the standard\n",
      "        Pareto distribution has location ``mu = 1``.  Lomax can also\n",
      "        be considered as a simplified version of the Generalized\n",
      "        Pareto distribution (available in SciPy), with the scale set\n",
      "        to one and the location set to zero.\n",
      "        \n",
      "        The Pareto distribution must be greater than zero, and is\n",
      "        unbounded above.  It is also known as the \"80-20 rule\".  In\n",
      "        this distribution, 80 percent of the weights are in the lowest\n",
      "        20 percent of the range, while the other 20 percent fill the\n",
      "        remaining 80 percent of the range.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``pareto`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : float or array_like of floats\n",
      "            Shape of the distribution. Must be positive.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``a`` is a scalar.  Otherwise,\n",
      "            ``np.array(a).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized Pareto distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.lomax : probability density function, distribution or\n",
      "            cumulative density function, etc.\n",
      "        scipy.stats.genpareto : probability density function, distribution or\n",
      "            cumulative density function, etc.\n",
      "        Generator.pareto: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density for the Pareto distribution is\n",
      "        \n",
      "        .. math:: p(x) = \\frac{am^a}{x^{a+1}}\n",
      "        \n",
      "        where :math:`a` is the shape and :math:`m` the scale.\n",
      "        \n",
      "        The Pareto distribution, named after the Italian economist\n",
      "        Vilfredo Pareto, is a power law probability distribution\n",
      "        useful in many real world problems.  Outside the field of\n",
      "        economics it is generally referred to as the Bradford\n",
      "        distribution. Pareto developed the distribution to describe\n",
      "        the distribution of wealth in an economy.  It has also found\n",
      "        use in insurance, web page access statistics, oil field sizes,\n",
      "        and many other problems, including the download frequency for\n",
      "        projects in Sourceforge [1]_.  It is one of the so-called\n",
      "        \"fat-tailed\" distributions.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Francis Hunt and Paul Johnson, On the Pareto Distribution of\n",
      "               Sourceforge projects.\n",
      "        .. [2] Pareto, V. (1896). Course of Political Economy. Lausanne.\n",
      "        .. [3] Reiss, R.D., Thomas, M.(2001), Statistical Analysis of Extreme\n",
      "               Values, Birkhauser Verlag, Basel, pp 23-30.\n",
      "        .. [4] Wikipedia, \"Pareto distribution\",\n",
      "               https://en.wikipedia.org/wiki/Pareto_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> a, m = 3., 2.  # shape and mode\n",
      "        >>> s = (np.random.pareto(a, 1000) + 1) * m\n",
      "        \n",
      "        Display the histogram of the samples, along with the probability\n",
      "        density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> count, bins, _ = plt.hist(s, 100, density=True)\n",
      "        >>> fit = a*m**a / bins**(a+1)\n",
      "        >>> plt.plot(bins, max(count)*fit/max(fit), linewidth=2, color='r')\n",
      "        >>> plt.show()\n",
      "    \n",
      "    permutation(...) method of numpy.random.mtrand.RandomState instance\n",
      "        permutation(x)\n",
      "        \n",
      "        Randomly permute a sequence, or return a permuted range.\n",
      "        \n",
      "        If `x` is a multi-dimensional array, it is only shuffled along its\n",
      "        first index.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``permutation`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : int or array_like\n",
      "            If `x` is an integer, randomly permute ``np.arange(x)``.\n",
      "            If `x` is an array, make a copy and shuffle the elements\n",
      "            randomly.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray\n",
      "            Permuted sequence or array range.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.permutation: which should be used for new code.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.permutation(10)\n",
      "        array([1, 7, 4, 3, 0, 9, 2, 5, 8, 6]) # random\n",
      "        \n",
      "        >>> np.random.permutation([1, 4, 9, 12, 15])\n",
      "        array([15,  1,  9,  4, 12]) # random\n",
      "        \n",
      "        >>> arr = np.arange(9).reshape((3, 3))\n",
      "        >>> np.random.permutation(arr)\n",
      "        array([[6, 7, 8], # random\n",
      "               [0, 1, 2],\n",
      "               [3, 4, 5]])\n",
      "    \n",
      "    poisson(...) method of numpy.random.mtrand.RandomState instance\n",
      "        poisson(lam=1.0, size=None)\n",
      "        \n",
      "        Draw samples from a Poisson distribution.\n",
      "        \n",
      "        The Poisson distribution is the limit of the binomial distribution\n",
      "        for large N.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``poisson`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        lam : float or array_like of floats\n",
      "            Expectation of interval, must be >= 0. A sequence of expectation\n",
      "            intervals must be broadcastable over the requested size.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``lam`` is a scalar. Otherwise,\n",
      "            ``np.array(lam).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized Poisson distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.poisson: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The Poisson distribution\n",
      "        \n",
      "        .. math:: f(k; \\lambda)=\\frac{\\lambda^k e^{-\\lambda}}{k!}\n",
      "        \n",
      "        For events with an expected separation :math:`\\lambda` the Poisson\n",
      "        distribution :math:`f(k; \\lambda)` describes the probability of\n",
      "        :math:`k` events occurring within the observed\n",
      "        interval :math:`\\lambda`.\n",
      "        \n",
      "        Because the output is limited to the range of the C int64 type, a\n",
      "        ValueError is raised when `lam` is within 10 sigma of the maximum\n",
      "        representable value.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Weisstein, Eric W. \"Poisson Distribution.\"\n",
      "               From MathWorld--A Wolfram Web Resource.\n",
      "               http://mathworld.wolfram.com/PoissonDistribution.html\n",
      "        .. [2] Wikipedia, \"Poisson distribution\",\n",
      "               https://en.wikipedia.org/wiki/Poisson_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> import numpy as np\n",
      "        >>> s = np.random.poisson(5, 10000)\n",
      "        \n",
      "        Display histogram of the sample:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> count, bins, ignored = plt.hist(s, 14, density=True)\n",
      "        >>> plt.show()\n",
      "        \n",
      "        Draw each 100 values for lambda 100 and 500:\n",
      "        \n",
      "        >>> s = np.random.poisson(lam=(100., 500.), size=(100, 2))\n",
      "    \n",
      "    power(...) method of numpy.random.mtrand.RandomState instance\n",
      "        power(a, size=None)\n",
      "        \n",
      "        Draws samples in [0, 1] from a power distribution with positive\n",
      "        exponent a - 1.\n",
      "        \n",
      "        Also known as the power function distribution.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``power`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : float or array_like of floats\n",
      "            Parameter of the distribution. Must be non-negative.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``a`` is a scalar.  Otherwise,\n",
      "            ``np.array(a).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized power distribution.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        ValueError\n",
      "            If a < 1.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.power: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density function is\n",
      "        \n",
      "        .. math:: P(x; a) = ax^{a-1}, 0 \\le x \\le 1, a>0.\n",
      "        \n",
      "        The power function distribution is just the inverse of the Pareto\n",
      "        distribution. It may also be seen as a special case of the Beta\n",
      "        distribution.\n",
      "        \n",
      "        It is used, for example, in modeling the over-reporting of insurance\n",
      "        claims.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Christian Kleiber, Samuel Kotz, \"Statistical size distributions\n",
      "               in economics and actuarial sciences\", Wiley, 2003.\n",
      "        .. [2] Heckert, N. A. and Filliben, James J. \"NIST Handbook 148:\n",
      "               Dataplot Reference Manual, Volume 2: Let Subcommands and Library\n",
      "               Functions\", National Institute of Standards and Technology\n",
      "               Handbook Series, June 2003.\n",
      "               https://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/powpdf.pdf\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> a = 5. # shape\n",
      "        >>> samples = 1000\n",
      "        >>> s = np.random.power(a, samples)\n",
      "        \n",
      "        Display the histogram of the samples, along with\n",
      "        the probability density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> count, bins, ignored = plt.hist(s, bins=30)\n",
      "        >>> x = np.linspace(0, 1, 100)\n",
      "        >>> y = a*x**(a-1.)\n",
      "        >>> normed_y = samples*np.diff(bins)[0]*y\n",
      "        >>> plt.plot(x, normed_y)\n",
      "        >>> plt.show()\n",
      "        \n",
      "        Compare the power function distribution to the inverse of the Pareto.\n",
      "        \n",
      "        >>> from scipy import stats # doctest: +SKIP\n",
      "        >>> rvs = np.random.power(5, 1000000)\n",
      "        >>> rvsp = np.random.pareto(5, 1000000)\n",
      "        >>> xx = np.linspace(0,1,100)\n",
      "        >>> powpdf = stats.powerlaw.pdf(xx,5)  # doctest: +SKIP\n",
      "        \n",
      "        >>> plt.figure()\n",
      "        >>> plt.hist(rvs, bins=50, density=True)\n",
      "        >>> plt.plot(xx,powpdf,'r-')  # doctest: +SKIP\n",
      "        >>> plt.title('np.random.power(5)')\n",
      "        \n",
      "        >>> plt.figure()\n",
      "        >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n",
      "        >>> plt.plot(xx,powpdf,'r-')  # doctest: +SKIP\n",
      "        >>> plt.title('inverse of 1 + np.random.pareto(5)')\n",
      "        \n",
      "        >>> plt.figure()\n",
      "        >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n",
      "        >>> plt.plot(xx,powpdf,'r-')  # doctest: +SKIP\n",
      "        >>> plt.title('inverse of stats.pareto(5)')\n",
      "    \n",
      "    rand(...) method of numpy.random.mtrand.RandomState instance\n",
      "        rand(d0, d1, ..., dn)\n",
      "        \n",
      "        Random values in a given shape.\n",
      "        \n",
      "        .. note::\n",
      "            This is a convenience function for users porting code from Matlab,\n",
      "            and wraps `random_sample`. That function takes a\n",
      "            tuple to specify the size of the output, which is consistent with\n",
      "            other NumPy functions like `numpy.zeros` and `numpy.ones`.\n",
      "        \n",
      "        Create an array of the given shape and populate it with\n",
      "        random samples from a uniform distribution\n",
      "        over ``[0, 1)``.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        d0, d1, ..., dn : int, optional\n",
      "            The dimensions of the returned array, must be non-negative.\n",
      "            If no argument is given a single Python float is returned.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray, shape ``(d0, d1, ..., dn)``\n",
      "            Random values.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        random\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.rand(3,2)\n",
      "        array([[ 0.14022471,  0.96360618],  #random\n",
      "               [ 0.37601032,  0.25528411],  #random\n",
      "               [ 0.49313049,  0.94909878]]) #random\n",
      "    \n",
      "    randint(...) method of numpy.random.mtrand.RandomState instance\n",
      "        randint(low, high=None, size=None, dtype=int)\n",
      "        \n",
      "        Return random integers from `low` (inclusive) to `high` (exclusive).\n",
      "        \n",
      "        Return random integers from the \"discrete uniform\" distribution of\n",
      "        the specified dtype in the \"half-open\" interval [`low`, `high`). If\n",
      "        `high` is None (the default), then results are from [0, `low`).\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``integers`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        low : int or array-like of ints\n",
      "            Lowest (signed) integers to be drawn from the distribution (unless\n",
      "            ``high=None``, in which case this parameter is one above the\n",
      "            *highest* such integer).\n",
      "        high : int or array-like of ints, optional\n",
      "            If provided, one above the largest (signed) integer to be drawn\n",
      "            from the distribution (see above for behavior if ``high=None``).\n",
      "            If array-like, must contain integer values\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "            single value is returned.\n",
      "        dtype : dtype, optional\n",
      "            Desired dtype of the result. Byteorder must be native.\n",
      "            The default value is int.\n",
      "        \n",
      "            .. versionadded:: 1.11.0\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : int or ndarray of ints\n",
      "            `size`-shaped array of random integers from the appropriate\n",
      "            distribution, or a single such random int if `size` not provided.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        random_integers : similar to `randint`, only for the closed\n",
      "            interval [`low`, `high`], and 1 is the lowest value if `high` is\n",
      "            omitted.\n",
      "        Generator.integers: which should be used for new code.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.randint(2, size=10)\n",
      "        array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random\n",
      "        >>> np.random.randint(1, size=10)\n",
      "        array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n",
      "        \n",
      "        Generate a 2 x 4 array of ints between 0 and 4, inclusive:\n",
      "        \n",
      "        >>> np.random.randint(5, size=(2, 4))\n",
      "        array([[4, 0, 2, 1], # random\n",
      "               [3, 2, 2, 0]])\n",
      "        \n",
      "        Generate a 1 x 3 array with 3 different upper bounds\n",
      "        \n",
      "        >>> np.random.randint(1, [3, 5, 10])\n",
      "        array([2, 2, 9]) # random\n",
      "        \n",
      "        Generate a 1 by 3 array with 3 different lower bounds\n",
      "        \n",
      "        >>> np.random.randint([1, 5, 7], 10)\n",
      "        array([9, 8, 7]) # random\n",
      "        \n",
      "        Generate a 2 by 4 array using broadcasting with dtype of uint8\n",
      "        \n",
      "        >>> np.random.randint([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)\n",
      "        array([[ 8,  6,  9,  7], # random\n",
      "               [ 1, 16,  9, 12]], dtype=uint8)\n",
      "    \n",
      "    randn(...) method of numpy.random.mtrand.RandomState instance\n",
      "        randn(d0, d1, ..., dn)\n",
      "        \n",
      "        Return a sample (or samples) from the \"standard normal\" distribution.\n",
      "        \n",
      "        .. note::\n",
      "            This is a convenience function for users porting code from Matlab,\n",
      "            and wraps `standard_normal`. That function takes a\n",
      "            tuple to specify the size of the output, which is consistent with\n",
      "            other NumPy functions like `numpy.zeros` and `numpy.ones`.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``standard_normal`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        If positive int_like arguments are provided, `randn` generates an array\n",
      "        of shape ``(d0, d1, ..., dn)``, filled\n",
      "        with random floats sampled from a univariate \"normal\" (Gaussian)\n",
      "        distribution of mean 0 and variance 1. A single float randomly sampled\n",
      "        from the distribution is returned if no argument is provided.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        d0, d1, ..., dn : int, optional\n",
      "            The dimensions of the returned array, must be non-negative.\n",
      "            If no argument is given a single Python float is returned.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Z : ndarray or float\n",
      "            A ``(d0, d1, ..., dn)``-shaped array of floating-point samples from\n",
      "            the standard normal distribution, or a single such float if\n",
      "            no parameters were supplied.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        standard_normal : Similar, but takes a tuple as its argument.\n",
      "        normal : Also accepts mu and sigma arguments.\n",
      "        Generator.standard_normal: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For random samples from :math:`N(\\mu, \\sigma^2)`, use:\n",
      "        \n",
      "        ``sigma * np.random.randn(...) + mu``\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.randn()\n",
      "        2.1923875335537315  # random\n",
      "        \n",
      "        Two-by-four array of samples from N(3, 6.25):\n",
      "        \n",
      "        >>> 3 + 2.5 * np.random.randn(2, 4)\n",
      "        array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random\n",
      "               [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]])  # random\n",
      "    \n",
      "    random(...) method of numpy.random.mtrand.RandomState instance\n",
      "        random(size=None)\n",
      "        \n",
      "        Return random floats in the half-open interval [0.0, 1.0). Alias for\n",
      "        `random_sample` to ease forward-porting to the new random API.\n",
      "    \n",
      "    random_integers(...) method of numpy.random.mtrand.RandomState instance\n",
      "        random_integers(low, high=None, size=None)\n",
      "        \n",
      "        Random integers of type `np.int_` between `low` and `high`, inclusive.\n",
      "        \n",
      "        Return random integers of type `np.int_` from the \"discrete uniform\"\n",
      "        distribution in the closed interval [`low`, `high`].  If `high` is\n",
      "        None (the default), then results are from [1, `low`]. The `np.int_`\n",
      "        type translates to the C long integer type and its precision\n",
      "        is platform dependent.\n",
      "        \n",
      "        This function has been deprecated. Use randint instead.\n",
      "        \n",
      "        .. deprecated:: 1.11.0\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        low : int\n",
      "            Lowest (signed) integer to be drawn from the distribution (unless\n",
      "            ``high=None``, in which case this parameter is the *highest* such\n",
      "            integer).\n",
      "        high : int, optional\n",
      "            If provided, the largest (signed) integer to be drawn from the\n",
      "            distribution (see above for behavior if ``high=None``).\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "            single value is returned.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : int or ndarray of ints\n",
      "            `size`-shaped array of random integers from the appropriate\n",
      "            distribution, or a single such random int if `size` not provided.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        randint : Similar to `random_integers`, only for the half-open\n",
      "            interval [`low`, `high`), and 0 is the lowest value if `high` is\n",
      "            omitted.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        To sample from N evenly spaced floating-point numbers between a and b,\n",
      "        use::\n",
      "        \n",
      "          a + (b - a) * (np.random.random_integers(N) - 1) / (N - 1.)\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.random_integers(5)\n",
      "        4 # random\n",
      "        >>> type(np.random.random_integers(5))\n",
      "        <class 'numpy.int64'>\n",
      "        >>> np.random.random_integers(5, size=(3,2))\n",
      "        array([[5, 4], # random\n",
      "               [3, 3],\n",
      "               [4, 5]])\n",
      "        \n",
      "        Choose five random numbers from the set of five evenly-spaced\n",
      "        numbers between 0 and 2.5, inclusive (*i.e.*, from the set\n",
      "        :math:`{0, 5/8, 10/8, 15/8, 20/8}`):\n",
      "        \n",
      "        >>> 2.5 * (np.random.random_integers(5, size=(5,)) - 1) / 4.\n",
      "        array([ 0.625,  1.25 ,  0.625,  0.625,  2.5  ]) # random\n",
      "        \n",
      "        Roll two six sided dice 1000 times and sum the results:\n",
      "        \n",
      "        >>> d1 = np.random.random_integers(1, 6, 1000)\n",
      "        >>> d2 = np.random.random_integers(1, 6, 1000)\n",
      "        >>> dsums = d1 + d2\n",
      "        \n",
      "        Display results as a histogram:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> count, bins, ignored = plt.hist(dsums, 11, density=True)\n",
      "        >>> plt.show()\n",
      "    \n",
      "    random_sample(...) method of numpy.random.mtrand.RandomState instance\n",
      "        random_sample(size=None)\n",
      "        \n",
      "        Return random floats in the half-open interval [0.0, 1.0).\n",
      "        \n",
      "        Results are from the \"continuous uniform\" distribution over the\n",
      "        stated interval.  To sample :math:`Unif[a, b), b > a` multiply\n",
      "        the output of `random_sample` by `(b-a)` and add `a`::\n",
      "        \n",
      "          (b - a) * random_sample() + a\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``random`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "            single value is returned.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : float or ndarray of floats\n",
      "            Array of random floats of shape `size` (unless ``size=None``, in which\n",
      "            case a single float is returned).\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.random: which should be used for new code.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.random_sample()\n",
      "        0.47108547995356098 # random\n",
      "        >>> type(np.random.random_sample())\n",
      "        <class 'float'>\n",
      "        >>> np.random.random_sample((5,))\n",
      "        array([ 0.30220482,  0.86820401,  0.1654503 ,  0.11659149,  0.54323428]) # random\n",
      "        \n",
      "        Three-by-two array of random numbers from [-5, 0):\n",
      "        \n",
      "        >>> 5 * np.random.random_sample((3, 2)) - 5\n",
      "        array([[-3.99149989, -0.52338984], # random\n",
      "               [-2.99091858, -0.79479508],\n",
      "               [-1.23204345, -1.75224494]])\n",
      "    \n",
      "    ranf(...)\n",
      "        This is an alias of `random_sample`. See `random_sample`  for the complete\n",
      "        documentation.\n",
      "    \n",
      "    rayleigh(...) method of numpy.random.mtrand.RandomState instance\n",
      "        rayleigh(scale=1.0, size=None)\n",
      "        \n",
      "        Draw samples from a Rayleigh distribution.\n",
      "        \n",
      "        The :math:`\\chi` and Weibull distributions are generalizations of the\n",
      "        Rayleigh.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``rayleigh`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        scale : float or array_like of floats, optional\n",
      "            Scale, also equals the mode. Must be non-negative. Default is 1.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``scale`` is a scalar.  Otherwise,\n",
      "            ``np.array(scale).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized Rayleigh distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.rayleigh: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density function for the Rayleigh distribution is\n",
      "        \n",
      "        .. math:: P(x;scale) = \\frac{x}{scale^2}e^{\\frac{-x^2}{2 \\cdotp scale^2}}\n",
      "        \n",
      "        The Rayleigh distribution would arise, for example, if the East\n",
      "        and North components of the wind velocity had identical zero-mean\n",
      "        Gaussian distributions.  Then the wind speed would have a Rayleigh\n",
      "        distribution.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Brighton Webs Ltd., \"Rayleigh Distribution,\"\n",
      "               https://web.archive.org/web/20090514091424/http://brighton-webs.co.uk:80/distributions/rayleigh.asp\n",
      "        .. [2] Wikipedia, \"Rayleigh distribution\"\n",
      "               https://en.wikipedia.org/wiki/Rayleigh_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw values from the distribution and plot the histogram\n",
      "        \n",
      "        >>> from matplotlib.pyplot import hist\n",
      "        >>> values = hist(np.random.rayleigh(3, 100000), bins=200, density=True)\n",
      "        \n",
      "        Wave heights tend to follow a Rayleigh distribution. If the mean wave\n",
      "        height is 1 meter, what fraction of waves are likely to be larger than 3\n",
      "        meters?\n",
      "        \n",
      "        >>> meanvalue = 1\n",
      "        >>> modevalue = np.sqrt(2 / np.pi) * meanvalue\n",
      "        >>> s = np.random.rayleigh(modevalue, 1000000)\n",
      "        \n",
      "        The percentage of waves larger than 3 meters is:\n",
      "        \n",
      "        >>> 100.*sum(s>3)/1000000.\n",
      "        0.087300000000000003 # random\n",
      "    \n",
      "    sample(...)\n",
      "        This is an alias of `random_sample`. See `random_sample`  for the complete\n",
      "        documentation.\n",
      "    \n",
      "    seed(...) method of numpy.random.mtrand.RandomState instance\n",
      "        seed(self, seed=None)\n",
      "        \n",
      "        Reseed a legacy MT19937 BitGenerator\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This is a convenience, legacy function.\n",
      "        \n",
      "        The best practice is to **not** reseed a BitGenerator, rather to\n",
      "        recreate a new one. This method is here for legacy reasons.\n",
      "        This example demonstrates best practice.\n",
      "        \n",
      "        >>> from numpy.random import MT19937\n",
      "        >>> from numpy.random import RandomState, SeedSequence\n",
      "        >>> rs = RandomState(MT19937(SeedSequence(123456789)))\n",
      "        # Later, you want to restart the stream\n",
      "        >>> rs = RandomState(MT19937(SeedSequence(987654321)))\n",
      "    \n",
      "    set_state(...) method of numpy.random.mtrand.RandomState instance\n",
      "        set_state(state)\n",
      "        \n",
      "        Set the internal state of the generator from a tuple.\n",
      "        \n",
      "        For use if one has reason to manually (re-)set the internal state of\n",
      "        the bit generator used by the RandomState instance. By default,\n",
      "        RandomState uses the \"Mersenne Twister\"[1]_ pseudo-random number\n",
      "        generating algorithm.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        state : {tuple(str, ndarray of 624 uints, int, int, float), dict}\n",
      "            The `state` tuple has the following items:\n",
      "        \n",
      "            1. the string 'MT19937', specifying the Mersenne Twister algorithm.\n",
      "            2. a 1-D array of 624 unsigned integers ``keys``.\n",
      "            3. an integer ``pos``.\n",
      "            4. an integer ``has_gauss``.\n",
      "            5. a float ``cached_gaussian``.\n",
      "        \n",
      "            If state is a dictionary, it is directly set using the BitGenerators\n",
      "            `state` property.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : None\n",
      "            Returns 'None' on success.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        get_state\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        `set_state` and `get_state` are not needed to work with any of the\n",
      "        random distributions in NumPy. If the internal state is manually altered,\n",
      "        the user should know exactly what he/she is doing.\n",
      "        \n",
      "        For backwards compatibility, the form (str, array of 624 uints, int) is\n",
      "        also accepted although it is missing some information about the cached\n",
      "        Gaussian value: ``state = ('MT19937', keys, pos)``.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] M. Matsumoto and T. Nishimura, \"Mersenne Twister: A\n",
      "           623-dimensionally equidistributed uniform pseudorandom number\n",
      "           generator,\" *ACM Trans. on Modeling and Computer Simulation*,\n",
      "           Vol. 8, No. 1, pp. 3-30, Jan. 1998.\n",
      "    \n",
      "    shuffle(...) method of numpy.random.mtrand.RandomState instance\n",
      "        shuffle(x)\n",
      "        \n",
      "        Modify a sequence in-place by shuffling its contents.\n",
      "        \n",
      "        This function only shuffles the array along the first axis of a\n",
      "        multi-dimensional array. The order of sub-arrays is changed but\n",
      "        their contents remains the same.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``shuffle`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The array or list to be shuffled.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        None\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.shuffle: which should be used for new code.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> arr = np.arange(10)\n",
      "        >>> np.random.shuffle(arr)\n",
      "        >>> arr\n",
      "        [1 7 5 2 9 4 3 6 0 8] # random\n",
      "        \n",
      "        Multi-dimensional arrays are only shuffled along the first axis:\n",
      "        \n",
      "        >>> arr = np.arange(9).reshape((3, 3))\n",
      "        >>> np.random.shuffle(arr)\n",
      "        >>> arr\n",
      "        array([[3, 4, 5], # random\n",
      "               [6, 7, 8],\n",
      "               [0, 1, 2]])\n",
      "    \n",
      "    standard_cauchy(...) method of numpy.random.mtrand.RandomState instance\n",
      "        standard_cauchy(size=None)\n",
      "        \n",
      "        Draw samples from a standard Cauchy distribution with mode = 0.\n",
      "        \n",
      "        Also known as the Lorentz distribution.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``standard_cauchy`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "            single value is returned.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        samples : ndarray or scalar\n",
      "            The drawn samples.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.standard_cauchy: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density function for the full Cauchy distribution is\n",
      "        \n",
      "        .. math:: P(x; x_0, \\gamma) = \\frac{1}{\\pi \\gamma \\bigl[ 1+\n",
      "                  (\\frac{x-x_0}{\\gamma})^2 \\bigr] }\n",
      "        \n",
      "        and the Standard Cauchy distribution just sets :math:`x_0=0` and\n",
      "        :math:`\\gamma=1`\n",
      "        \n",
      "        The Cauchy distribution arises in the solution to the driven harmonic\n",
      "        oscillator problem, and also describes spectral line broadening. It\n",
      "        also describes the distribution of values at which a line tilted at\n",
      "        a random angle will cut the x axis.\n",
      "        \n",
      "        When studying hypothesis tests that assume normality, seeing how the\n",
      "        tests perform on data from a Cauchy distribution is a good indicator of\n",
      "        their sensitivity to a heavy-tailed distribution, since the Cauchy looks\n",
      "        very much like a Gaussian distribution, but with heavier tails.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] NIST/SEMATECH e-Handbook of Statistical Methods, \"Cauchy\n",
      "              Distribution\",\n",
      "              https://www.itl.nist.gov/div898/handbook/eda/section3/eda3663.htm\n",
      "        .. [2] Weisstein, Eric W. \"Cauchy Distribution.\" From MathWorld--A\n",
      "              Wolfram Web Resource.\n",
      "              http://mathworld.wolfram.com/CauchyDistribution.html\n",
      "        .. [3] Wikipedia, \"Cauchy distribution\"\n",
      "              https://en.wikipedia.org/wiki/Cauchy_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples and plot the distribution:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> s = np.random.standard_cauchy(1000000)\n",
      "        >>> s = s[(s>-25) & (s<25)]  # truncate distribution so it plots well\n",
      "        >>> plt.hist(s, bins=100)\n",
      "        >>> plt.show()\n",
      "    \n",
      "    standard_exponential(...) method of numpy.random.mtrand.RandomState instance\n",
      "        standard_exponential(size=None)\n",
      "        \n",
      "        Draw samples from the standard exponential distribution.\n",
      "        \n",
      "        `standard_exponential` is identical to the exponential distribution\n",
      "        with a scale parameter of 1.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``standard_exponential`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "            single value is returned.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : float or ndarray\n",
      "            Drawn samples.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.standard_exponential: which should be used for new code.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Output a 3x8000 array:\n",
      "        \n",
      "        >>> n = np.random.standard_exponential((3, 8000))\n",
      "    \n",
      "    standard_gamma(...) method of numpy.random.mtrand.RandomState instance\n",
      "        standard_gamma(shape, size=None)\n",
      "        \n",
      "        Draw samples from a standard Gamma distribution.\n",
      "        \n",
      "        Samples are drawn from a Gamma distribution with specified parameters,\n",
      "        shape (sometimes designated \"k\") and scale=1.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``standard_gamma`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        shape : float or array_like of floats\n",
      "            Parameter, must be non-negative.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``shape`` is a scalar.  Otherwise,\n",
      "            ``np.array(shape).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized standard gamma distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.gamma : probability density function, distribution or\n",
      "            cumulative density function, etc.\n",
      "        Generator.standard_gamma: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density for the Gamma distribution is\n",
      "        \n",
      "        .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n",
      "        \n",
      "        where :math:`k` is the shape and :math:`\\theta` the scale,\n",
      "        and :math:`\\Gamma` is the Gamma function.\n",
      "        \n",
      "        The Gamma distribution is often used to model the times to failure of\n",
      "        electronic components, and arises naturally in processes for which the\n",
      "        waiting times between Poisson distributed events are relevant.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n",
      "               Wolfram Web Resource.\n",
      "               http://mathworld.wolfram.com/GammaDistribution.html\n",
      "        .. [2] Wikipedia, \"Gamma distribution\",\n",
      "               https://en.wikipedia.org/wiki/Gamma_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> shape, scale = 2., 1. # mean and width\n",
      "        >>> s = np.random.standard_gamma(shape, 1000000)\n",
      "        \n",
      "        Display the histogram of the samples, along with\n",
      "        the probability density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> import scipy.special as sps  # doctest: +SKIP\n",
      "        >>> count, bins, ignored = plt.hist(s, 50, density=True)\n",
      "        >>> y = bins**(shape-1) * ((np.exp(-bins/scale))/  # doctest: +SKIP\n",
      "        ...                       (sps.gamma(shape) * scale**shape))\n",
      "        >>> plt.plot(bins, y, linewidth=2, color='r')  # doctest: +SKIP\n",
      "        >>> plt.show()\n",
      "    \n",
      "    standard_normal(...) method of numpy.random.mtrand.RandomState instance\n",
      "        standard_normal(size=None)\n",
      "        \n",
      "        Draw samples from a standard Normal distribution (mean=0, stdev=1).\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``standard_normal`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "            single value is returned.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : float or ndarray\n",
      "            A floating-point array of shape ``size`` of drawn samples, or a\n",
      "            single sample if ``size`` was not specified.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        normal :\n",
      "            Equivalent function with additional ``loc`` and ``scale`` arguments\n",
      "            for setting the mean and standard deviation.\n",
      "        Generator.standard_normal: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For random samples from :math:`N(\\mu, \\sigma^2)`, use one of::\n",
      "        \n",
      "            mu + sigma * np.random.standard_normal(size=...)\n",
      "            np.random.normal(mu, sigma, size=...)\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.standard_normal()\n",
      "        2.1923875335537315 #random\n",
      "        \n",
      "        >>> s = np.random.standard_normal(8000)\n",
      "        >>> s\n",
      "        array([ 0.6888893 ,  0.78096262, -0.89086505, ...,  0.49876311,  # random\n",
      "               -0.38672696, -0.4685006 ])                                # random\n",
      "        >>> s.shape\n",
      "        (8000,)\n",
      "        >>> s = np.random.standard_normal(size=(3, 4, 2))\n",
      "        >>> s.shape\n",
      "        (3, 4, 2)\n",
      "        \n",
      "        Two-by-four array of samples from :math:`N(3, 6.25)`:\n",
      "        \n",
      "        >>> 3 + 2.5 * np.random.standard_normal(size=(2, 4))\n",
      "        array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random\n",
      "               [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]])  # random\n",
      "    \n",
      "    standard_t(...) method of numpy.random.mtrand.RandomState instance\n",
      "        standard_t(df, size=None)\n",
      "        \n",
      "        Draw samples from a standard Student's t distribution with `df` degrees\n",
      "        of freedom.\n",
      "        \n",
      "        A special case of the hyperbolic distribution.  As `df` gets\n",
      "        large, the result resembles that of the standard normal\n",
      "        distribution (`standard_normal`).\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``standard_t`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        df : float or array_like of floats\n",
      "            Degrees of freedom, must be > 0.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``df`` is a scalar.  Otherwise,\n",
      "            ``np.array(df).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized standard Student's t distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.standard_t: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density function for the t distribution is\n",
      "        \n",
      "        .. math:: P(x, df) = \\frac{\\Gamma(\\frac{df+1}{2})}{\\sqrt{\\pi df}\n",
      "                  \\Gamma(\\frac{df}{2})}\\Bigl( 1+\\frac{x^2}{df} \\Bigr)^{-(df+1)/2}\n",
      "        \n",
      "        The t test is based on an assumption that the data come from a\n",
      "        Normal distribution. The t test provides a way to test whether\n",
      "        the sample mean (that is the mean calculated from the data) is\n",
      "        a good estimate of the true mean.\n",
      "        \n",
      "        The derivation of the t-distribution was first published in\n",
      "        1908 by William Gosset while working for the Guinness Brewery\n",
      "        in Dublin. Due to proprietary issues, he had to publish under\n",
      "        a pseudonym, and so he used the name Student.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Dalgaard, Peter, \"Introductory Statistics With R\",\n",
      "               Springer, 2002.\n",
      "        .. [2] Wikipedia, \"Student's t-distribution\"\n",
      "               https://en.wikipedia.org/wiki/Student's_t-distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        From Dalgaard page 83 [1]_, suppose the daily energy intake for 11\n",
      "        women in kilojoules (kJ) is:\n",
      "        \n",
      "        >>> intake = np.array([5260., 5470, 5640, 6180, 6390, 6515, 6805, 7515, \\\n",
      "        ...                    7515, 8230, 8770])\n",
      "        \n",
      "        Does their energy intake deviate systematically from the recommended\n",
      "        value of 7725 kJ?\n",
      "        \n",
      "        We have 10 degrees of freedom, so is the sample mean within 95% of the\n",
      "        recommended value?\n",
      "        \n",
      "        >>> s = np.random.standard_t(10, size=100000)\n",
      "        >>> np.mean(intake)\n",
      "        6753.636363636364\n",
      "        >>> intake.std(ddof=1)\n",
      "        1142.1232221373727\n",
      "        \n",
      "        Calculate the t statistic, setting the ddof parameter to the unbiased\n",
      "        value so the divisor in the standard deviation will be degrees of\n",
      "        freedom, N-1.\n",
      "        \n",
      "        >>> t = (np.mean(intake)-7725)/(intake.std(ddof=1)/np.sqrt(len(intake)))\n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> h = plt.hist(s, bins=100, density=True)\n",
      "        \n",
      "        For a one-sided t-test, how far out in the distribution does the t\n",
      "        statistic appear?\n",
      "        \n",
      "        >>> np.sum(s<t) / float(len(s))\n",
      "        0.0090699999999999999  #random\n",
      "        \n",
      "        So the p-value is about 0.009, which says the null hypothesis has a\n",
      "        probability of about 99% of being true.\n",
      "    \n",
      "    triangular(...) method of numpy.random.mtrand.RandomState instance\n",
      "        triangular(left, mode, right, size=None)\n",
      "        \n",
      "        Draw samples from the triangular distribution over the\n",
      "        interval ``[left, right]``.\n",
      "        \n",
      "        The triangular distribution is a continuous probability\n",
      "        distribution with lower limit left, peak at mode, and upper\n",
      "        limit right. Unlike the other distributions, these parameters\n",
      "        directly define the shape of the pdf.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``triangular`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        left : float or array_like of floats\n",
      "            Lower limit.\n",
      "        mode : float or array_like of floats\n",
      "            The value where the peak of the distribution occurs.\n",
      "            The value must fulfill the condition ``left <= mode <= right``.\n",
      "        right : float or array_like of floats\n",
      "            Upper limit, must be larger than `left`.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``left``, ``mode``, and ``right``\n",
      "            are all scalars.  Otherwise, ``np.broadcast(left, mode, right).size``\n",
      "            samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized triangular distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.triangular: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density function for the triangular distribution is\n",
      "        \n",
      "        .. math:: P(x;l, m, r) = \\begin{cases}\n",
      "                  \\frac{2(x-l)}{(r-l)(m-l)}& \\text{for $l \\leq x \\leq m$},\\\\\n",
      "                  \\frac{2(r-x)}{(r-l)(r-m)}& \\text{for $m \\leq x \\leq r$},\\\\\n",
      "                  0& \\text{otherwise}.\n",
      "                  \\end{cases}\n",
      "        \n",
      "        The triangular distribution is often used in ill-defined\n",
      "        problems where the underlying distribution is not known, but\n",
      "        some knowledge of the limits and mode exists. Often it is used\n",
      "        in simulations.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Wikipedia, \"Triangular distribution\"\n",
      "               https://en.wikipedia.org/wiki/Triangular_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw values from the distribution and plot the histogram:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> h = plt.hist(np.random.triangular(-3, 0, 8, 100000), bins=200,\n",
      "        ...              density=True)\n",
      "        >>> plt.show()\n",
      "    \n",
      "    uniform(...) method of numpy.random.mtrand.RandomState instance\n",
      "        uniform(low=0.0, high=1.0, size=None)\n",
      "        \n",
      "        Draw samples from a uniform distribution.\n",
      "        \n",
      "        Samples are uniformly distributed over the half-open interval\n",
      "        ``[low, high)`` (includes low, but excludes high).  In other words,\n",
      "        any value within the given interval is equally likely to be drawn\n",
      "        by `uniform`.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``uniform`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        low : float or array_like of floats, optional\n",
      "            Lower boundary of the output interval.  All values generated will be\n",
      "            greater than or equal to low.  The default value is 0.\n",
      "        high : float or array_like of floats\n",
      "            Upper boundary of the output interval.  All values generated will be\n",
      "            less than or equal to high.  The default value is 1.0.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``low`` and ``high`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(low, high).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized uniform distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        randint : Discrete uniform distribution, yielding integers.\n",
      "        random_integers : Discrete uniform distribution over the closed\n",
      "                          interval ``[low, high]``.\n",
      "        random_sample : Floats uniformly distributed over ``[0, 1)``.\n",
      "        random : Alias for `random_sample`.\n",
      "        rand : Convenience function that accepts dimensions as input, e.g.,\n",
      "               ``rand(2,2)`` would generate a 2-by-2 array of floats,\n",
      "               uniformly distributed over ``[0, 1)``.\n",
      "        Generator.uniform: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density function of the uniform distribution is\n",
      "        \n",
      "        .. math:: p(x) = \\frac{1}{b - a}\n",
      "        \n",
      "        anywhere within the interval ``[a, b)``, and zero elsewhere.\n",
      "        \n",
      "        When ``high`` == ``low``, values of ``low`` will be returned.\n",
      "        If ``high`` < ``low``, the results are officially undefined\n",
      "        and may eventually raise an error, i.e. do not rely on this\n",
      "        function to behave when passed arguments satisfying that\n",
      "        inequality condition. The ``high`` limit may be included in the\n",
      "        returned array of floats due to floating-point rounding in the\n",
      "        equation ``low + (high-low) * random_sample()``. For example:\n",
      "        \n",
      "        >>> x = np.float32(5*0.99999999)\n",
      "        >>> x\n",
      "        5.0\n",
      "        \n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> s = np.random.uniform(-1,0,1000)\n",
      "        \n",
      "        All values are within the given interval:\n",
      "        \n",
      "        >>> np.all(s >= -1)\n",
      "        True\n",
      "        >>> np.all(s < 0)\n",
      "        True\n",
      "        \n",
      "        Display the histogram of the samples, along with the\n",
      "        probability density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> count, bins, ignored = plt.hist(s, 15, density=True)\n",
      "        >>> plt.plot(bins, np.ones_like(bins), linewidth=2, color='r')\n",
      "        >>> plt.show()\n",
      "    \n",
      "    vonmises(...) method of numpy.random.mtrand.RandomState instance\n",
      "        vonmises(mu, kappa, size=None)\n",
      "        \n",
      "        Draw samples from a von Mises distribution.\n",
      "        \n",
      "        Samples are drawn from a von Mises distribution with specified mode\n",
      "        (mu) and dispersion (kappa), on the interval [-pi, pi].\n",
      "        \n",
      "        The von Mises distribution (also known as the circular normal\n",
      "        distribution) is a continuous probability distribution on the unit\n",
      "        circle.  It may be thought of as the circular analogue of the normal\n",
      "        distribution.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``vonmises`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        mu : float or array_like of floats\n",
      "            Mode (\"center\") of the distribution.\n",
      "        kappa : float or array_like of floats\n",
      "            Dispersion of the distribution, has to be >=0.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``mu`` and ``kappa`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(mu, kappa).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized von Mises distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.vonmises : probability density function, distribution, or\n",
      "            cumulative density function, etc.\n",
      "        Generator.vonmises: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density for the von Mises distribution is\n",
      "        \n",
      "        .. math:: p(x) = \\frac{e^{\\kappa cos(x-\\mu)}}{2\\pi I_0(\\kappa)},\n",
      "        \n",
      "        where :math:`\\mu` is the mode and :math:`\\kappa` the dispersion,\n",
      "        and :math:`I_0(\\kappa)` is the modified Bessel function of order 0.\n",
      "        \n",
      "        The von Mises is named for Richard Edler von Mises, who was born in\n",
      "        Austria-Hungary, in what is now the Ukraine.  He fled to the United\n",
      "        States in 1939 and became a professor at Harvard.  He worked in\n",
      "        probability theory, aerodynamics, fluid mechanics, and philosophy of\n",
      "        science.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n",
      "               Mathematical Functions with Formulas, Graphs, and Mathematical\n",
      "               Tables, 9th printing,\" New York: Dover, 1972.\n",
      "        .. [2] von Mises, R., \"Mathematical Theory of Probability\n",
      "               and Statistics\", New York: Academic Press, 1964.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> mu, kappa = 0.0, 4.0 # mean and dispersion\n",
      "        >>> s = np.random.vonmises(mu, kappa, 1000)\n",
      "        \n",
      "        Display the histogram of the samples, along with\n",
      "        the probability density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> from scipy.special import i0  # doctest: +SKIP\n",
      "        >>> plt.hist(s, 50, density=True)\n",
      "        >>> x = np.linspace(-np.pi, np.pi, num=51)\n",
      "        >>> y = np.exp(kappa*np.cos(x-mu))/(2*np.pi*i0(kappa))  # doctest: +SKIP\n",
      "        >>> plt.plot(x, y, linewidth=2, color='r')  # doctest: +SKIP\n",
      "        >>> plt.show()\n",
      "    \n",
      "    wald(...) method of numpy.random.mtrand.RandomState instance\n",
      "        wald(mean, scale, size=None)\n",
      "        \n",
      "        Draw samples from a Wald, or inverse Gaussian, distribution.\n",
      "        \n",
      "        As the scale approaches infinity, the distribution becomes more like a\n",
      "        Gaussian. Some references claim that the Wald is an inverse Gaussian\n",
      "        with mean equal to 1, but this is by no means universal.\n",
      "        \n",
      "        The inverse Gaussian distribution was first studied in relationship to\n",
      "        Brownian motion. In 1956 M.C.K. Tweedie used the name inverse Gaussian\n",
      "        because there is an inverse relationship between the time to cover a\n",
      "        unit distance and distance covered in unit time.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``wald`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        mean : float or array_like of floats\n",
      "            Distribution mean, must be > 0.\n",
      "        scale : float or array_like of floats\n",
      "            Scale parameter, must be > 0.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``mean`` and ``scale`` are both scalars.\n",
      "            Otherwise, ``np.broadcast(mean, scale).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized Wald distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        Generator.wald: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density function for the Wald distribution is\n",
      "        \n",
      "        .. math:: P(x;mean,scale) = \\sqrt{\\frac{scale}{2\\pi x^3}}e^\n",
      "                                    \\frac{-scale(x-mean)^2}{2\\cdotp mean^2x}\n",
      "        \n",
      "        As noted above the inverse Gaussian distribution first arise\n",
      "        from attempts to model Brownian motion. It is also a\n",
      "        competitor to the Weibull for use in reliability modeling and\n",
      "        modeling stock returns and interest rate processes.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Brighton Webs Ltd., Wald Distribution,\n",
      "               https://web.archive.org/web/20090423014010/http://www.brighton-webs.co.uk:80/distributions/wald.asp\n",
      "        .. [2] Chhikara, Raj S., and Folks, J. Leroy, \"The Inverse Gaussian\n",
      "               Distribution: Theory : Methodology, and Applications\", CRC Press,\n",
      "               1988.\n",
      "        .. [3] Wikipedia, \"Inverse Gaussian distribution\"\n",
      "               https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw values from the distribution and plot the histogram:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> h = plt.hist(np.random.wald(3, 2, 100000), bins=200, density=True)\n",
      "        >>> plt.show()\n",
      "    \n",
      "    weibull(...) method of numpy.random.mtrand.RandomState instance\n",
      "        weibull(a, size=None)\n",
      "        \n",
      "        Draw samples from a Weibull distribution.\n",
      "        \n",
      "        Draw samples from a 1-parameter Weibull distribution with the given\n",
      "        shape parameter `a`.\n",
      "        \n",
      "        .. math:: X = (-ln(U))^{1/a}\n",
      "        \n",
      "        Here, U is drawn from the uniform distribution over (0,1].\n",
      "        \n",
      "        The more common 2-parameter Weibull, including a scale parameter\n",
      "        :math:`\\lambda` is just :math:`X = \\lambda(-ln(U))^{1/a}`.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``weibull`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : float or array_like of floats\n",
      "            Shape parameter of the distribution.  Must be nonnegative.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``a`` is a scalar.  Otherwise,\n",
      "            ``np.array(a).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized Weibull distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.weibull_max\n",
      "        scipy.stats.weibull_min\n",
      "        scipy.stats.genextreme\n",
      "        gumbel\n",
      "        Generator.weibull: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The Weibull (or Type III asymptotic extreme value distribution\n",
      "        for smallest values, SEV Type III, or Rosin-Rammler\n",
      "        distribution) is one of a class of Generalized Extreme Value\n",
      "        (GEV) distributions used in modeling extreme value problems.\n",
      "        This class includes the Gumbel and Frechet distributions.\n",
      "        \n",
      "        The probability density for the Weibull distribution is\n",
      "        \n",
      "        .. math:: p(x) = \\frac{a}\n",
      "                         {\\lambda}(\\frac{x}{\\lambda})^{a-1}e^{-(x/\\lambda)^a},\n",
      "        \n",
      "        where :math:`a` is the shape and :math:`\\lambda` the scale.\n",
      "        \n",
      "        The function has its peak (the mode) at\n",
      "        :math:`\\lambda(\\frac{a-1}{a})^{1/a}`.\n",
      "        \n",
      "        When ``a = 1``, the Weibull distribution reduces to the exponential\n",
      "        distribution.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Waloddi Weibull, Royal Technical University, Stockholm,\n",
      "               1939 \"A Statistical Theory Of The Strength Of Materials\",\n",
      "               Ingeniorsvetenskapsakademiens Handlingar Nr 151, 1939,\n",
      "               Generalstabens Litografiska Anstalts Forlag, Stockholm.\n",
      "        .. [2] Waloddi Weibull, \"A Statistical Distribution Function of\n",
      "               Wide Applicability\", Journal Of Applied Mechanics ASME Paper\n",
      "               1951.\n",
      "        .. [3] Wikipedia, \"Weibull distribution\",\n",
      "               https://en.wikipedia.org/wiki/Weibull_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> a = 5. # shape\n",
      "        >>> s = np.random.weibull(a, 1000)\n",
      "        \n",
      "        Display the histogram of the samples, along with\n",
      "        the probability density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> x = np.arange(1,100.)/50.\n",
      "        >>> def weib(x,n,a):\n",
      "        ...     return (a / n) * (x / n)**(a - 1) * np.exp(-(x / n)**a)\n",
      "        \n",
      "        >>> count, bins, ignored = plt.hist(np.random.weibull(5.,1000))\n",
      "        >>> x = np.arange(1,100.)/50.\n",
      "        >>> scale = count.max()/weib(x, 1., 5.).max()\n",
      "        >>> plt.plot(x, weib(x, 1., 5.)*scale)\n",
      "        >>> plt.show()\n",
      "    \n",
      "    zipf(...) method of numpy.random.mtrand.RandomState instance\n",
      "        zipf(a, size=None)\n",
      "        \n",
      "        Draw samples from a Zipf distribution.\n",
      "        \n",
      "        Samples are drawn from a Zipf distribution with specified parameter\n",
      "        `a` > 1.\n",
      "        \n",
      "        The Zipf distribution (also known as the zeta distribution) is a\n",
      "        continuous probability distribution that satisfies Zipf's law: the\n",
      "        frequency of an item is inversely proportional to its rank in a\n",
      "        frequency table.\n",
      "        \n",
      "        .. note::\n",
      "            New code should use the ``zipf`` method of a ``default_rng()``\n",
      "            instance instead; please see the :ref:`random-quick-start`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : float or array_like of floats\n",
      "            Distribution parameter. Must be greater than 1.\n",
      "        size : int or tuple of ints, optional\n",
      "            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n",
      "            a single value is returned if ``a`` is a scalar. Otherwise,\n",
      "            ``np.array(a).size`` samples are drawn.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray or scalar\n",
      "            Drawn samples from the parameterized Zipf distribution.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.stats.zipf : probability density function, distribution, or\n",
      "            cumulative density function, etc.\n",
      "        Generator.zipf: which should be used for new code.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density for the Zipf distribution is\n",
      "        \n",
      "        .. math:: p(x) = \\frac{x^{-a}}{\\zeta(a)},\n",
      "        \n",
      "        where :math:`\\zeta` is the Riemann Zeta function.\n",
      "        \n",
      "        It is named for the American linguist George Kingsley Zipf, who noted\n",
      "        that the frequency of any word in a sample of a language is inversely\n",
      "        proportional to its rank in the frequency table.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Zipf, G. K., \"Selected Studies of the Principle of Relative\n",
      "               Frequency in Language,\" Cambridge, MA: Harvard Univ. Press,\n",
      "               1932.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples from the distribution:\n",
      "        \n",
      "        >>> a = 2. # parameter\n",
      "        >>> s = np.random.zipf(a, 1000)\n",
      "        \n",
      "        Display the histogram of the samples, along with\n",
      "        the probability density function:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> from scipy import special  # doctest: +SKIP\n",
      "        \n",
      "        Truncate s values at 50 so plot is interesting:\n",
      "        \n",
      "        >>> count, bins, ignored = plt.hist(s[s<50], 50, density=True)\n",
      "        >>> x = np.arange(1., 50.)\n",
      "        >>> y = x**(-a) / special.zetac(a)  # doctest: +SKIP\n",
      "        >>> plt.plot(x, y/max(y), linewidth=2, color='r')  # doctest: +SKIP\n",
      "        >>> plt.show()\n",
      "\n",
      "DATA\n",
      "    __all__ = ['beta', 'binomial', 'bytes', 'chisquare', 'choice', 'dirich...\n",
      "\n",
      "FILE\n",
      "    /Users/yasmine/anaconda3/lib/python3.7/site-packages/numpy/random/__init__.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.random)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}