A - introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2018-04-24 - Génerer des sets de MotionClouds statiques\n",
    "On va génerer des ensembles de 500 MotionClouds statiques pour différentes valeurs de B$\\theta$ et $\\theta$, dans le but de faire apprendre à un réseau convolutionné la détection de l'orientation $\\theta$. Plus B$\\theta$ est grand, moins la détection de l'orientation devrait être facile :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N_B_thetas = 7\n",
    "\n",
    "B_thetas = np.pi*np.logspace(-6, -1, N_B_thetas, base=2)\n",
    "print(B_thetas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import MotionClouds as mc\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "downscale = 1\n",
    "fx, fy, ft = mc.get_grids(mc.N_X/downscale, mc.N_Y/downscale, 1)\n",
    "\n",
    "N_B_thetas = 3\n",
    "\n",
    "bw_values= np.pi*np.logspace(-6, -1, N_B_thetas, base=2)\n",
    "\n",
    "fig_width = 21\n",
    "\n",
    "bw_values = np.asarray([0.6,0.9, 1.57079633])\n",
    "fig, axs = plt.subplots(1, N_B_thetas, figsize=(fig_width, fig_width/N_B_thetas))\n",
    "\n",
    "for i_ax, B_theta in enumerate(bw_values):\n",
    "    theta = random.randint(0,180)\n",
    "    mc_i = mc.envelope_gabor(fx, fy, ft, V_X=0., V_Y=0., B_V=0, theta=theta/180*np.pi, B_theta=B_theta)\n",
    "    im = mc.random_cloud(mc_i)\n",
    "                \n",
    "    axs[i_ax].imshow(im[:, :, 0], cmap=plt.gray())\n",
    "    axs[i_ax].text(20, 20, r'$B_\\theta=%.1f$°' % (B_theta*180/np.pi), color='white', fontsize=32)\n",
    "    #axs[i_ax].text(170, 20, r'$\\theta=%.1f$°' % (theta), color='white', fontsize=32)\n",
    "    axs[i_ax].set_xticks([])\n",
    "    axs[i_ax].set_yticks([])\n",
    "    print(theta)\n",
    "plt.tight_layout()\n",
    "\n",
    "fig.subplots_adjust(hspace = .0, wspace = .0, left=0.0, bottom=0., right=1., top=1.)\n",
    "plt.savefig('./figs/MC.pdf',format='pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#un joli polarplot\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "angle_list = [131, 140, 38]\n",
    "angle_list2 = [16, 72, 117]\n",
    "\n",
    "\n",
    "\n",
    "f, axs = plt.subplots(1, 3, subplot_kw=dict(projection='polar'), figsize = (10,10))\n",
    "for i_ax, angle in enumerate(angle_list):\n",
    "    xs = (0,np.pi*angle_list[i_ax]/180)\n",
    "    ys = (0,1.6)\n",
    "    axs[i_ax].plot(xs, ys, lw = 6, color = 'g')\n",
    "\n",
    "    axs[i_ax].set_rmax(2)\n",
    "\n",
    "    axs[i_ax].set_rticks([])  # less radial ticks\n",
    "    axs[i_ax].set_rlabel_position(-22.5)  # get radial labels away from plotted line\n",
    "    axs[i_ax].grid(True)\n",
    "    \n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "f.subplots_adjust(hspace = .0, wspace = .0, left=0.0, bottom=0., right=1., top=1.)\n",
    "f.savefig('./figs/Polar_plot.pdf',format='pdf', bbox_inches = 'tight') \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On commence par génerer un ensemble de 500 clouds pour B$\\theta$ appartenant à [1°:15°] pour $\\theta$ = 0, $\\theta$ = $\\pi$/4, $\\theta$ = $\\pi$/2, $\\theta$ = 3$\\pi$/4.\n",
    "Pour chaque $\\theta$, on va créer un folder spécifique ou seront sauvegardés les 500 clouds.\n",
    "![Err : Impossible d'afficher le cercle trigonométrique](http://etc.usf.edu/clipart/43200/43215/unit-circle7_43215_sm.gif)\n",
    "On crée aussi un folder de 25 clouds qui serviront à tester le réseau."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import MotionClouds as mc\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import imageio\n",
    "\n",
    "downscale = 1\n",
    "fx, fy, ft = mc.get_grids(mc.N_X/downscale, mc.N_Y/downscale, 1)\n",
    "\n",
    "N_theta = 500\n",
    "N_theta_test = 25\n",
    "\n",
    "bw_values = np.pi*np.logspace(-7,-3.5, N_theta, base=2)\n",
    "bw_test_values = np.pi*np.logspace(-7,-3.5, N_theta_test, base=2)\n",
    "fig_width = 21\n",
    "print('Btheta list : \\n'+str( bw_values*180/np.pi))\n",
    "\n",
    "theta_list = [0,np.pi/2, np.pi/4, 3*np.pi/4] #liste des angles theta\n",
    "\n",
    "for t in theta_list :\n",
    "    if not os.path.exists('./clouds_easy/%s' % t): #si le folder n'existe pas on le crée\n",
    "        os.makedirs('./clouds_easy/%s' % t)\n",
    "    \n",
    "    for i_ax, B_theta in enumerate(bw_values):\n",
    "        mc_i = mc.envelope_gabor(fx, fy, ft, V_X=0., V_Y=0., B_V=0, theta=t, B_theta=B_theta)\n",
    "        im = mc.random_cloud(mc_i)\n",
    "        im = im\n",
    "        imageio.imwrite('./clouds_easy/%s/B0 %s.png' % (t , (B_theta*180/np.pi) ) , im[:, :, 0])\n",
    "\n",
    "        #plt.imshow(im[:, :, 0], cmap=plt.gray())\n",
    "        #plt.text(5, 29, r'$B_\\theta=%.1f$°' % (B_theta*180/np.pi), color='yellow', fontsize=32)\n",
    "        #plt.show()       \n",
    "\n",
    "for t in theta_list :\n",
    "    if not os.path.exists('./clouds_easy/%s' % t): #si le folder n'existe pas on le crée\n",
    "        os.makedirs('./clouds_easy/%s' % t)\n",
    "    if not os.path.exists('./clouds_easy_test/%s' % t):\n",
    "        os.makedirs('./clouds_easy_test/%s' % t)\n",
    "\n",
    "    for i_ax, B_theta in enumerate(bw_test_values):\n",
    "        mc_i = mc.envelope_gabor(fx, fy, ft, V_X=0., V_Y=0., B_V=0, theta=t, B_theta=B_theta)\n",
    "        im = mc.random_cloud(mc_i)\n",
    "        \n",
    "        imageio.imwrite('./clouds_easy_test/%s/B0 %s.png' % (t , (B_theta*180/np.pi) ) , im[:, :, 0])\n",
    "\n",
    "        #plt.imshow(im[:, :, 0], cmap=plt.gray())\n",
    "        #plt.text(5, 29, r'$B_\\theta=%.1f$°' % (B_theta*180/np.pi), color='yellow', fontsize=32)\n",
    "        #plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour des valeurs de B$\\theta$ entre 15° et 30° (un peu plus dur) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import MotionClouds as mc\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import imageio\n",
    "\n",
    "downscale = 1\n",
    "fx, fy, ft = mc.get_grids(mc.N_X/downscale, mc.N_Y/downscale, 1)\n",
    "\n",
    "N_theta = 500\n",
    "N_theta_test = 25\n",
    "\n",
    "bw_values = np.pi*np.logspace(-3.5, -2.5, N_theta, base=2)\n",
    "bw_test_values = np.pi*np.logspace(-3.5,-2.5, N_theta_test, base=2)\n",
    "\n",
    "fig_width = 21\n",
    "print('Btheta list : \\n'+str( bw_values*180/np.pi))\n",
    "\n",
    "theta_list = [0,np.pi/2, np.pi/4, 3*np.pi/4] #liste des angles theta\n",
    "for t in theta_list :\n",
    "    if not os.path.exists('./clouds_medium/%s' % t): #si le folder n'existe pas on le crée\n",
    "        os.makedirs('./clouds_medium/%s' % t)\n",
    "\n",
    "    for i_ax, B_theta in enumerate(bw_values):\n",
    "        mc_i = mc.envelope_gabor(fx, fy, ft, V_X=0., V_Y=0., B_V=0, theta=t, B_theta=B_theta)\n",
    "        im = mc.random_cloud(mc_i)\n",
    "        \n",
    "        \n",
    "        imageio.imwrite('./clouds_medium/%s/B0 %s.png' % (t , (B_theta*180/np.pi) ) , im[:, :, 0])\n",
    "\n",
    "        #plt.imshow(im[:, :, 0], cmap=plt.gray())\n",
    "        #plt.text(5, 29, r'$B_\\theta=%.1f$°' % (B_theta*180/np.pi), color='yellow', fontsize=32)\n",
    "        #plt.show()\n",
    "        \n",
    "for t in theta_list :\n",
    "    if not os.path.exists('./clouds_medium_test/%s' % t): #si le folder n'existe pas on le crée\n",
    "        os.makedirs('./clouds_medium_test/%s' % t)\n",
    "\n",
    "    for i_ax, B_theta in enumerate(bw_test_values):\n",
    "        mc_i = mc.envelope_gabor(fx, fy, ft, V_X=0., V_Y=0., B_V=0, theta=t, B_theta=B_theta)\n",
    "        im = mc.random_cloud(mc_i)\n",
    "        \n",
    "        imageio.imwrite('./clouds_medium_test/%s/B0 %s.png' % (t , (B_theta*180/np.pi) ) , im[:, :, 0])\n",
    "\n",
    "        #plt.imshow(im[:, :, 0], cmap=plt.gray())\n",
    "        #plt.text(5, 29, r'$B_\\theta=%.1f$°' % (B_theta*180/np.pi), color='yellow', fontsize=32)\n",
    "        #plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et enfin pour des valeurs de B$\\theta$ entre 30° et 45° (difficile) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import MotionClouds as mc\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import imageio\n",
    "\n",
    "downscale = 1\n",
    "fx, fy, ft = mc.get_grids(mc.N_X/downscale, mc.N_Y/downscale, 1)\n",
    "\n",
    "N_theta = 500\n",
    "N_theta_test = 25\n",
    "\n",
    "bw_values = np.pi*np.logspace(-2.5,-2, N_theta, base=2)\n",
    "bw_test_values = np.pi*np.logspace(-2.5,-2, N_theta_test, base=2)\n",
    "\n",
    "fig_width = 21\n",
    "print('Btheta list : \\n'+str( bw_values*180/np.pi))\n",
    "\n",
    "theta_list = [0,np.pi/2, np.pi/4, 3*np.pi/4] #liste des angles theta\n",
    "\n",
    "for t in theta_list :\n",
    "    if not os.path.exists('./clouds_hard/%s' % t): #si le folder n'existe pas on le crée\n",
    "        os.makedirs('./clouds_hard/%s' % t)\n",
    "\n",
    "    for i_ax, B_theta in enumerate(bw_values):\n",
    "        mc_i = mc.envelope_gabor(fx, fy, ft, V_X=0., V_Y=0., B_V=0, theta=t, B_theta=B_theta)\n",
    "        im = mc.random_cloud(mc_i)\n",
    "        \n",
    "        imageio.imwrite('./clouds_hard/%s/B0 %s.png' % (t , (B_theta*180/np.pi) ) , im[:, :, 0])\n",
    "\n",
    "        #plt.imshow(im[:, :, 0], cmap=plt.gray())\n",
    "        #plt.text(5, 29, r'$B_\\theta=%.1f$°' % (B_theta*180/np.pi), color='yellow', fontsize=32)\n",
    "        #plt.show()\n",
    "\n",
    "for t in theta_list :\n",
    "    if not os.path.exists('./clouds_hard_test/%s' % t): #si le folder n'existe pas on le crée\n",
    "        os.makedirs('./clouds_hard_test/%s' % t)\n",
    "\n",
    "    for i_ax, B_theta in enumerate(bw_test_values):\n",
    "        mc_i = mc.envelope_gabor(fx, fy, ft, V_X=0., V_Y=0., B_V=0, theta=t, B_theta=B_theta)\n",
    "        im = mc.random_cloud(mc_i)\n",
    "        \n",
    "        imageio.imwrite('./clouds_hard_test/%s/B0 %s.png' % (t , (B_theta*180/np.pi) ) , im[:, :, 0])\n",
    "\n",
    "        #plt.imshow(im[:, :, 0], cmap=plt.gray())\n",
    "        #plt.text(5, 29, r'$B_\\theta=%.1f$°' % (B_theta*180/np.pi), color='yellow', fontsize=32)\n",
    "        #plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Figure Ring Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "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",
      "    ==================== =========================================================\n",
      "    Utility functions\n",
      "    ==============================================================================\n",
      "    random_sample        Uniformly distributed floats over ``[0, 1)``.\n",
      "    random               Alias for `random_sample`.\n",
      "    bytes                Uniformly distributed random bytes.\n",
      "    random_integers      Uniformly distributed integers in a given range.\n",
      "    permutation          Randomly permute a sequence / generate a random sequence.\n",
      "    shuffle              Randomly permute a sequence in place.\n",
      "    seed                 Seed the random number generator.\n",
      "    choice               Random sample from 1-D array.\n",
      "    \n",
      "    ==================== =========================================================\n",
      "    \n",
      "    ==================== =========================================================\n",
      "    Compatibility functions\n",
      "    ==============================================================================\n",
      "    rand                 Uniformly distributed values.\n",
      "    randn                Normally distributed values.\n",
      "    ranf                 Uniformly distributed floating point numbers.\n",
      "    randint              Uniformly distributed integers in a given range.\n",
      "    ==================== =========================================================\n",
      "    \n",
      "    ==================== =========================================================\n",
      "    Univariate 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 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 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",
      "    info\n",
      "    mtrand\n",
      "    setup\n",
      "    tests (package)\n",
      "\n",
      "FUNCTIONS\n",
      "    beta(...) method of 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 normalisation, 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, non-negative.\n",
      "        b : float or array_like of floats\n",
      "            Beta, 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`` 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(...) method of 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",
      "        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",
      "               http://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 mtrand.RandomState instance\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.bytes(10)\n",
      "        ' eh\\x85\\x022SZ\\xbf\\xa4' #random\n",
      "    \n",
      "    chisquare(...) method of 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",
      "        Parameters\n",
      "        ----------\n",
      "        df : float or array_like of floats\n",
      "             Number of degrees of freedom, should 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",
      "               http://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])\n",
      "    \n",
      "    choice(...) method of 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",
      "        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",
      "        \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])\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])\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])\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])\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'],\n",
      "              dtype='|S11')\n",
      "    \n",
      "    dirichlet(...) method of 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. Dirichlet pdf is the conjugate\n",
      "        prior of a multinomial in Bayesian inference.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        alpha : array\n",
      "            Parameter of the distribution (k dimension for sample of\n",
      "            dimension k).\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,\n",
      "            The drawn samples, of shape (size, alpha.ndim).\n",
      "        \n",
      "        Raises\n",
      "        -------\n",
      "        ValueError\n",
      "            If any value in alpha is less than or equal to zero\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. math:: X \\approx \\prod_{i=1}^{k}{x^{\\alpha_i-1}_i}\n",
      "        \n",
      "        Uses the following property for computation: for each dimension,\n",
      "        draw a random sample y_i from a standard gamma generator of shape\n",
      "        `alpha_i`, then\n",
      "        :math:`X = \\frac{1}{\\sum_{i=1}^k{y_i}} (y_1, \\ldots, y_n)` is\n",
      "        Dirichlet distributed.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] David McKay, \"Information Theory, Inference and Learning\n",
      "               Algorithms,\" chapter 23,\n",
      "               http://www.inference.phy.cam.ac.uk/mackay/\n",
      "        .. [2] Wikipedia, \"Dirichlet distribution\",\n",
      "               http://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",
      "        >>> 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 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",
      "        Parameters\n",
      "        ----------\n",
      "        scale : float or array_like of floats\n",
      "            The scale parameter, :math:`\\beta = 1/\\lambda`.\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",
      "               http://en.wikipedia.org/wiki/Poisson_process\n",
      "        .. [3] Wikipedia, \"Exponential distribution\",\n",
      "               http://en.wikipedia.org/wiki/Exponential_distribution\n",
      "    \n",
      "    f(...) method of 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 should 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, should be > 0.\n",
      "        dfden : float or array_like of float\n",
      "            Degrees of freedom in denominator, should 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",
      "               http://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",
      "        >>> sort(s)[-10]\n",
      "        7.61988120985\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 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",
      "        Parameters\n",
      "        ----------\n",
      "        shape : float or array_like of floats\n",
      "            The shape of the gamma distribution. Should be greater than zero.\n",
      "        scale : float or array_like of floats, optional\n",
      "            The scale of the gamma distribution. Should be greater than zero.\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",
      "               http://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\n",
      "        >>> count, bins, ignored = plt.hist(s, 50, normed=True)\n",
      "        >>> y = bins**(shape-1)*(np.exp(-bins/scale) /\n",
      "        ...                      (sps.gamma(shape)*scale**shape))\n",
      "        >>> plt.plot(bins, y, linewidth=2, color='r')\n",
      "        >>> plt.show()\n",
      "    \n",
      "    geometric(...) method of 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",
      "        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.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 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",
      "        Returns\n",
      "        -------\n",
      "        out : tuple(str, ndarray of 624 uints, int, int, float)\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",
      "        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 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",
      "        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.\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",
      "        >>> 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, normed=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, normed=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 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",
      "        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.\n",
      "        \n",
      "        See Also\n",
      "        --------\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{m}{n}\\binom{N-m}{n-x}}{\\binom{N}{n}},\n",
      "        \n",
      "        where :math:`0 \\le x \\le m` and :math:`n+m-N \\le x \\le n`\n",
      "        \n",
      "        for P(x) the probability of x successes, n = ngood, m = nbad, and\n",
      "        N = number of samples.\n",
      "        \n",
      "        Consider an urn with black and white marbles in it, ngood of them\n",
      "        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",
      "               http://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",
      "        >>> 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 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",
      "        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.\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",
      "               http://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, normed=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 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",
      "        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. Should be greater than zero.\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",
      "               http://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",
      "        >>> count, bins, ignored = plt.hist(s, bins=50)\n",
      "        \n",
      "        #   plot against distribution\n",
      "        \n",
      "        >>> def logist(x, loc, scale):\n",
      "        ...     return exp((loc-x)/scale)/(scale*(1+exp((loc-x)/scale))**2)\n",
      "        >>> plt.plot(bins, logist(bins, loc, scale)*count.max()/\\\n",
      "        ... logist(bins, loc, scale).max())\n",
      "        >>> plt.show()\n",
      "    \n",
      "    lognormal(...) method of 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",
      "        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. Should\n",
      "            be greater than zero. 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",
      "               http://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, normed=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.random(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, normed=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 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",
      "        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 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",
      "               http://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",
      "        >>> count, bins, ignored = plt.hist(s)\n",
      "        \n",
      "        #   plot against distribution\n",
      "        \n",
      "        >>> def logseries(k, p):\n",
      "        ...     return -p**k/(k*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 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 generalisation 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\n",
      "            Number of experiments.\n",
      "        pvals : sequence of floats, length p\n",
      "            Probabilities of each of the ``p`` different outcomes.  These\n",
      "            should 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",
      "        >>> np.random.multinomial(20, [1/6.]*6, size=1)\n",
      "        array([[4, 1, 7, 5, 2, 1]])\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],\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])\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])\n",
      "        \n",
      "        not like:\n",
      "        \n",
      "        >>> np.random.multinomial(100, [1.0, 2.0])  # WRONG\n",
      "        array([100,   0])\n",
      "    \n",
      "    multivariate_normal(...) method of mtrand.RandomState instance\n",
      "        multivariate_normal(mean, cov[, size, check_valid, tol])\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",
      "        \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.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]\n",
      "    \n",
      "    negative_binomial(...) method of 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` trials and `p` probability of success where `n` is an\n",
      "        integer > 0 and `p` is in the interval [0, 1].\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 negative binomial distribution,\n",
      "            where each sample is equal to N, the number of trials it took to\n",
      "            achieve n - 1 successes, N - (n - 1) failures, and a success on the,\n",
      "            (N + n)th trial.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The probability density for the negative binomial distribution is\n",
      "        \n",
      "        .. math:: P(N;n,p) = \\binom{N+n-1}{n-1}p^{n}(1-p)^{N},\n",
      "        \n",
      "        where :math:`n-1` is the number of successes, :math:`p` is the\n",
      "        probability of success, and :math:`N+n-1` is the number of trials.\n",
      "        The negative binomial distribution gives the probability of n-1\n",
      "        successes and N failures in N+n-1 trials, and success on the (N+n)th\n",
      "        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",
      "               http://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):\n",
      "        ...    probability = sum(s<i) / 100000.\n",
      "        ...    print i, \"wells drilled, probability of one success =\", probability\n",
      "    \n",
      "    noncentral_chisquare(...) method of 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 generalisation of\n",
      "        the :math:`\\chi^2` distribution.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        df : float or array_like of floats\n",
      "            Degrees of freedom, should 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, should 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",
      "        In Delhi (2007), it is noted that the noncentral chi-square is\n",
      "        useful in bombing and coverage problems, the probability of\n",
      "        killing the point target given by the noncentral chi-squared\n",
      "        distribution.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Delhi, M.S. Holla, \"On a noncentral chi-square distribution in\n",
      "               the analysis of weapon systems effectiveness\", Metrika,\n",
      "               Volume 15, Number 1 / December, 1970.\n",
      "        .. [2] Wikipedia, \"Noncentral chi-square distribution\"\n",
      "               http://en.wikipedia.org/wiki/Noncentral_chi-square_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, normed=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), normed=True)\n",
      "        >>> values2 = plt.hist(np.random.chisquare(3, 100000),\n",
      "        ...                    bins=np.arange(0., 25, .1), normed=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, normed=True)\n",
      "        >>> plt.show()\n",
      "    \n",
      "    noncentral_f(...) method of 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",
      "        Parameters\n",
      "        ----------\n",
      "        dfnum : float or array_like of floats\n",
      "            Numerator degrees of freedom, should 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, should be > 0.\n",
      "        nonc : float or array_like of floats\n",
      "            Non-centrality parameter, the sum of the squares of the numerator\n",
      "            means, should 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",
      "               http://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, normed=True)\n",
      "        >>> c_vals = np.random.f(dfnum, dfden, 1000000)\n",
      "        >>> F = np.histogram(c_vals, bins=50, normed=True)\n",
      "        >>> plt.plot(F[1][1:], F[0])\n",
      "        >>> plt.plot(NF[1][1:], NF[0])\n",
      "        >>> plt.show()\n",
      "    \n",
      "    normal(...) method of 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",
      "        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.\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",
      "        `numpy.random.normal` is more likely to return samples lying close to\n",
      "        the mean, rather than those far away.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Wikipedia, \"Normal distribution\",\n",
      "               http://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)) < 0.01\n",
      "        True\n",
      "        \n",
      "        >>> abs(sigma - np.std(s, ddof=1)) < 0.01\n",
      "        True\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, normed=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",
      "    pareto(...) method of 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",
      "        Parameters\n",
      "        ----------\n",
      "        a : float or array_like of floats\n",
      "            Shape of the distribution. Should be greater than zero.\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",
      "               http://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, normed=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 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",
      "        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",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.permutation(10)\n",
      "        array([1, 7, 4, 3, 0, 9, 2, 5, 8, 6])\n",
      "        \n",
      "        >>> np.random.permutation([1, 4, 9, 12, 15])\n",
      "        array([15,  1,  9,  4, 12])\n",
      "        \n",
      "        >>> arr = np.arange(9).reshape((3, 3))\n",
      "        >>> np.random.permutation(arr)\n",
      "        array([[6, 7, 8],\n",
      "               [0, 1, 2],\n",
      "               [3, 4, 5]])\n",
      "    \n",
      "    poisson(...) method of 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",
      "        Parameters\n",
      "        ----------\n",
      "        lam : float or array_like of floats\n",
      "            Expectation of interval, should 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 long 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",
      "               http://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, normed=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 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",
      "        Parameters\n",
      "        ----------\n",
      "        a : float or array_like of floats\n",
      "            Parameter of the distribution. Should be greater than zero.\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",
      "               http://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\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)\n",
      "        \n",
      "        >>> plt.figure()\n",
      "        >>> plt.hist(rvs, bins=50, normed=True)\n",
      "        >>> plt.plot(xx,powpdf,'r-')\n",
      "        >>> plt.title('np.random.power(5)')\n",
      "        \n",
      "        >>> plt.figure()\n",
      "        >>> plt.hist(1./(1.+rvsp), bins=50, normed=True)\n",
      "        >>> plt.plot(xx,powpdf,'r-')\n",
      "        >>> plt.title('inverse of 1 + np.random.pareto(5)')\n",
      "        \n",
      "        >>> plt.figure()\n",
      "        >>> plt.hist(1./(1.+rvsp), bins=50, normed=True)\n",
      "        >>> plt.plot(xx,powpdf,'r-')\n",
      "        >>> plt.title('inverse of stats.pareto(5)')\n",
      "    \n",
      "    rand(...) method of mtrand.RandomState instance\n",
      "        rand(d0, d1, ..., dn)\n",
      "        \n",
      "        Random values in a given shape.\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, should all be positive.\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",
      "        Notes\n",
      "        -----\n",
      "        This is a convenience function. If you want an interface that\n",
      "        takes a shape-tuple as the first argument, refer to\n",
      "        np.random.random_sample .\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 mtrand.RandomState instance\n",
      "        randint(low, high=None, size=None, dtype='l')\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",
      "        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 one above the\n",
      "            *highest* such integer).\n",
      "        high : int, 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",
      "        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. All dtypes are determined by their\n",
      "            name, i.e., 'int64', 'int', etc, so byteorder is not available\n",
      "            and a specific precision may have different C types depending\n",
      "            on the platform. The default value is 'np.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.random_integers : similar to `randint`, only for the closed\n",
      "            interval [`low`, `high`], and 1 is the lowest value if `high` is\n",
      "            omitted. In particular, this other one is the one to use to generate\n",
      "            uniformly distributed discrete non-integers.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.randint(2, size=10)\n",
      "        array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0])\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],\n",
      "               [3, 2, 2, 0]])\n",
      "    \n",
      "    randn(...) method of mtrand.RandomState instance\n",
      "        randn(d0, d1, ..., dn)\n",
      "        \n",
      "        Return a sample (or samples) from the \"standard normal\" distribution.\n",
      "        \n",
      "        If positive, int_like or int-convertible arguments are provided,\n",
      "        `randn` generates an array of shape ``(d0, d1, ..., dn)``, filled\n",
      "        with random floats sampled from a univariate \"normal\" (Gaussian)\n",
      "        distribution of mean 0 and variance 1 (if any of the :math:`d_i` are\n",
      "        floats, they are first converted to integers by truncation). A single\n",
      "        float randomly sampled from the distribution is returned if no\n",
      "        argument is provided.\n",
      "        \n",
      "        This is a convenience function.  If you want an interface that takes a\n",
      "        tuple as the first argument, use `numpy.random.standard_normal` instead.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        d0, d1, ..., dn : int, optional\n",
      "            The dimensions of the returned array, should be all positive.\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",
      "        random.standard_normal : Similar, but takes a tuple as its argument.\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",
      "        >>> 2.5 * np.random.randn(2, 4) + 3\n",
      "        array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],  #random\n",
      "               [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]]) #random\n",
      "    \n",
      "    random = random_sample(...) method of 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",
      "        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",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.random_sample()\n",
      "        0.47108547995356098\n",
      "        >>> type(np.random.random_sample())\n",
      "        <type 'float'>\n",
      "        >>> np.random.random_sample((5,))\n",
      "        array([ 0.30220482,  0.86820401,  0.1654503 ,  0.11659149,  0.54323428])\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],\n",
      "               [-2.99091858, -0.79479508],\n",
      "               [-1.23204345, -1.75224494]])\n",
      "    \n",
      "    random_integers(...) method of 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 type used by Python 2 for \"short\"\n",
      "        integers and its precision 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",
      "        random.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\n",
      "        >>> type(np.random.random_integers(5))\n",
      "        <type 'int'>\n",
      "        >>> np.random.random_integers(5, size=(3,2))\n",
      "        array([[5, 4],\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  ])\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, normed=True)\n",
      "        >>> plt.show()\n",
      "    \n",
      "    random_sample(...) method of 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",
      "        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",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.random_sample()\n",
      "        0.47108547995356098\n",
      "        >>> type(np.random.random_sample())\n",
      "        <type 'float'>\n",
      "        >>> np.random.random_sample((5,))\n",
      "        array([ 0.30220482,  0.86820401,  0.1654503 ,  0.11659149,  0.54323428])\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],\n",
      "               [-2.99091858, -0.79479508],\n",
      "               [-1.23204345, -1.75224494]])\n",
      "    \n",
      "    ranf = random_sample(...) method of 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",
      "        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",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.random_sample()\n",
      "        0.47108547995356098\n",
      "        >>> type(np.random.random_sample())\n",
      "        <type 'float'>\n",
      "        >>> np.random.random_sample((5,))\n",
      "        array([ 0.30220482,  0.86820401,  0.1654503 ,  0.11659149,  0.54323428])\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],\n",
      "               [-2.99091858, -0.79479508],\n",
      "               [-1.23204345, -1.75224494]])\n",
      "    \n",
      "    rayleigh(...) method of 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",
      "        Parameters\n",
      "        ----------\n",
      "        scale : float or array_like of floats, optional\n",
      "            Scale, also equals the mode. Should be >= 0. 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",
      "               http://www.brighton-webs.co.uk/distributions/rayleigh.asp\n",
      "        .. [2] Wikipedia, \"Rayleigh distribution\"\n",
      "               http://en.wikipedia.org/wiki/Rayleigh_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw values from the distribution and plot the histogram\n",
      "        \n",
      "        >>> values = hist(np.random.rayleigh(3, 100000), bins=200, normed=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\n",
      "    \n",
      "    sample = random_sample(...) method of 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",
      "        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",
      "        Examples\n",
      "        --------\n",
      "        >>> np.random.random_sample()\n",
      "        0.47108547995356098\n",
      "        >>> type(np.random.random_sample())\n",
      "        <type 'float'>\n",
      "        >>> np.random.random_sample((5,))\n",
      "        array([ 0.30220482,  0.86820401,  0.1654503 ,  0.11659149,  0.54323428])\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],\n",
      "               [-2.99091858, -0.79479508],\n",
      "               [-1.23204345, -1.75224494]])\n",
      "    \n",
      "    seed(...) method of mtrand.RandomState instance\n",
      "        seed(seed=None)\n",
      "        \n",
      "        Seed the generator.\n",
      "        \n",
      "        This method is called when `RandomState` is initialized. It can be\n",
      "        called again to re-seed the generator. For details, see `RandomState`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        seed : int or 1-d array_like, optional\n",
      "            Seed for `RandomState`.\n",
      "            Must be convertible to 32 bit unsigned integers.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        RandomState\n",
      "    \n",
      "    set_state(...) method of 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 the\n",
      "        \"Mersenne Twister\"[1]_ pseudo-random number generating algorithm.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        state : tuple(str, ndarray of 624 uints, int, int, float)\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",
      "        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 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",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The array or list to be shuffled.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        None\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]\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],\n",
      "               [6, 7, 8],\n",
      "               [0, 1, 2]])\n",
      "    \n",
      "    standard_cauchy(...) method of 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",
      "        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",
      "              http://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",
      "              http://en.wikipedia.org/wiki/Cauchy_distribution\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw samples and plot the distribution:\n",
      "        \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 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",
      "        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",
      "        Examples\n",
      "        --------\n",
      "        Output a 3x8000 array:\n",
      "        \n",
      "        >>> n = np.random.standard_exponential((3, 8000))\n",
      "    \n",
      "    standard_gamma(...) method of 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",
      "        Parameters\n",
      "        ----------\n",
      "        shape : float or array_like of floats\n",
      "            Parameter, should 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 ``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",
      "        \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",
      "               http://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\n",
      "        >>> count, bins, ignored = plt.hist(s, 50, normed=True)\n",
      "        >>> y = bins**(shape-1) * ((np.exp(-bins/scale))/ \\\n",
      "        ...                       (sps.gamma(shape) * scale**shape))\n",
      "        >>> plt.plot(bins, y, linewidth=2, color='r')\n",
      "        >>> plt.show()\n",
      "    \n",
      "    standard_normal(...) method of mtrand.RandomState instance\n",
      "        standard_normal(size=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",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : float or ndarray\n",
      "            Drawn samples.\n",
      "        \n",
      "        Examples\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",
      "    standard_t(...) method of 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",
      "        Parameters\n",
      "        ----------\n",
      "        df : float or array_like of floats\n",
      "            Degrees of freedom, should 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",
      "               http://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 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, normed=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 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",
      "        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 should fulfill the condition ``left <= mode <= right``.\n",
      "        right : float or array_like of floats\n",
      "            Upper limit, should 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",
      "               http://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",
      "        ...              normed=True)\n",
      "        >>> plt.show()\n",
      "    \n",
      "    uniform(...) method of 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",
      "        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",
      "        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",
      "        \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.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, normed=True)\n",
      "        >>> plt.plot(bins, np.ones_like(bins), linewidth=2, color='r')\n",
      "        >>> plt.show()\n",
      "    \n",
      "    vonmises(...) method of 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",
      "        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.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\n",
      "        >>> plt.hist(s, 50, normed=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))\n",
      "        >>> plt.plot(x, y, linewidth=2, color='r')\n",
      "        >>> plt.show()\n",
      "    \n",
      "    wald(...) method of 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",
      "        Parameters\n",
      "        ----------\n",
      "        mean : float or array_like of floats\n",
      "            Distribution mean, should be > 0.\n",
      "        scale : float or array_like of floats\n",
      "            Scale parameter, should 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",
      "               http://www.brighton-webs.co.uk/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, \"Wald distribution\"\n",
      "               http://en.wikipedia.org/wiki/Wald_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, normed=True)\n",
      "        >>> plt.show()\n",
      "    \n",
      "    weibull(...) method of 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",
      "        Parameters\n",
      "        ----------\n",
      "        a : float or array_like of floats\n",
      "            Shape of the distribution. Should be greater than zero.\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",
      "               http://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 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",
      "        Parameters\n",
      "        ----------\n",
      "        a : float or array_like of floats\n",
      "            Distribution parameter. Should 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.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\n",
      "        \n",
      "        Truncate s values at 50 so plot is interesting:\n",
      "        \n",
      "        >>> count, bins, ignored = plt.hist(s[s<50], 50, normed=True)\n",
      "        >>> x = np.arange(1., 50.)\n",
      "        >>> y = x**(-a) / special.zetac(a)\n",
      "        >>> plt.plot(x, y/max(y), linewidth=2, color='r')\n",
      "        >>> plt.show()\n",
      "\n",
      "DATA\n",
      "    __all__ = ['beta', 'binomial', 'bytes', 'chisquare', 'choice', 'dirich...\n",
      "\n",
      "FILE\n",
      "    /home/hugo/anaconda3/lib/python3.6/site-packages/numpy/random/__init__.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function vonmises:\n",
      "\n",
      "vonmises(...) method of 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",
      "    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.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\n",
      "    >>> plt.hist(s, 50, normed=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))\n",
      "    >>> plt.plot(x, y, linewidth=2, color='r')\n",
      "    >>> plt.show()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.random.vonmises)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-01T10:13:12.173212Z",
     "start_time": "2018-10-01T10:13:12.147165Z"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-01T10:50:34.408550Z",
     "start_time": "2018-10-01T10:50:27.592737Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/hugo/anaconda3/lib/python3.6/site-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  warnings.warn(message, mplDeprecation, stacklevel=1)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min 1.0376118465799387 2.1283458337968604\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcgAAAHICAYAAADKoXrqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsnXm8VHX9/59v9h0EBBSViygIiqG4b6m4k2lpZlaamWbf6ttq8bNl7mnxi6mVlaZpblmaaWoGroD7khtEypIgIAoKouz7ff/+eH8OM3eYe2fm3tnuzPv5eMzj3Jk55/P5zNw553Xen897EVXFcRzHcZzGtCv3ABzHcRynEnGBdBzHcZwMuEA6juM4TgZcIB3HcRwnAy6QjuM4jpMBF0jHcRzHyYALpOM4juNkwAXScRzHcTLgAuk4juM4GXCBdBzHcZwMuEA6juM4TgZcIB3HcRwnAy6QjuM4jpMBF0jHcRzHyYALpOM4juNkwAXScRzHcTLgAuk4juM4GXCBdBzHcZwMuEA6juM4TgZcIB3HcRwnAy6QjuM4jpMBF0jHcRzHyYALpOM4juNkwAXScRzHcTLgAuk4juM4GXCBdBzHcZwMuEA6juM4TgZcIB3HcRwnAy6QjuM4jpMBF0jHcRzHyYALpOM4juNkwAXScRzHcTLQodwDcBwniUQS37SqJlTLOhjHqXFcIB2nsjgL6AVMB/5V5rE4Tk3jU6yOU5m49eg4ZcYtSMcpMxLJAGA8ICSF0QXSccqMC6TjVAYdw3Zz2LZIICWSzkAnYL0mdEshBuY4tYoLpOO0gOBMczrQHXhGEzq/Fc1lEsOWWpB7AocBm4BbWjogx3FcIB2nRWhCGySSHkAXTCRzRiI5GnPEmaMJnUNmMWxo5vjdgUHARkwINwLzg8XYJey2Lp8xOY6zPS6QjtNy1tACgQT6A32Bd8LzTGK4nWhKJEdhjnW9gYHABpKCuBDYAnQLzztLJJ8G1gIPa0I34zhOXrhAOk7LWYuJXbdsO6YRrw1ui3nMsE+m13YnrC+m7aOYJQlJwQQT0h4ujo7TMlwgHaflrA3blgpk+7DNJIZ1EslgTPgE2ErT5+vGlKQCXdPaXJthf8dxcsAF0nFagIh0pg8XsZ6TgM1SL+8Bkare18T+NwK3qupT5GZB9sKENzmN+gCHMpx5jGBR2nEbU47LKJAiUg/0UNXv5v4pHae2cYF0nJZxLRvoxzeopxvrqOcl4CERWaGqT6buKCLtVfVLKS+lW5BNOuSQFLoG3uAwurOGEbyVts+GlL9jgYzFd01uH8dxnHREPd2j4+SFiAwBXuMkDuQQjgwv30Q9FwJnAn9C+AwdWEkDezGKCcwhAfyfbtT75Csynn8wgRX0ZwOb6cDTTGAGHVB+ybfpy0KWU8dm+jKI5zmfB7ifQ5jBOXRkNe1Zz6HczZG8wp2czkJGs551wNtcyOMMZhXv0447uJBV7Eg7FtHAUjaxwC1Ix8kdTzXnOPkzGniDQ3g75bXxfIw+CPsjCMoRnMUMfsTVnMEudKUP3egMwJ1czM7MZQJfA8bQQH/+yeHbWlpLX77FZXyZn7GYo5nDAE7jaXqykIO5k++R4Ehm8w8OZxUD+C4/p57fsw/v8w8+BcD9nE5HNnApl3I+f6eBo0r39ThOdeBTrI6TPxK2qQ4wvelAN9rRgTEcxTzmsSfLSL0J7RjOt1UczuusYyZHA6tpoDsfkkw0sAcv056t9GU93XiHJezIiEZibFOzi9if1ezOlfwUoR2K0CFMt77PSI7iTqAdA1lDb6bxfqG/BsepblwgHSdfOvEfNrEnrzGWvdmEhV40MJ/d6R4caNpvc5xJ5lftsG3NUfgk17IHr2hCH5JIugDnbmu/I5tJinADDbSjsSOPvacIezOJj/MYjR16GlKOb5fSis8YOU4e+AnjOPlyKW+xE9N5nGtYG3KozmAXZnEKB2JerLJNoCB2wukQbkh78ARTOYnN4dib6cs8+mXptYEObGA9XYnFbwjTmcPRLAuJCtbRnhnsAmylP7OZwWFAB96jO2s5nl3ZRyI5sBBfgePUAm5BOk6eaEK3yFr5I3/lHK7m57RjK8ImDuROjmQuD7AzNBLIrQC0D+fbmUzkYSZyFdfI5XIVwmaWMYlhjSZB06t6KHvzJP/iTF7nBA7hbj7O89xFb27iBwjtaEAZzpN8hDc4jUn8hXO5nJ/Qhffpx39CO56CznFyxL1YHacFSCSnAwMwwemGZbfpilXjiCtzKCaUG4HOwNOa0NclklHAESmvN5CczYmPj9tLb38LyRvbrdh6ZNxOvG+8TR1L3MdyLPTjdU3oYomkE4AmNM7E4zhOwC1Ix2kZazCBjGm85mc0YAIW34XGYpVehkrYnkyvxW3GJNc0G2/j/raGPrem7NsbS4/3Zni+J3C4RPIhsBp4H3gxJTOP49QsLpBOTRLKVR2HidxkTeiKPJtYHTcVtu3TtpAUplhsuksk/UgG86cLWyaaEqpUq7N92nuSsk/qOCB5zu8gkewG7Biedwb6AH00of9qZjyOUzO4k45Tk2hCG7CKGt1IikQ+NCWQEK85br+OuDtwBvCRtGObI90qbEjbwvZCmd5uvO+WlPdGAycBu6W178EgjhNwgXRqmffCtn8uO4vIxSLyrfA0TuEWW2Sp51IskOkp5NKFK/m8nutZGRIJpPIw+3ELZ7C92DakPE+f3k0/r1MFMh6fiel0duchxqYcsxxAItlNIjlLIjlsuzE5To3gU6xOLfMesAc5WpCqel3K09iCTLUcYweadGFMnybNxXI0TmQ6MIftLcl4u4Xk2ma6WKf3k3pMe6CBtxjCQvYFXoiPkUh6Yt9JH5Kf03FqDhdIp5ZZFrb9JJJ2mtAGEfkR0FdVvwUgIv2AudhU5CV0YAd+yDSeZT+e4Qso7VDaMZrJnMLT/IrvszcPcAJzAeVXfGfb8zs4mbc5jAaE9mxhHLczplGGnFRM3O7lCN7mAL7Gr3iG4TzNp+jLQlZQhyCcwrXsw/s8w548w9n0ZhGr2AWhgZO4gX1Yzn0cxWLG8jV+BcB9HM5ixvIp/shMPs5WuvILIvoxlwvYAowlWXPyvYyjc5wawAXSqWWWk/Q03QF4n7FM4lUeke/K9XqlzgbOAe6nns38loG0YwdgAC9zGnvxKKfyLxrYxAf0pinLMU4acDTPshOPA5t5itE8xucZw8RmRyhpVuB6BnMgtzGGP/AXzuAJTmUfbqGBraxjF47gTg7jvzzAoTzIRezDZUiaRalhXANZxWj+wQL25uvcGMYfXxNiq3QZjlOjuEA6VU/wWB0A9NWEvh6/rgndKpG8j00n9pdINnAq3XiDZTzN+RLJS3Tlm6znC0ADO7ALm+kMbGUQc3iNk1lNf4YxnYN5h+2nUhsL0yzquIOPs5luCLCegfl8DAC6sIQxodzVrrzJ24yOPw5deI/DeB3oyCk8yyt8jg/okiKQ7UNLTU3xbsJS1aXGWjayICWSIeHPJR476VQ77qTj1ALdgY8DR4S8p6nEFtIBwGeB3dmTZ3mDcfyHvWmgJ/X8C+hLwzYnly18iimczlV0ZTVP8nlu4zQApFH4hbA1WGIbaM/TfI1juIvvU89nuBpt9gY18/phOzZve8Vy57QL76Z7tyYdhdpvc+TpEN7pvK2FxsTHxJ9zlSZ0Q9o++wMnYmu3jlPVuEA6VY8mdDVJr9NBABJJe4lkAEkhSk4tHs2rrGQET3M8Q3gW+AxwekqTDcxhAHvxHp/gKUbwMCuoA6A7y1jC7gDMZDBr2RWhHevpiNKenVgBCNM4Oh5eU8NOe57dsWcDA3g6CNckDqIbb7MDa9iRZaxmMOvpxAbas4g4H2sHOrOBLXQLz+PrQSyy6dZjR5Iev+9kHY/jtHF8itWpaiSSjwB7kfQ2HQQsAAZjcYCxRdYpbNvTg/UMYDrvcDgncSmxZaUpHqRPMY572ZP2NACbOJa/AsIxPMTfuYgrGENP3qJHqO6xAxsYwf3cxKV0YQU7bcuN2uTQm9imv5+kO2/xGofyHOcCWziFm4EGDmI+r/IaV5OgC8voxVLW0xvowAHMZibH8wt+RF9m8yX+RlIo0x10BoZ+12lCP8wyfsdp83guVqeqkUgOxgLz41ymyzSh96aVmIqnRePSVXHZqPTcpul5UeNtnAs1Pj5ew0vNpJNpylRS+o73jfOnxtu4zbiPeGyNx/AkQ3iBz3IJP8wy5vj49LGmjjEey0vAfGClJlQlkgOwKdY3NKFTQzhIf+AdTWhc3stxqgafYnWqnTiMIvbK7C+RdAxra7EVFF/c47W3pgL80wPx0+MO4+fpaeeSNSEbB/inPs81djJ9m34ON2VxpveXvt64OeX1WNTHAmcBPcJ7O4XtkrAdChwPjMNxqhCfYnWqComkO+Zw01MT+k9gKcnwhdgqGwgsBt7FguHTxSkmPYVbhya2HVP2jy2xdAsxDidJfZ4qbtmmUJsSRnt+FHM5issy7JevYG4macl2wqZTV0sk7UkmZ4/XHweH7WIcpwpxC9KpNjYDw4GdJZI+2EU8zgYTW0uDwvbdsE23+Do2sY2nImOhE5LCkm2bbjmS9rwpizE9K066FZtt2z7L86ZyvcbfVfwd9Q/HrtWErgyCGVuUb+E4VYhbkE610R1YiVmGp5KsqZhKukDGAtgp5XkshPGUY7xWF6d22xL2T30/3r9DyjbXKdWmyDa1mv48m7WbfjPQlGDG2/4SycewNUtITq8ODG2u1YR+kNMncZw2hgukUzWkOOSkC2L8O48FcKBEchQmlPHUZyyAsfPKJswpJnXKMRa+uMYibG8hpgtiujCS5fUmP17YZrIQU63a+Hm7tG38emwFp1vHndK2qd/ZziRTz+0kkXyc5LqtW49O1eIC6bR5JJKuwAiSlmF80Y8D4juRFI94HXIojb1CUwUQmp4aTRfCpgSxueobqVuaeL7t44Vt6vpmuudrqtXajuT6YWztxs8zbVM9ZuP2Gkha0bFgdk7ZdicpkL7+6FQtLpBONdAROAi7oMcX99gijMMjNmLTrbFoNCWAuXqPpm9Tj1+Heci+jyUo2IpZYFsxQW7ARGlreMTjVpJWH5hYtQufo0N43imMv3N4rXvY9gr7dqSx400mazfVg7UjjYW0fcp3tZHGISGxkDaQFMyDJJLBwEIs3CNeu3ScNo8LpNPm0YSuCjlV+2EC1BW7qMdrhp3J7gTT1Npd+hod2Brn+5jorQTWYkK4FliviezBxSLSHhOfzpjoxGJIGOtWTKA2ARtUdXOmdrZrN5LYwuuBxT/2xr6PfqGfruQecpLqsJMqkHHO1o2YMHcFRgKbJJIlWCKGhRnS1DlOm8ITBThthpDqDE1sLxYSyf5YeEdTAfGZphEzhWWkTmOuBFYAH4Tth1h+0kbrhkHsdgZ2CdudMCeWAZj3Z1+sWkhvTFC6k0xIsJHG1iRhXO3DeDuFz6GYAK8O4/owjOl9LJ/su1hIy9vh8Zbq9gIlkfQI4+gbxjIAE9LuKd9Z+jb+TtOTD6wNx6UnI9gYxr0Ysyznu1g6bRG3IJ02gUSyLyaALwIzM+yyILyfumYWr6HF067p2WlSs9RswDw0V2Ap1lbkMl0oIlcC3wnHLsbEaQkmWNMx8YpFdiUmcGswqzDnu1MR6YSJUU9M4PpgItcfq0ayC3AgSaHeRUSWAbuk9qMJXRP631aHMlQ76R3aGhDaHUjTjjzp8Z/pMZax1d4P2DU8Hs71szpOpeAC6bQV1mG/1z0JAhlSnQ0DZmEX/diSidcdUy2a1PXHTZgFthgTsKWtSJW2M/BlVf1DC4/PCVXdhI07p5AKEdkZmJ2LCAeL+IPw+C9YMndMeAdin7Ef9t1uJXnT0Qm7CYkrpHRO28bT0/NyGbPjVBoukE5bYQFmAfaXSMYAdZg11RWzUAZiViAkpypTHWdWYNN9SzFBzGlNLwfmYQJSaQwBZrf0YE3oVsJ3BcwIVmZ/zFN4N8zijL1ZU6djY6t8KyaUW7DvvUkkknbp09aOUwm4QDoVi0QyENgbeF0TulQimYdV5tiH5FoY2Ppe7O0JybRyb2Np0d7ShKbHRhaKBcCRRWq7NdRhYysIQcDeC49/SyQdsBuDnYHdSToYxQ49G7H/0UJN6OaQAnBrE2uRH5dI1gDPFvH/5Dh54wLpVDK7kSzMuxSYiwlkvBYWO690xqb8toR9FmEhB6WwSt4kWRWkkqijgAKZTlifXRQez0skfbHY0l0wYdxWXkwiOQFbp9xVIpmPVQhZpAltkEh2JLnu+TLbJ3lwnLLhXqxOxRI8Ls/Bputu14RulEjOxrwv43XGDzArcR7wbi4hFgUdo8gwYIqq1rW2rdG3jhaAmefNbPVnEJHrgRmqem1r28q770h6Y2K5O7Z2Ccn4zthR6kNMwHuF/WKP2Fc0oS+VeMiOkxG3IJ2KQyLphwngOsxyHIRZkq8Bc4AxmCC+iVmK5bzLWwTsJCIdc41VbIavAUeNvnX0uTPPm7k+697NUwfc38o2WoQmdCXmwTtdItkBE8ARJBMcbMa8cPcl6QEbzwosK+1oHadpXCCdiiKEcxyCrR/2ITlVNwITyNeAmZWSsUVVN4vIu9jU4pstbWf0raMPAK7CwiEKUXy4jiJOseZKSGT+skTyChYfGqcE7Ig59nQj6eCzCrvhcJyKwAXSqTQWYQI5CJuS2wC8ilmOaEI3NX1o2ViACVKLBHL0raP7AHdh1vIXZp43s1VrpyLSDlu/XdCadgpJsPLfAd6RSDph4Tp7YgIZzwD8J9NsQAg5aSjzTIFTg7hAOhVDSDo+DJtaXQ38G/OCrPQQgAWYQOZNWHe8ERO0o2aeN/P9AoxnELBKtTI9QsNNzmvAaymeyrtiDlbbSAn/+Aiwu0TyrCb0ne0adJwi4QLplJ1Q2HhfLGTgXeBBTWghhKJULMCcUlrC/wBnAN+bed7MZws0njoqyHpsDk3ou8C7EkkHTegWiWQ3YDSWsOBgieS18Dz2VHackuEC6ZSNMNV2NBaAPg94QBO6tqyDahlvAsfke9DoW0fvD/wSmIytPxaKOtqIQMakrCm/gyVaH4UlgRiFieOH4eE4JcPDPJyyIpHshSWzrsS1xZwQkWOASFWPyvWY0beO7o3F/XUG9pt53szlBRzPD4Beqvr9QrVZaiQSwazy0ViWpI2Yw9ZkTejSco7NqR3cgnSKSrjQ7Q4s04SuSn9fE9ridGgVxALyWIMM6443hGM+WkhxDAwBXilwmyUlOOTMB+aHadexmGVZ6O/KcZrEBdIpNmOwKhNvAFPLPJZisRgYKCKdQlLxbFwMfAqYMPO8mc8UYTx1wL1FaLcsaEIXAYskkh4p65TtNaEtDqtxnFxol30Xx2kVc7AsKSvKPZBiERIELME8MZtl9K2j9wN+DTwIXFGkIQ2lFTGZlUoo1QUWFnKgRLJLOcfjVD8ukE5RCcmn79CETi/3WIrMQmxqMxvLgX8A57Y23jETIQZyV7JU0GjLaELfAu7WhC6WSDpLJMeE9HaOU1DcScdxCoCI3AI8pap/LPM4BgMvq+qgco6jVISqImOAnprQaeUej1Nd+Bqk4xSGBbQwWUCBqaONhXi0hhAesi25uURyCDad/1/PvOO0FhdIp1VIJF2Ag4C5Ne5+vwAYV+5BUKXrj3mwEPs9LsZLZzmtxAXSaS17YhUZaj2IewHNWJAi0gkr7NwH6ImFLHQNj07YuRj7BDRgJb42YfF/6zFHp1XASqzE13rNvD5SRw1ZkOloQpdQpiomTvXha5COUwBEpA6z3C7BnGQGY6nzBgI7YkIYZ4NZBazBLJyNmBBuJimcS7Cg+E5YIoGu4fWeQG9MaMEcft4N+7+DWU3nA5er6vXF+7SOUxu4QDpOARCR9sCV4elbmFgtwSp0LANWNmHxISInAL/DykH1wGJGbwSuVNWtTRzTDRPegeG4wZgw7wT8WFW9bJTjtBIXSMcpA0FQvwF8BZui3gq8BxwB3I6V/BIsI86FqrqyTEN1nJrF4yAdp4SISC8R+ROWQOF/MAEcq6ojCE4lqvp5YC/g98B+wMsiMkdERpRp2I5Tk7gF6TglQET2wNK/dcUywfwRuCJ1ClVEHgZOUFVJO/ZE4LfYDW0D8E1VnVyqsTtOreIC6ThFRESOB64hKW7fBiZlWo9sSiBT3t8DuA/ogonsDcBVTa1TOo7TOlwgHafANLG+eLqqzspyXLMCmbJfL+Ba4ODw0svARarbV0txHKfluEA6ToEQkZ6YtXgoSQebi1Q1pxjRXAUyZf/2wLeAL4eXtgCnqercfMfuOM72uEA6TisRkWEk1xcBbsZiEfOa+sxXINOOPQn4Dcmp3G+o6oP5tuM4ThIXSMdpIRnWF78D/LOpeMcsbXUCHgKOwYR2Ywvb2RPLJNMJX6d0nFbhAuk0QkQOAWbnOi1Ya4Rpzf/FQjRyXl/M0uYOWCacLikvj2+Np2pYp7wOK1YN8CJwsa9TZkZEBLs5eTrHotdODeBxkA4AItJRRH4NPAfcFYTACYhIz1DSajYmjtOBA1R1RGvEMRCnoItZD7RqHVFVV6nqOVg85Q2YUL4sIq8HK9NpzHeAKcBUEdmp3INxKgMXSAcR2RF4FBiOpS/rCNSXc0zlRIxrRGSaiIwSkRmYw83hwC3ASFX9VKGs7DCVei2wIbw0R1XfKFDbW1X1F6q6J+ZZ2wGYLCJzReQkEblMRJ4VkT6F6K8tIiIfBb6LVUJ5FHgxzKQ4NY5PsdY4IvIRbM3qL8CPVHWriAzEauxdrKqTyjrAMiAi38QumJ2wpOJbwvMHWrIumGOfuwL/DX19XVVvLkY/oa/hWDxlR+yGaC02BfspVd1crH4rERHZGfvs56vqI+G1U7FEDt9V1dvKOT6nvLhA1jAichqWFPtrqvrXtPcOB/4OHKqq88sxvnIgIuOxtbvYmusLfEJVnyxB388CY4F+qrqmyH31AV7FLMq1QHfgb8B3inUTUGmISEdgGvCwqv407b1RwAPA3cD/U9WGMgzRKTM+xVqDhCnEb2PTeqekiyOAqj4D/By4R0S6pr9fjQRr+gbMi7QDVmpqGuZAUwouwcIziiqOgbXAJCz/axesvNb5wEUl6LtSuAJb+/15+huq+jqWiOFQ4O5QPcWpMdyCrDGC883VwEcxT8kmyyIFz76/YMV5v1iiIZYNEfk9Vo1+MrYW9S9V3dD8UQXsP5KdsHWw+ZrQpSXpU6QdsDdwNPBxoB9wcLVPtYrIp4HLMEerD5rZrzN20zQCOFVV3yvREJ0KwAWyhgiW4B1YzcEzcimhJCI9gBeAX6vqDUUeYlkRkQ6quqXk/UbSHbgNOAUroNwZE+lzNaFrSzqWMn0HpURERgJPYkkZXs1hfwEi4BzgpEI5UDmVj0+x1ggh1u5RzOnklFzrC4bpvjOAy0RkbBGHWHbKKAyxOHYBeoftKeH1klID4tgTW1v/Xi7iCOZlrKo/Bn4BPFnt54GTxC3IGiDEdT2CCeR3W+JwICJnYms2B6jq+wUeYs0gkXQEegK9wqMOc47plGH3TcB4YAGwClitCV1fkoFWIcES/CuwUlUvbGEbpwN/AD6tqtMKOT6n8nCBrHJEJI7tuhm4rDUeiiJyJbZe9bFqT13W0vVAiaQd5hGaKoI9U553STtkNyzheCYnkHVYHchUL+ItBLHMsF2tifwtwHKsfZaD4Jh2DnBEa9aWReRo4C7gAlV9oEDDcyoQF8gqJsS7PQb8QlV/V4D2Oob2pqlqfWvbq0RyWQ+USLrQWPRSRbAnloIupgGb1t4mYjQWtr6YAKYLJ1ioyR6YUMZ9pW87pB2zLkMf8XadJpInfCWtfRYbETkSC9k4WFUXFKC9g7AwkK+r6l2tbc+pTFwgq5QQx/UoFvx/UwHbHYQlEbiwGqtFSCT3kFwPjNmIBZP/GhOm9OnQDZgAZRLBtZpofkq7iT43AJM1oWdkObYrTYtnd7YX69SxJYAjMWHMq9+2RFhieAmz+B4qYLv7Ag8Dl6jq7YVq16kcXCCrEBHZGxPH76vqn4rQfkHvxisFiWQwMI/GghGzGTgPWEiaCGqidSERTVhyk4DzWmPJheneHmQWz12AK7FsOulsAIZWw3RrmPWYAkxR1agI7cc3ov/Ps+5UHy6QVUZwYZ+C3dX+uYj9fAv4HHB4KWMFi4FE0gMYBXwMSymXKTHCSuBkTehzRRzHIGwt8M1ii5NEchg2ndo7w9trgbM00fJqIpWCiFwFjMTWzYuSDSecc49hN6RuSVYR6esXThsmVGl4FJhQTHEM/Bo4BPgd8KUi91VwJBLBrKhRmKMMwOs0npJMpTPwZjHHFESxVFbbm2S2lMGmkEeF6dvXgDda4vxTboLn9SeBscVMFaeqs0Jt0MdEZJOvSVYPbkFWCSIyBAt+/qmq3liiPnsC/wKuKOQ6ZzEJDjbDMWHshZWWmgXM1oSuac16YFujmc/6IPADzGO5LxZuMhd4XRNto06oiOwFPIUF9r9coj73xW5Qv+TerdWBC2QVEKpvPAVcq6q/LnHfI4FngHG5Bl6XA4lkACaKw7C8o0swi/HNVCeaYq0HViK5fFaJZCAmlLtjiUXewazKhdmcj8pFyP70Mnbjlvlmsb73wVhozYfY9PmHwCrqV7bKUg7erf/E4ySrAhfINo6I9AYeB+5vLvRi1l4jewNfA64fOXvW8gL2vw/wb+C8YjgEtQaJpAMmiHsD/TFHm/9iltCKLMeWbD2w3OTyWcN06wjsJqMHFk4yC5ilCV1XqrHmgojUYVPIn1HVOzPuVN97CnBshnfWkCxgvbKJv6dQv/KVZvo/GouTPLlU1qtTHFwg2zAhkfJD2B3915tLAjBrr5GjgP8Al42cPeuHBer/DKw01HcqyYNPIumNXchHYOtpH5BcS9tUzrG1dcLa7a7YTceugGJi9LomtFRVT7ISKrPcC9yDrck3TmxR33sEsBPmpNQnPFL/Tn8e/90e+Ab1K3+Tpf/TsWo5R3nu1raLC2QbJVRhuAOb9jo7l8w2s/YaeRdwIlA3cvasJisY5Nj3j4ALsFqJZb9LDiENu2HCuAsW8xdfuJeUc2zVikTSC/MVMy5oAAAgAElEQVQQ3Qubnv0Qm7aeWwk3IiLSD0sttxmzJlu3flrfW7DY0q3Ur8ya8k9ELgK+BxzmVUDaJi6QbRQRuQLzIj0+1zCLWXuN3BeYAdSPnD2rRTFhoSLIzcAQTBxLU5apiXRoEkk37AI9Ert4rSXpdFNRU3/VSpjK3h27ORmApcOLp7LfT9u3pGntRKQD8CtgHBbqUdLi3yLyU+AE4BhV/z22NVwg2yAicjGWv/NQ1ebX0tKZtdfIe7Haf0NGzp61Ks9+dwTux4Llzy9F/GMz6dAuwS60QzErejFmvSyqVOeRWkAi6Y9Nv+6BTUe+i01vvwvcQpnS2onIV4EfYjd1zxe7v5R+BbgVW7c9s5jhJk7hcYFsY4R4qz9hCZfzXtuYtdfIsVjarR+MnD3rsjz6HYatd/4N+GGpTvQmQhE2YRfd3wBzMEslp/JdTmmQSDqTDKfpDVwIjKaMae1EZDwm0l9S1ftL0WfotzNWTed5Vf1+qfp1Wo8LZBtCREZg4RxnquqTLW1n1l4j/4lNz9aNnD1rTQ797o+5rv9EVa9rab/5EqbjmkrkvREYpgl9u1TjcfInOPXsBzxH5pJeJU1rJyIHAP8A6lX1D6XoM/TbHys8HlWSQ5vTPF4wuY0gIn2wE/vS1ohj4KdAP+ArOfR7NGY5frWU4hgYiglhJjaQzIDjVCihekgXLCFDJjZi/+fSjEf1JeAo4PsicmmYAi1Fv8uBU4ErReSQUvTptB4XyDZA8Bq9HXikEFlyRs6e9QI25fPdWXuNzFSHMO53PBbPdbaq3tvaflvAGjLXSYQSpH5zCkZzae26UOL/Y1iaOBL4DHB5CUXydczz++5QYcSpcFwg2wYJrArDtwvY5k8xj8OMldVDjONNwKmqOrWA/eaERLIvcDDwKmYtphKvXVV1AH+1EMJsJrP9/3ET5li1j0SSafq1eGNSfQdzVjsG+G24CS1Fvw8ANwB/EyntZ3byxwWywgkn7o+BG1RbV1YplZGzZz2N3c1utx4iIp8GrgFOVNUXCtVnLkgknSSSE7A10gVY3GZ8cV0ZtpOAc0s5LqfVnMv2/8cHsGn+ocAnJJK+pRyQqr4PHAfsD/y+VCKJebUeDhxRov6cFuJOOm2AsA74F0y0/q+YHqQichZwNXCCqs4sVj8Z+46kH3A85hL/giaS/ddS6rdqJtP/MThjHYfVpnxKE/rfko7Jku4/iHlGf6XI59cJ2E3plcBVzWW/csqPC2QbQUQGY+uBK4BzVbXFmXCa6eMTwO8xcfx3odtvtu9IRmB31BuBx1wEa4uQ8GEclv5tFvCsJrJnhypY/yaSDwOvkCVtYwvbb4dVSPkKltXniUK27xQHF8g2RKiOfiVW2PcMVZ1ewLZPwqZ+TiplVY6QheVwLG/q28BUTWjWNF5O9RHSBR4AjAGWA49qQleXrH9L/P8YMA0rflyQi6OI7IDFLvcBzgrrn04bwAWyDSIiZwO/BS5R1VsK0N4RwN+B01T1uda2l3O/lsvzeCzk5BXg5RAW4NQwEskQzHkGYJomdGHJ+rb8rY8Dd6hqzok0mmlvPyxh+j+w87VgfgRO8XGBbKOIyChM1J4AvtHStG+hyOtjwGdV9dECDrH5fiOpw7wIFbMa3ypV307lE26ejsPKlE0HXipVCkER2RlLyHF5a5IJiMj5wC+Ar6nqXws1Pqd0uEC2YcK6SZw4/EzV/O60RWQIVuz4O6U6gcM02kHAvsAybBotazaftoqIdMMSGuwG7AwMBHYEdsBSsPUAumJZZtqHwxqwChQbsOTrq7CSXcuB97CixYuxnLgfVKujh0TSHpt+3wv7zFNLlYBeRPYAnsScdvJKSyciXbAZniOwpZDXizBEpwS4QLZxQpDzt7Hk3eep6sM5HrcDJo7Xq+rVRRxisk9zxDgOGIR5DD5fSkeMUiIi/wNcgYneIuAtbI31XezGYAUmfGuw4sObgPi7aId5dHbFKpT0wgS1PyawO2G1GIcAHYBHVfX0UnyuciCRDMfEZhMwpVTly0JaugexWOCcEpyHYs13YykSL1At3RqqU3hcIKsEETkKqw95PfCz5lzVQ4Dyw8B0Vf1WScYXyc6Yl2JH4ElNVHcRWRH5HWYFfqdYYQPh5ugI4C5VrerMLCFG8njsZuFfmtAZJenXskndCByerVRWiqPb5cCvqtWyryVcIKuIkL7qLswy+XymUljhonoj5hhzRi6Flls1JktWPQbzTlyJTakWPESl0gjllUar6sVF7ucTwBdV9dRi9lMJhGw7H8XiKBcAj5eiMHP4X34VK3y8XdHllALiF2FpGZ8q9pic0uCZdKoIVV0CHAvMBV4KVTjS+TaWOeRzJRDHzlgmnAOxKad7a0EcA3Ox0JViMwIr+VX1aEI3aUIfxSqD7AZ8MtSfLG6/qtcAU4A7RaR96nsi0herdDMOOMDFsbpwC7JKCRlxrsHiuW4Kr52IOfUcoqqLCtpfWqV4iWRHbEqsG/CcJvS1QvZX6YjIblj9v52L3M9NoZ+SlW6qBEJGnuOwJOjPaEJnh9cb/Q4L1p9IB6yqzauqekl4bSy23vh3YIKHcFQfLpBVjIiMxE7eZ4BfYgHQZxbyLlci6Y6lzkqtFP8UcB/wIZYV571C9ddWCNNuq4FBxXTUEJFnsBJoNZeZRSLpis2YDMY8er8MnEzydzgZOFcTurYg/VmM5IvApZj38f9hXq53F6J9p/JwgaxyQijIjcBZWAqt3xW0/UjuwcQxtajxZuBfwHGaaFl8ZjUgIjOw9cGXc9m/bsKkcZiH750LJo7PafpbRJZha51lT80X1rf3w5Lg76qqHy96n7bGPRb4A7A3jYsyx1VfzihYfyIfweIy52KJNWYXqm2n8vA1yConWC9nYxePawrZdpjOShdHME/VsVhqrVpmDvmtQ34L+BkWB5mVsP7VCQsdKRsi0kVEPoPNHNwLfBI4QER+IiKni0hdmKIsOCHz0tvAKBqLI9jv8pQwHVuY/lRnAHXAWBfH6qcoP1qnsgju5sUIVh6KTWelCyQkK8WX3bIpIzkLZN2EST2wNbXrFkwcn+u0zghgbgWEEwwGJmIxm5vCowNWkPgz8U5pdYkbsPSCr2A1P2cCy1oYEjMUsxYzFWUu+O8w34QcTtvFBdJpDc1Viu9MiSvFVyBzMQs7F47HvrN8srZUhAerqs4Tkb2xmMxTgZOAJ1X18wDB83MAlj1p//DYFwv9OSC1rTQRXUlSRF8BZgOrM9wQ+O/QKQoukE6L0YQukUiewBwlOqa8Fa/91LL1CCZeuSZiOA1zano6j/aHYyJcdlR1Debl+VAQxHYp720FloRHxkxPIXnFbtgaZiyiQ7Gk5cek7butaWx69TW+x0N04yQaz2Zswn+HTitwgXRajETSB/NW7YVd2GLvwUnAeWUcWqUwBxguItLcNGjdhEkdsBJmkxZMHJ9PqMAILDFERREEMa8YW1XdBLwRHn/LtI+I9AD2ICmg+2GW6NFcyXX8mMkkvam7YOkMf9rCj+E4LpBOy5BIOmLTguvCtidpleJrHVVdKSJrsCTlbzez66FYZqO8kmJTIVOspSJYqdPD4yYR+QlwGLCCBoZrQscFh5yh2LTqWGCsRPKWJvT9sg3cabO4QDot5UgsgfakEGe2ltp2yGmKOKNOcwJ5GjYd+FCujYZpzGHAf1s1ujZKEMcfARGWrWlXgHBzthRAIpmKedQeL5H8vRRp6ZzqwsM8nLyRSEZhU10vaUKbu/A7WTxZ6yZMEkwgpy2YOD6fhAK7ActVCxME35YQkZ8SxFFV6zEvWEnfTxO6HksR1wOrPeo4eeEC6eRFSCF3GFa+6dUyD6ctMBdzpmmKkdjNhk+v5kCwHH8I/CSII5iHa0aCRfkCUCeR7Fv8ETrVhAukkzMSSReS647TQpB2ecYi0l9ERpWr/zzIFgsZZ5t5IM92h9MGBFJEBopIQZK2p0yr/kRVEylvvRLe386KBNCEzsTWJA8OyS0cJydcIJ2cCCm9jsaSjz9azhRyInIE8B/gNREZXa5x5Eg2gTwNeHnBxPGL82x3BBUS4tEUItIVy64zW0T+tykBy7GtbWuOaeIIyXXYns008QRWBm5cKNztOFlxgXRyZQy27vWsJnRZOQYgxjeBe4AvYqEkfxWR7uUYT47MBwaLyHaB7HUTJvXEUqTlO70KbWOK9dfAS5gz0ReAO1ryv0oTx/r091OSwTd5IxIcdB7F0tEdK5H4tc/Jiv9InKxIJIOxjCdvaEKLkbIu+xhEumDV2s8DDlbVyap6G3YB/k05xpQLoQTSIkwkGhGccgYAV7eg6YoWSBH5NJZA4mJVnQ8cDqwHnhWRujzaSZ1Wrc+y+37NvakJXYElYtiZtAw+jpMJF0inWUI5q2OxtF9lKQYrIgOwUl2dgcNVdUHK2/8DHCEiny3H2HKkyWnWBRPHb1x4+cdWi0hnEekRHl1DuayMBCusPya8FYeI7A78FjhbVVcBqOp6zOq/CXhORA5r5vjhIvJYqHWZac2xKTIVCG+EJnQulrJujESyWw5tOjWMl7tymiRMQ30Muxj/XRP6YcnHYA4eDwK3A4lMGWlEZAw2fXaYqlZcXKCIXIl5/j4MDMGSew/EvtfeWJLvLViZMID22FTgRuzGZAXwHvAOJoo9gZNUdTurtNyElHFPA39W1YyWsYicjNUQ/R9V3S5rjog8hDmDtQNuUtULcuh3LrBSVQ/Mum8k7bG1317APZooXr1Op23jFqTTHAdh9QmfKJM4HoI5V/xMVX/cVLo2VZ0O1GPrkU0lrS4nf8GErSPwHLY290VMNAcDHVS1k6p2D48umEj2w6YNzwJ+gt0orMYE9bKSf4rcuAwL1G9y2ltVH8QE8Fci8vXU90TkcCwJRTssXV2uVt4CciyvpgndCjwWnh4fBNNxtsMtSCcjEslQ7CL2mib0mZL3L3I8JixfUNVJOewvmPPOW6r6jWKPrxCIyHDgLFX9WbnHUghE5BTgOmA/1eyp3cJa5CPAHdgNDsAMYDQWSvQE8I1cZgVEZCJwhqrumfN4IxmCZeGZpQkty/KBU9m4Belsh0TSG/goNq33fMn7FzkV+DPwyVzEEbbVvLwAOE1Eil7JvkCcTpUk0xaRwdj64mdzEUeAsJZ8JDbdeQUwHhPHGcDxqnpKHlPmTSYLaLL/hC4MfY2USHIWVqd2cIF0GiGRdMAsRwUeC9NRpetf5DTgRmC8an539ar6AXAOcIOI7FqM8RWYqii8G/LC/hn4XQv+Z+9i5aw+CpyMrXnvp6rP5jmM6WEs+V7TXsTKcB0pkfTN81inynGBdNI5HOgLTNWErillxyIyHvgDcIqqvtiSNsKF9VdYzF2lJ+OvCoHEUr9tBf6vJQeHG5vjsTXvY1s4hvi77J9X3wltwPK1bsbWIztmOcSpIVwgnW1IJCOwcIRXNKFvlbRvkWOAm4GPq+rLrWzuF1h1kfrWjqvILIKmU6S1BUTko8DFwOdCHcgWoaofAicA42jB/01VN4Y/98n72ISuw5x2emGWrOMA7qRT84TclEOBDzCvyqVYFfaS/TBEZCzmoXmWqj5eoDYHYutS56rqlEK0WWhCSMRGoGeoddimEJEdse/4QlXNuVRXljYHYGEiv1XV3+Z57H+B61T1qhb1HckYzIp9FngfOy/me33T2qXSp6CcIhESANxGsgJ7N2wd56QSi+MwLFH3RYUSR7C1LRE5D7hNRPYPa10VhapuCsbjzlR4XtV0wlrfLcBfCiWOAKr6noicADwtIkszxUlmIWuygGaYgYWV3IqlANwIdJZIJgPnhrqnTg3hU6y1SyyOXbBg9Y6YB+ENpRqAiPQFJmNxjvc1uWN970HU976R+t7NJaPeDlV9DLuI39YC541SMqTcA2gB38LiNH+Yz0GDpk0fNmja9B8Pmjb9pKb2Cd6tHwOubS7jTqZDgbH5jKfRwXZjeD52HsTnRRfsPLmtpe06bZdKvmg4RSJMq8bimEoX4BSJZFDRxyDSEbgb+KeqXptl9+HYhes66nvnu16XwALrL8l/lCWjTQmkiBwIfB9LJbc52/6Dpk3vN2ja9K8Mmjb9WeANIAKOau6YkPzhXOCePHK3zsQSLLSIcF6chN0splKy88KpLFwga5Oh2PRRJjaG94vNr7Fg8O9l3bN+5ZNYTs5zgIvy6URVt4Tjvi0ih+Y/zJLQZnKCikhv4E7gK2k5cRsxaNr0roOmTf/UoGnT78fWta/FnGAmAEOWHjPm0mx9hYw7E4H7c6wCkncsZBqVcF44FYSvQdYmb2KJvzPRObxfNETkC8BxwEF5eD5OxILKr6a+97+oX/lqrv2p6iIRuQj4S1iP/CDvQReXNmFBBm/bPwAPq+o96e8Pmja9HeYF+jngTEwQ38Fuhm4H/r30mDH5rm//Biu19kcR+UxT6QYDr2BltVpKWc8Lp/JwL9YaRSK5B1vn6ZTy8gbMg/WMovWbTCz+UdU8S2fV9+6PORJtAMZSv3JlHv12BN4FLlfVy/Pqt0iIyH1YFhmAG1Q1L+u41IT/3avA7qq6TSwGTZu+FzYFfg6wC7AGmz6/HXh86TFjWpVsIhRefga4RVWbzPEasvk8DowMMwf592XnRfryQ9HPC6cy8SnW2uXLwH9IVozYAEzC1n2KQrBAHge+n7c4AtSvXA58GqgDbsx1PVJEdgKmYonCb8y73+KRGrO3Y9lGkTszsfXDp0XkyJTXPwZ8G7t5ORsYuPSYMecvPWbMlNaKI2wrlXUmcHWo7tIUcTjG4FZ0dy7mOLYBWIUlEHicIp4XTuXiU6y1y27A9Zhw7Ai8Wex4L1VVEXkY+KaIPKeqs/JupH7lM9T3/n9YMoCvAr9rbvfgUPJ3TBh/qqoN+Y+8aEwDdgcEc16paMJ0eL2IPA/cLSI/VtXrse/21qXHjFlWjH5FpBfwM+C/QJNVZVR1awibGUMLsxSFUI4zgkPOUMyjdamHeNQmLpA1SKjzOBJYrAl9g9JenM/Gkoo/KSLfw6bN8p3nvwpbj/wl9b1foH5lxrR0InIGVl3iwmbDSMrHVMwi7kiFFj/OhKo+JCJHAA8Ei+6S1mTRaY6QROJO7Lv6SLAms7E/cH9r+g03i0slkjXAoRJJP03kloTdqR58irU22Q0LfXit1B2rcSNwNPBd4E8ikld8I/UrGzBnjHeAu6jvvUP6LiLyNeBq4MQKFUewdbUOwCbg7TKPJS9ClY1DMTG6s9B1OMX4BpZh6Yeq+uXmxFFEOorI7VjCiwtF5B8FGspcrJj1qAK157QhXCBrk70xR4qyWS2q+hpwILAeeEVE8suAUr9yBWZ9DQZujtcjw4U1AfwvcKSqttb1v2io6iLs83ehjQkkbEsyfiI2RTxJRHoUol0R6YdZgJ8FDlHVv+YyHEywt4TxFCSXsCZ0IzAP2FMi6ZRtf6e6cIGsMSSSPpiozCplSrlMqOo6Vb0Qy8bykIj8b16Ju+tXvoAlAFgBdAzH/h9wBiaObcEt/3nMk7jNCSRsSxL+aexm68G8ZwPSCM4/r2KW2xGqOj/HcWwBHsYs8s0U1hnrtdCu14ysMVwga49RQAMwu9wDiQkWwqHA54F7Qwq6XPkN9Su/KNGqzcBlmEVzTCXmXm2ChzHrp80mxA7rj18CXgcmt8SSFJH2IvJD4G/Axar6XVXdlGczD2DxigsJ9SELgSZ0OVY8fO9Ctem0DVwga4hQDHk4VqEgF2eHkqGq87BalPOBV4MTSHbqV8ZW8KXAqVgl+rbkTPEE8ExL4/YqheAd/BXM0/S+fNYkQxjOI1jyiLGqOrmFw3gaK3N2TQscv7LxOtBHItm5wO06FYwLZG2xBzadl38MYglQ1U2q+m0sfONuEflBqFbfLCFLzhcxcVxe7HEWElWdoapHZt+z8gkieSEWinF7jv+7k7AMOE8C41S1xVPNqroaK7hcDKes+VjMsDvr1BAukLXF3sCKSq9vp6r/BA7ACug+LNJ0kmgROQULXj9RVZeUaIhOE4Tp1s9isbVXNLVf8Dq9HKsec7aqRoUIFVHVeaq6obXtbNduQrcAc4A6iaRbodt3KhOPg6wRJJIBWHmip8s9llxQ1cUiMg5LUv6KiHxBVR9J3UdERmPlrE5T1YoPtG+KEJfaFbPu22FrkpuBDZrIXi2j0lDVjSLyCeA5EZkTkglsI1TnuBMrSry/qhYlwUAReB3YF9iL1idGd9oAnou1RpBIjsFStN3e1i66InIM8Ccst+ePVHVzcOR5Efixqv65rAPMAYlEgAHY/2AwMAjoD/TBYlKbIk4F+D6WS/ZtzGN0cbBqKhYR2RO7ITtTVZ8Kr52JVfa4HPhlEdYKi4pEcjJ2o/kXTVRUVianCLhA1gASSReswsIsTegz5R5PSxCRHbFK7ztgSbGvAWap6nfKOrBmkEh6YxbHKGAEzQthvmzGqku8DszUhC4uYNsFI6wx/hE4AittdgI2pZox+1GlI5EMwTylH9VEmwgjclqBT7HWBiOwqbuKdM7JBVVdJiJxUuz5wAtYbcGKQiLpiiVAOBgYhgWtF4OOmEfycOB0ieQ9zKJ+ThOVM2UZ0tLdgP3P7sKmVHOuwlKBLMKSbIzCy19VPW5BVjlhau9sYI0m9IFyj6cQiMgewLJKutCGavTHAQfRuIRYqVFgFjAFeK3cySDAYhyxpN8z2tqUaiYkkjHY//kuTWiTydOdto9bkNXPrkBPzOKqCirJIUci2QWLv/wIxbMW80Ew62YUsFgimQS8Wk6hDN6pBQvcrwDmYF7Wo4BnyzwWp4h4mEf1MwpYBywo8ziqColkB4nki1iavDFUhjimswtW93OCRDKs3IOpFkKSjfnA8JB8w6lS/J9bxUgkPbHKHa+4x11hCCEZx2FFggtawaKI1AHfk0ieB/6mCV1T5vFUA69jiTf2oILSNjqFxS3I6mYkyTUpp5WEdcYJWDL0tiKOqRwC1Esk+5V7IG2dkGxjBZ6ftapxgaxSJJL2WEDzQq+G3nokkiOAHwBDyj2WVtITuFgi+ZxE0rHcg2njvAb0k0gGlnsgTnFwL9YqJFg6R2LTq3doouX5LWudsMZ0DpZIvdp4C7hWE7qi3ANpi4QbjM8Bq4AlWBGAik7j6OSHC2QVIZF0B24DTgG2YuEGDwDnuhWZP+H7/CoWzxijWMWK2dhFcR32PffH1qP2obzTr/H4ZmEltOLx7Yh9jvTxrQKu0YQuKO0w2z7h9zEJOAz7njsDk/HzrWpwgawiJJJ7MHHskvLyBmCyJvSM8oyqbSKR7AB8E0sJB1ap/gngseYsLomkM2Ztngz0KvY4U9iCVcR4NIfxHYb9TuLxbQSu04S22UQS5cDPt+rHBbJKCNOq82l8ssZsAIb69E9uSCT9gO9gOTfBLLLbNKHv5dFGF8yZ56jCj3A75gO3aCL3ItFhfJ8APoqFqGwBrteE/rs4Q6wu/HyrDdxJp3oYilkCmdgY3neyIJH0wdLZxeI4GbgqH3EE0IRu0IT+GSvnVMzk8FOAK/IRR9g2vjuA32MX9A7AlyUSr3eYG36+1QAukNXDmzS99tUZzxuZlZBH9RvYemIDcLMm9P7WZKHRhL4E/ApYX5hRNuJvmtC7WhPjqgmdgVXW+BATyYslkrrCDK96EJFeIvJnEdktvOTnWw3gAlklaEKXYNZOerHYeE3Ep3uaISQA+DKwMyaOf9CEPl+ItjWh84CradriaAl/04Q+VoiGNKHvYMWNP8Au7l+VSPoWou1qQEQEuBJbVx4Ifr7VCi6Q1cW5wOPYlN4q7GSdFF53mudMkokVbtGEvlrIxkNppD9g4ttaHiuUOMZoQpdjlu5azHnnKx4nuY3TMXFcReNE9OeSFMn1wCb8fKsq3EmnypBIRmP16l4E5vidbHZCZpmLw9N/aEInFbGvE4FPtqKJWcDVxUo+LpHsAXwLm259ShN6ezH6aSuEKdVpJHPtXqCq0xrtE8kg4AvAIk3oX0o7QqeYuAVZffQE3teEPuHimJ3glBPf8U/HLIJi8gjwnxYeuwr4YzErc2hC3wD+Gp4e6Wnp+AxmUffErMft1h3DefYy5gnsVBEukNVHL2B1uQfRhjgX6Ibl1by12GWhQvu3YVOZ+fInTWjR/7ea0CeBl8LTz0okPYrdZwXzO+y3sQpYDjTlLbwK6BXqrzpVggtk9dETO1mdLEgkB2HJphXzWF1Xin41oSuBe/I87KUSxyj+GViJ/Z4+VcJ+K41e2HXyy6o6RrXJtenVYb9uJRuZU3RcIKsPF8gcCIHyZ4anT2lC55Z4CM9igea5sBH4WxHHsh3hZuGO8PSQGq4n+RCgqlmdouJzrmeRx+OUEBfIHJBAuceRDYmkG+Zc4VOs2TkR6A2sAe4tdedhqjVX0XtEE/phMceTieDJG6+XnlVr04cishPQHfhKDrvH51wp0wu2mLZwPasEvGByblwOXCIi/wEWYkHAC1IebwIfaPldguO7VxfIZgiFpI8LTx8o1dRqOprQ+RLJDOAjzey2Bni0REPKxF3AKKzo8n7AK2UcS6l5BGhQ1Sk57BufcxVhQYpIN+x/lvoYipVr2wsb7+CyDK4N4QKZGwdi03HzsB/YUOwHdyTJH56IyAIai+Y2MVXVD0owzvju1adYm+cEzCNxOfBUmcfyT5oXyEc1oYVMMJAXmtB3JZLnsATs4yWSV4vtyFQJBOuxC5Y8Iiua0AaJZA0lsiBFpCuNr0XxIxbB3tj1Z0HK45Xw2kJggYh0UdX0RAdOCi6QubEbMFNV52KhANshIjuw/Q/16LCtExFle/F8VlVfKOA43YLMQkgnFycQn6wJ3VrO8WhCF0kkr5G5Mv0GLPFDuZkMHArsgo2zpWEqbYlHsLXHqXkcs5oCW5AhDvMUTPTqSApiH6yeZ+ps1v0pfy9VbToFoYgsxv6fbxRyvNWGC2QWwlz9YO7DjHEAACAASURBVGBxc/sFC/EDYDsvt9BGqoAOBQ7C0le1L+BwewHryn3Rr3AOxyyDlUAhb05aw2NkFsinNVH+O3xN6HKJ5GVsJmUcVS6QIrIz0BW4MM9DVwG7Fng4P8Fu6P6IZemJBXFJcwKYAy6QOeBOOtnpC2xQbfk6lRorVPUVVf27ql4F/BKYUbBRGu7Bmp3YenxSE1oRgd2hDmN6fJ1SGdZjTOzFOVIi6V/WkRSfR7G1x2lZ92zMaqCbRFJIw2MJcJOq/lxVb1fVZ1T17SHf/2dr230HyzvsNIMLZHYGYT/SQrMLNkVSSHri06tNEkIVBmL5UJ8u83DSSV8Lna0JXVaWkWRAE7oAszoEK7hclQTrsRM5rj2mEd+cFjKxwlukWaV1EyYNB2bUTZh0UCvaXQrs1JqB1QIukNkZSNPZM1rDYODtQjUmkbTHTsyiWZAicoGIbBGRqSLyexH5loicIiLDRAp611ws4gvK7HKETWTheSB1arzSBBzgubA9sKyjyEKIyhokIh8VkYtE5EoReUBElojIfVkOfwyb9MnXeoTihHq8zfaW3ruYE86tdRMmdW1hu0uBAa0ZWC3gApmdAUAx7uQHYT/SQhHftRbTgjwB+DEwEXgd2B34JjAVWC0ir4vIvSJyuYh8UUQOF5H+lRBzFWL4xoSnL5ZzLJkIKeRmhqfraMIZrMy8hE39DpBIdin3YESku4iMEZFPi8iPQ73GF7HaljOBy4BDMG/lm4CzgOOb+j2KyGDMeryohUMqRrKAJaRZegsmjl8JXICFa/y0he0uwwUyK23hrr/c9MNOsEIzkGS+y0IQn5TFXIMcCvxaVZ/DvPy2EdzO9wRGAMMxD94vh79VROYAc4C5YTsHeKOEbua7Yp5/CpQyZVs+PIuJ+IuVsj6aiib0Q4lkIeZoNposjmuFQETaYx6cw0n+tkaER38s9Cr+PT2K5U6do6orMrQlWELxHbD8qunEa4+Pt2SsmtD1EskWCmtBvkuoQZnKgonjH62bMOk64Nt1Eybdt2Di+HxnHJZj1zanGVwgs9OXzCdTa9mRwlqm8UlZTAtyCBaesh2quh4TnkbiEy5KO5K8qA3HEoSPwMJf3gWeUNVi19AbFbZvakLXFLmvljITuyC2ZHqvVPwHE8hRwIPF6kRELgAuxaYXl5MUwTnAA2G7SDV3j21VVRFZiP2OG53TwXrsSP6eq+kUOtRjGXYjkIlLsIxQt9RNmPSRBRPH55MAfwV2bXOawadYs9MHC98oNP2A9wvYXi9sDasoWWFEpDN2553XtHDw4H1PVZ9S1RtV9Xuqepqq7oVNC38Rm/oqNnuG7ZwS9NUiNKENwE9CtfpKZXbYDi2wt2Y6R2J5UPur6q6qepyqflVVf6OqD6nqm/mIYwpvYQ5y6cRrj4+3YswQqnq0so1txN7zITNOIxZMHL8GOB8Yhi175MOH2LXNaQYXyOz0ojjTljtQWOHtCawuYpaTQcC7rYy9aoSqbsFEvRRrgruHbUXHfVXi1GoaC7D/WUcyC02h+C+wWlXXAkyZOqxQF/MlpDm9iMgu2Gxaa61HKEKyAOw6sUOmNxZMHP8EcDXwtboJk47No81VmKOP0wwukNkpVuhEbyxYvVAUO8SjWN68u9HEtG2hCHF78R14UfuqdjShm0l6X+9WxK4Wxe1PmTrsaGDRlKnDvj5l6rDWJtZ4l+2dU2Lr8YlWtg0mPB1DtZhCsZLmxexS7Ibi5roJk3K1Xosh5FWHC2R2umMJowtNoQWtWJZuTLGclXbGgpaLSWwxrCxFweEaIHbOKWay69TwhoWYA9NvgOemTB02psmjsrOclDW9YD22B77UijZTKUaox+rm2lswcfw64DzMor8qxzbXYNc2pxlcILPTDVhfhHYLJrwSSWfMPb2YF/9CTwnHDKA4lmkqsRdgIcNqapn4e9zOu7KAvEew9MYdO+9N4GTgHMzB5qUpU4ddMWXqsJZc4D+g8drbFMx6fLKV440pRlWPtWQRswUTxz+Hpa78Ut2ESSfn0OZmzIeuYwHGV7W4QGanC5Y0umCEoPp2qrqpQE2WIsSjWBZqP4rjJZzeBxTHAq5F4u+xmGEC75PiZTnu2Hk67th5dwAjgZuB7wL/mTJ1WC5ikMo2JxoR2RW7Bl5QkBEn24fCWpDrsNyw2Uhg8ck31k2YlHHNMiaU5tuAXd+cJnCBzE4noFBCFtMZqxJfKIZhTigtzaqRC92xO9lC04vCrsVmIrYYKi17Tlsl/h6L6eSRcd1t3LHzVow7dt6FWE7dDcDkKVOH3Tll6rBBObabao3Fa48FK3kWnKw6AYdIJLmOKRsbsWtGsyyYOH4DFkI1EHPcycYmbKxOE7hAZqcjNh1RSAoiuhJJd4nkHuAJ4H+BVySSeySSYqwtFNySDhRLeNP7AM9TWyjipYHORQz1WA90FpGM16hxx857CkuqkAA+AcyaMnXYRVOmDst2TVsPdA1lpNphYUY5E9LY7ZjxveT5eBVwBfBmgc7HnIVswcTxL2MZhD5fN2HSaVl234xd35wm8EQB2WlP4xyZ23HNxVMFu9vtj0079Uv7+62vXnfs9fm0mSO3YbXiUu8uTwmvn1GA9lPp9P/bO+84ucrq/78/CZDQi1QNkNADIh1BCUIIRQhNSpQuAoIgorFERScjIlG/wQYK/gARRAyKFEPoEY30XiM9QJDeWwIk5/fHeSY72czstDs7uzPn/XrNa3dn7n3uMztz7+ee85xCDTcKG/5xw4G4qBY/BhX9fv/9h97/Ftlb06UouJGasZbciRTn2i5KE248UlL/+/j3o+TntsPIx2cDP7p+6pqTgDOAM4FDrp+65lE7jHz8oTJDF0Th2nSYWivQHAWcIelB4I/AxWb2RHqtcD4uQpegZXE+zqG2tng/BnYHfj903BU3zpiwW7mlhVrH7ThCICsjvPvDApx+9NTj8Nqky1H+izYX7+NWLJADyo1Z9aTyWgU/+bqvIQwGdlVeK1vOsgxKGUAZgdzwjxuuhbdmKhbCSt+trfEC3VndLPRE4S65r+cY9heKvwfNtECquoDvMPLxh6+fuuZI4DA8UOWe66euecwOIx8/u8Tmc/Hv5prAwNTIvFbm4v0788Apkp5kV3Zny6adj3Opwds3Y8Ju7w8dd8WheCnL04ExZTY1/PoWlCEEsjEeB/6OBxS8ggcvdP/9jWPPGJlZcn0Rw3DLq9Qi++z0em9Fbb4FXI27YLs/Zpd5/r8lR2oOhYtLMz6HTqRYVPrEBXaHkY8b8Ifrp645GRfJnuocG/6dfZ7a82J3TD/fT+O8CFzKGqxC885HMf//vCIzJux239BxV3wXeH/ouCs0Y8JuzSog0taEQFZmLmXuYo89Y+SV1FePsqY7wjI8SfmF+0Hp9Sz5kDLfl/sPvf8F6o8E7I11kIKFGmvu2VB8PjTzpqPm9f8dRj7+Ep4TWI6B+Hf5UmAbYNdaqkNJ2gn4DXAh8FfgITOz5NFp1vk4gBoFEmDGhN0q5UQ27Mlqd+KCUZlm+OnLik21pHqdU1gwcGYWMCVj9yo0L+Kt3F13lhQushUjAQtIGiRpoqTHJf1X0t2S9uph+7MkjWhkkpIOk7ROldvuJWnLor83l3RBI8evgeLvQdYR3sC8Lh4LNWH8QWnMY9LfX6tlZzO7xszWNbPxZvZgSpdo9vm4ENkHCkLvLG/0a0IgK9MMCycrsTkEPyln44EMs/D1zmZ0xniP5qSRvE22HdhLUQgqqWX+v8Urk2yQCqsfDJwmadvuG0oaaGZHZJAucBje7aQa9qKrATRmdoeZHdjg8aul8H80mhf4tDjwTkGAMmRR4L3UZm0a8JVykbJ1UDgfP8C/11mdj81INSuM2wzhbRtCICtTVQ5SPWM22kjYcvaO5WwfYCO8DNf2lrN9LWfNSJtolpD1RleBQlpCVcnbklbHAxuOKfSrNLMHgJOBXLL0rpJ0vqQ7gQ0l3SBpdNp/qWRR3ibpPkm/ShYRabufS/qPpCckTUjPfxHYHPi1pHskjZK0oaRpku5KzahPSNvuDOwBjEvbHiJpO0l3FL2HQyTdn45/iaQV0/OHSbpG0iRJD0q6Uao5X6/wf3w3dSBpBsvQnPzYJej6PhSsyBOyGDiddwfitVGPBoZldD4OojkpVr0RQd6vCYGsTObVJlKbnvczHPdx4Ama5O5KNKv6f280bi2UyKu2/92GeDPn7hV+bsFvRsDXr8ab2WZmdk+37U7Fe1xuiefqrcj8+Xar4YnumwBHSFrbzP6AB5Ycb2Ybm9l1eOeMUWa2KW4tHiVpuJldDVwOTEjbnld8cEkfx9sf7WRmn8B7OP6maJMtgG+a2QZ45ZWvVvl/KVCo0tKM0oMFlqc5lY/mFaYws9l4DvExGVqRS+Lnyo0ZLnMsTsaWero5b5bwtg0hkJV5h65OEFmSmUWWqne8S3Or879KmZY7DfIC3kqrmRQaU5dM8C5BNZb9f8zs8TKv7QF8S9I9wF3AZszvOv2rmc01szeA6XjKQSkWA86WdD9wI168e6My2xazPTDFbF5fyTOBUUWv32hmz6Tfb+nh+OUo/B+z7GfanWZ1j1mO+YX92PQzEyuSLus6y7KMzWiYMBh4v86emh1DCGRl3qE5rsUeK/TXOV4zBfJlqheYWniW5naFAA/FB1hZ+arc2vcDa0nqbnFuBdyXfu/pgiVgr2TdbWxm65jZt4peL75rn0P5gK2f4KkBm5jZRsBtVOd1KJUWUPx3tccvR6HLRjPTiIbQ1VYrS1ag64apYEX+k+ysyMI52Nc79RS7moMyhEBWJtMO4UW8TrYuy2bNs8DzNMfSewoY2oRxiym0ZxpMUaujcpjZDDyE/3eS9/VLbsvv48nhlbgcXx8srDsuL2lYFft1d2MvAzxjZh+m44/oYdtirgd2LVpbPBKvO5oVhUbJzRCwAqvTnN6dK7OgZVpwMX8jg/GXAmalvplZ0Yz12KWI0osVCYGsTKVmpfXyGtWviVXDW8Diyme2ltKdl4BlJDUcfStpgKShKadsV9wF2TQsZ2/T5Q4cWuVux+B9Kh+S9F/gT8DXqmyqewJumd2b3KNXUZ2V/HvgBymlZBReMuxISbcDJwLFLZnOBw4oBOkUD2JmDwLfBa6VdB/ulq0pnaEcqa5ooeHwjCzGLMNawM6S9pa0vqSsAuUW6D9aZEV+OQMrsrAGmQlprXAZsu940xtNAvo9USigMq+TrZAVyDo45U3ctbYETWhLZWZzJD2HWw9PVNoeQNKy+NrbuulR+H0t/Abh4fQoVworSx7H/9/rALdX2jhFr349Pbq/di5wbrfntiv6/S26IiS777tdub/NbDIwudsuHy8zzu14ubNiNi96/Ty8BmiPcy/1Xiqwdvr5Dl2u62bwM7z/4+H4d2Y1Sc/S9Z15pOj3/9WQDrIq8HSJ57+KBzN9A6/EUy9Lku3/ZWk8LSXrdIxm9XdtK0IgK/MKfkHPmpfouhPPguJO5s3qCzkDL5k1TyCTRbkGXSJYLISLMv/F7O+Fv82st9c/HsEjQdfr5eO2G8PTz4ctl3mO4jzM7C48wAmA1Ni38D1bB9gU+EL6fQlJjzC/aBa+Z28VjTEAjyBeQCDNbLak63Er8tRaquvMG9+9N0viN2NZMd+aaYYsR/P7sPZ7QiAr8wrNCU7JOnqzGY1au/ME8ENJu9Elgqvia3yFi9JtuDvyYeC5JiR618uD6eeKymsly1kzIiQ7gQ3Tz3LdMppCsqAK37H5kLQ089+c7ZV+ri3pjaL93gM+NLN3u4+R+BpuRX4Tt2BrZXHci5Pl2t7KNCcYagWigXhFQiAr8yLNEcjn8I4WWfEuXlexmZGsZ+E1V5/H88ceAR43s2bmX2aC5exV5TUTdxFvSn01dDsa5bUq7qY2uqJ5W05Kl7ktPeaRLMYhdAnncODbPYxTsCKPlPR/dViRhXMvSw/OKvi1ImtWpLku8rYgBLIyzcrTyzS9wXJmyqupqR5mdiOej9dfuRO/YG5JHxPIVCXnz2bW0EUr1Yv9n5ndVnHj2imUtnvMctbnAzySwD2dHtdWudvxuLehHiuyGTmQzUp3WYle9gL0RyKKtTLPAas0WhauBE/j7sksaXaqR3/nNtz6+ajyWr3Vk+nGCWSzJj1fjdasSOtrW6U/myG+fYLkDbkOtyJrvT4uhXtxsiz1uCrwTMWtaqdZlmlbERZkBczs7dTZfBlqjPpKJ9jKeE7XMDzFoPD4ONl3x3iLbAN/2grL2cvK62E8UOczlIjybBRJS+Bl3bZIT51vZj9Nr80ARqe6rvP+BvbE0w/+JmkWHr25P7A+HpW8Ot4/83Aze0PSucAdZnZaGudcvEzdo3gVn1GSjgBO7V6GrgE2xgXgfaqIAu7nfA23Ir8F/LSG/ZYE3s44eEnAzyXtiQfJFR5P4nmiz9S5xPExuqW7BAsSAlkdM/E7ufkEMlmVK+HiV0oEV8OtuqfwL/QM4G7gErq+6FnyJjBIeQ2ynEUR4tL8CxfILZXXJZazrJOlf4B7ZjbEL5g3S7rPzMq6dM3sZElHAvsWiSd4YYCNzewFSeeksb/ZwzhXS7qcIvHMkEKpulstZ83q4NEnMLP3JV2L18n9eQ1rkZnmQCbGAr9g/mvLCLxDyOq4d+sFFhTPwu8zy6SINMsybStCIKvjWWCspIeY/4u6Gu5OKdzNPQncC1xG+oL2EDHXDAoX+yWJKv3luAeP3lse2AFvnJslo/CCAga8KenC9Fw9a56TzeZF257N/AXHew3ltTZer9XwKj2dwAnUbkUuRcaNylOt1KcoU1Uopb8MYf4b8+2Lfl8p5S8/RZd4/g/3bIWLtQIhkNVxNp5ztQIeBv4P/Mv2VAvy+XqiWCAjhLsElrO5yutqvC3R9srrulRpJyt6qoP6IfOv+9fSzaV43EbGqYc90s97U2PgtidZkddQpRWpvBbGP4deLd+WrMMnKSPMSUBXpUswhwHbAROjUHllQiCrwMwmAZNaPY8q6I1cyHbgJmAXPGVhN7L9bAuuuZvw9cPP0+UWfRxfm7xP0g64e75Aqdqqu0lawcxewpsp/7PbOEhaBbcY/tPDOHWjvD6Op0gYC1b5aXe+jluR3wFOqbBtM1I8GiYJ6BNUWf0qmJ+IYm0jLGfv467VZuZC9ntSe7DL0p/bKa9VMhz+JNzaux+4GQ/SuSq9diLuqr8Fr0FbXNHl18AfUm3V9dNz1wPnSHoQr3xyUnr+98AQSfem/W4tGqdsjdZaUV4L4cFCALdZzjpqzSoFv1wNHF4oPN8DzUjxCFpMWJDtR9ZttNqV23DLaxhwoPKamEX0YXK5H1bmtdvxyNQCY4teOwsvxADMC9J5wcwOLjHOK2nu5Y7RvUZrveyEW7mz8cCyTuTreL7gOEl/AZ4oUx2qcM5Fh4w2IizI9uNNwoKsSBLDC/C8tbXxtI8gkazq3dKfky1nnVrYutCm7DjcNT+qzHZLAu9H9Hh7EQLZfrwJLFllY+COJrkMCxVW9lFezaiYVBdmNt7MyqZ0NJPkWv0S7mF6imx7SfY3dsPXqt/FI9bLnVfNSPEIWkwIZPvxFt7KZmRfuuD3YS7H81wXAY5M0Yidzn545OMHwDmWq72zRRtxBl7ovFDUY4Gk/GRtb04sWbUd6jvNFoJGSc1s/4q7gd7DT+opwCGWsyzLX7UV6Ubie8AgPBjl7BZPqWUor62AL6Y/z7ec/aen7TuBFDR1JS6A+5rZzTDvfDsPD7gy3OC4gjjf2oawINuL8/DgjYXxoIHB+MmbeUm1dsJy9jxd/6MtldfoVs6nVaSCAIWgoBtDHB0zewhP81iY+S3IgjgOxnufDiLOt7YiLMg2Ibl5nqB00vgsYFgSgqAMymsPugJT/mQ5m9bK+fQmymsIHlW7GPAY8IuUDhMAKc3jUODvZvZ6nG+dQViQ7cMwypeXm01XNF5QBsvZ5cAt6c8Dk7ux7UkX+xNwcXwe+G2I4/yY2RwzO8fMXk9PxfnWAYRAtg9P4i6eUgwi4xqRbcwf8XqtAg5TXiNaPJ+mkpogj8WjMF8BfhnrZ1UR51sHEALZJqQamVNw904xs4Ap4e6pjhSx+f/wovMCDmrXNUnlNRwvg1eo3Tuxg/MdayLOt84gBLK9OISuk/YdPEx/Sno+qJLkXjyDLnfr7srrS+2UAqK8tgeOx9fQ/gf83HL2Smtn1e84BO/D+QHwBn7eXUGcb21DBOm0ISltYXO87+E/LGcPt3hK/ZJUbGF3ugJ3ngV+35+tA+U1GO9ksmV6ajpwZrv3eGwGymsJvMvPM7hAPtmfvxvBgoRAtjHKaz/gQ8tZp9bRzATltTluFQzCw/wvBv6Vcef4ppPSOA7De2GCV8i5uMMLAdSN8toC2Bi4MOOWaUEfIQSyjVFeGwCfBi6xnL3U6vn0Z5JVfiTenBbgUeCC/tAfUXktBuwFbIuvq74LnGc5u7ulE+vHKK8BuCX+ouXs6lbPJ2gOsQbZ3jyKr49k1d2hY0mus1OAq+gqcP5D5TUmudr6HMproPLaDm+T9RlcHB8A8iGODTMMLw7wYKsnEjSPsCDbHOW1DbAubu10j7gL6iClRhxIV67bbGAqcL3lrOXtjlKx8a2Az9LlTn0D+Kvl7PaWTayNSEUlFgMm9TdXe1A9IZBtjvJaDtgXuMVydl+r59MupACeLYE98W4P4Nb6bfj65FMtmNMywDa4K3Xp9PRsvPHyVdGKKRvinOocQiA7gHa625U0AG/FdLeZ3dHy+bi19ilgZ7qsNfCI19uBuyxnLzTx+EsAnwC2wKOWC8sms4B/A9e02qqV9BF8/fZMs/6fZxlemc4hBLIDUF5rAjsAV6YeiP0SSSsB5wOb4OuAG5n1jbD6FLSxEbAdfvEs7hv4IvBffE14BvBSvTcqymtJYHVgLVwQh3Y71gu4MN7YF1I30g3NP4CtcTfvAYVuGP0R5bUIcBDwhOXshhZPJ2gy0b+sM3gSb3+1Pp6z1e+QtCNeBu5svGPCD4BJkkaZ2QctnRzzKvDcDdytvJbH3a+b4VGvK6bHtmnzWcrreeAl4FW80e57eArJHNwKXBhP4l8SWAZYAVgZ79LSndfTsW+3nD3ejPfXAD/A57wS/rldKulU4Odm/TK9ZG38uhnBOR1AWJAdQsrZ2gTP2Wp5IEm1SFoI+BHeSeFgM5uanh+ANzt+2sy+0sIp9khar9oAWAdYk671ykZ4F+8k8Qie6P9MX3SdS9oL+A2wpZmnw0haDfgzXunpELPmuZ+bQeQWdxZhQXYO0/Gk5uF4IEmfp9vFdBMze7HwmpnNlXQgcJOk483s162aZ09Yzl4FpqVHocnuENyiWgG3DpfEUwYWAQbi7uMPcavybdw1+TLuqv2f5ezl3n0XtSNpU7ym7a4FcQQws6clbQfkgbskHWJm17domjWRup4sC/yr1XMJeoewIDsI5bUT7qa7wHI2p9Xz6YlkfZwJ9OiOkzQM+A9wnFnc1fcF0mcyDTjezP7ew3ajcLf5H4DxZn27xZbyGgV8DD9/+vRcg2yIQgGdxUP4ulbmverkHClpuQbHGSzpN8AvgD3N7Kc9rVWZ2ZN4vdQzJW3fyLGDxkmBVFcDE3oSRwAzuw7YFI/AvSF5DPokqRrRUODhEMfOIQSys3gWDwhZvwljbw78BBhV7wCS1gFuBlbBXaq3VNgFADO7C9gfD9rZut7jB42R0jmuBS4ws9Oq2SetQX4Wj3S9XdIeTZxiIxRSaKa3eiJB7xEC2UGkQI6HgJWVVxbBIsUcga+h7V3PzpIOAm7E1632K+rcXpbp6w0fMH294ROmrzd8qJndgBcUvyxEsveRtDxe/HwKHlRVNWY218x+in93fi3pV5LKNSPudVIKz3BgpuXsjVbPJ+g9QiA7j4fxVILMrMhkOeyCpy18StKiNey7hKQ/ACcCo8zst1b9wvjRwHdIVquZXUWXSIa7tZeQtApwA16n9rs1fH7zYWY34ZHWqwI3S1o7s0k2xmrA4vjNZdBBhEB2GKnc2GPA2inpOQv2B5bA890WAz5ZzU6SPoE3nBWwuZndW+0Bp683fBjwM9yld3bh+SSSBXdrXdZsUD2S1sKDpC4EvlevOBZIlXb2wT/Tm1KkcqvZAI8mfrrVEwl6lxDIzuQhPMUnqzv0p/DQ97fw8P07e9o4BfQcg9cIPdnMDjOrvp/e9PWGD8AvoHOBI4b/d/p8F+Xkbt0FOE3S8bW8kaB6kit7GvBTMzu5UXEsYM7pwI7ADyWdLWnxLMaulVTf9mPA9Oib2XmEQHYgqTfkS2TUBsvMpuDlt+biARplCxFIWgb4K3AU8GkzO7+OQx4NbA+MHf7f6SXv6lPgzqeBL0v6raSF6zhOUIZk2V0GfMnMft+MY5jZPXg1ooXxAJ4Nm3GcCgzHv9cPt+DYQYsJgexcHgSWUV4fzWIwM3s3/Tq83DaShJe6ewXY2sweqfU43VyrZ1WY0wy8kPhqwHWSVq71eMH8SFpY0kQ8EGekmU2ZOGb04GYdz8zeNrNDgAnAfZKaEYFdklSIfl3gScvN+34HHURU0ulcnsALSG+jvGbixZezKPy9KXBTD69PA94zq70LQiXXainM7I2UOpAD7pW0W1/oAtIfSdb/VXj92C3M7NWJY0YPAB6bOGb047hFednYSZObUQ/2ZbwQ+4uVNsyCVDXnM3iHlqt645hB3yMEsnMZBByGuyHfBQYprynAIZazdxoYd9NyL5iZJdfcnZJuMrOLahz7y7hr9ahyrtUyx50r6STgK3iUZAhkfSyPB2CtYWavpucG45Vw9gQmAhMnjhn9IEksgTvGTprc0NpdqszzB2Afs+aW2UulAM/DC6vPxa+RWyuvRs+LoB8SpeY6FOV1MX4RKHaPzQKmWM72qWtM6RHgXTPbuMJ2mwDX4C66+6sZO7lW78et052rsR67HfMk38nPCgAAIABJREFU/OK+Sz/tItEnkPRNPMp02+5dVCaOGb0GsAculiPwurLP4UXlLwOmjp00uaamzZIWw/NjzzWzXzX+DiocrwnnRdB/CYHsQJL76AnmvwgUmAUMq8fdKukKYB0zqxgdmyzJk/BODz1aBcm1eh1erefjtViP6Vg7kPpI9rfuEX2N1EVlMnCfmY0rt93EMaOXA3bDxXIXPI/wbdxdeRkwZeykya+W27/oWBcCs4FDs4qSLXu8Jp0XQf8lXKydyTD8olPqQjA7vV7PheAuvK1TRczsAkkbAJekno49WRafow7XKoCkFXGX2aEhjo2T3NWHAndLmmpm15TaLonf+cD5KYhnJC6WewD7AmcAx1Q43Hg8wGr7ZotjolnnRdBPCYHsTJ7E1yBLMSi9Xg93AZ+vYfsTgUnAuZIO7MH1+XdgP+DiWiaTLJDzgT+a2bW17BuUx8xeknQwcIGkTc16tqrGTpo8Cy9BN2XimNHH4J6AHku2STocTx3aqp6Arjpp1nkR9FPCxdqhlFlr+QC4xnI2uq4xpTXwTg7rmVXXTiuVpbsW71E5NktLQdJ38E4f2/X1Vkr9EUl5PMhr52o/7yrH3Q2PVv6MmfVa/mGqLDUND+QqzpuNNcgOJfIgO5dD8Lv6Wfjd/CzgbuBi5VVvXtsz6eeK1e5gZu/hIrYj8N06j7sAkrYCvgEcEOLYNE7ChaTsWmStSBoBnIu3Ouvt5PztcHf8Ncx/XlyBny9BhxEWZIejvFbG11aexLvY7wX8D7gydf+obTzpUbx58dU17rcKfvf+m0ajFVO+3t3A183s0kbGCnpG0sfw0oL7mtl/GhxrC1yMDuxtl7jy+gSwFXCL5ey+4vMiAnM6lxDIYD6U13A8RP8Oy9ldNe/vAnmOmZ1Sx76r4zVdf2Zmv611/zSG8FJ2z5nZV+sZI6gNSaOB0/Eo4R4jU3sYYzPco3GEmf0jy/lVPLaL4e7ADMvFWnXQRbhYg/mwnE0HHgU2V15D6hxmk1p3SP3/9gN+B3y7gSLjxwBrAt+qc/+gRsxsMh5AdU66QakJSZ/ExfGoFojjoni7tLfwm7P6x5IWl3RMSisK2oAQyKAU04DXgJGpskgtzAU2qnZjSQMkHYC3Evo57ub9DHC8pO/VcsGVtBHeTWT/Xox8DJxxwBCgJqtd0nbAP4DDzeyyJsyr/LHzErADHqF6reXs/brGkZaUdBxwD3AysGR2swxaSQhksACWsw/xyNKBwKjUUb1a7qbK71XKg3wIOBMP7HkROM3MnsLdvF8AJqZ0jUpjLYGnjHzdzB6tYb5BBpjZ+8AY4ERJZcsNFiNpL+AiYIyZXdHM+ZVhc+CjwDTL2Su17ixpkKQT8PSm7+D9UKfhhRCCNiDyIIOSWM5eV17/wt1PnwRurnLXu/AWRdWwAd4tAbzKygmFggFm9pykbXHr4gJJh1UoJnAacLOZ/anKY/cakvbHxftOvHfmTLzw9svA6/h7n4Wn2YDfmAzCq88sDXwEv4H4GJ44vwVwUepy0Wcws8clfRVvVr1phbZnX8HzYD9rZj32D20Gyms1fCngv5arvatMYk3g+7h7dhbuPck0VSloLSGQQVksZ08orweADZXXC5azJ6rY7e4aDlHc3+9ZXES6jm/2mqQd8dD76yTtXaosXUpa3wq3CPoi2+PtoaYAq+NCtxKwBrAMLoSD6cq9m4NXbnkHeBNvD/Yi8ADuih4InNN7068eM5skaRTwO0kHdxcLSQPxdmWjgRFm1ozOHz2ivJbEP5NX6LnzTCVexj+f5dPP35rZY43PMOgrhEAGlbgFt14+o7xetZy9XmH7+wAkLZLcbiVJxcNPxIXjQeDBUpV0zOw9SWOAHwO3SdqzuMC5pHWAU4EdzOztGt9bb7EucImZ3Qrc2uhgkhYCVpI0uI+utX4NuB3vFvOHwpOSlgYuABbD+4HWFfHaCMprIO4VEb7uWFeOrKSjgG/jNzOP48sKv8xqnkHfINYggx6xnM3FC4XPwdcjK91UvZR+rlZug2JxNLOcmV1kZg+WnYPZXDP7HvADYGpyWSJpMG51/tDM7qv6TfU+61KiI/3pR09d//Sjp+5R62Cp8MEMYK3Gp5Y9qXn2/sDPJA0HSI2Ob8PnvXMrxDGxNbACcIPl7M1ad04BOQ/j4vhX/LPdDdgtFb0I2ogQyKAilrO3ganAcsA2PW7bZQWWbHnVXRxrmofZBcBOwARJvwR+hd+9n1HLOL1JCh5alq4qQ8WMB84+/eipi9Qx9MN0rd/2OdINz3fx9cgv4SkUp5jZcd3bZPUWymstYH3gXsvZjJr396Ciu3Drc1cz+645z5nZs9nONugLhEAGVWE5m4kHmayjvNarYpcFIhkl/Yg6xXHePMzuxoOA1sajXI/o40ER6wCPlSnEfh6+frVLHeM+TJWdU1rI2cB0vJHyjmZ2bqsmoryWBbbFu3HcXtO+0iKSbgP+D3eRr2dWd2BP0I8IgQxq4S48AvPTymv5CtvOJ5DJcvwBDYhjATN7DRhtZkuZVVwTbTUl3auJq3GXdD3RqI/Qhy1IgGRdjQGWNbN7WjUP5bUwXuv3A+C6tGxQ3b7Sp/E18mXxur4HRcPtziEEMqiaVJt1KvAesKPyKtca6E08QhNozK1adi5922osZh1czBbg2DNGfgD8Gdj99KOnLlfjuH3axVpMH/istsXTZa63nL1bzQ6SBkr6G/BHvDbx+mZ2WxPnGPRBQiCDmrCczcKDdhYHtkvVSLpzJ75O0xRx7Gf0ZEGCu1kXwYNaaqHfCGQrUV4b4PmKt1vO/lfVPh5QNB2vCHW8mX2mVeumQWsJgQxqxnL2Ip7+sTqly8rdBSGOiUoCeTfuwqvVzfoSXpu9kqu7Y1FeK+JRq08D91bc3jkVuBwwYGMzm9LcWQZ9mRDIoC4sZw8ATwBbKK+Pdnv5bjzitaPFMdWRLetiBTj2jJGGW5Fbn3701LWrHTu5Lfv8OmSrSD1NR+HFFv5ZqXWbpCH4jczuwMlmtq6ZvdP8mQZ9mSgUEDTCv3Ah3EF53QisjIvmg+n514ADUjFyw3tO3oUL6N3AUz0VE2gDVgHeS0FFPXEBMAE4CKjlZqLgZr2xvum1H8prFbyP4zBgUeBSy/VYohBJ3wC+gpeK28qs9rqsQXsS/SCDhlBeH8OLM2+IB+8MAqYwhWO4jdXxepeb4qkZy1QYzvBKPAURvRd4wczm9DgHaal0jFv7UrK2pO1xC3pEpW1PP3rqNXjqyprHnjGyqihJSScCS5jZuMZm2v9JXWfOA3bFO8IMAm4A9rZcaUtQ0rL4UsFA4Ox6epgG7U1YkEGj/Br4OB5oUkh435Vd+Z3davtQJucsdehYHhfWYhHdKD2+WLRt8a7v4gJaeEwHDgR+CLwr6SbgEuC6FlZrKbAOPa8/FnMecD7wabwjRDU8DBxQx7zakYI4Di56bkR6fp/uGyevRh6/KdshdZAJgvkICzKom+TOeoL5L0oFZgHDLGfP1z2+tDBe2HtjXEA3xUWne+TsALwH35t4GbH3ge+Z2f+r99hZkAI+njezn1Xa9vSjpy6Od/i48NgzRh5Z5fifAC40sw0am2n/ppbvoaRF8b6NA4FrgGP7QBpK0EeJIJ0OQNJHJH1Dqrn5cSWG4V0nSjE7vV43ZvaBmc0ws0vN7IdmNtrM1jGztQsP4BO4K3Yg3g3jQtySOKuRY2dEpQjWeRx7xsh3gL8Be59+9NSFK22feBRYIxUv72TWwN2qpZj3PUydYe7Db7D2MbOv1COOkg6WtEm9kw36D51+YrU9kjbDL7wrAptJOijDO+Yn8bWeUiyGu0ObSur2cRZuDfy1jwVYVC2QiRzw7VRAoCLpvb+Ip9v0etuovkBae1yb8t/DQbzC05KuxYXyv8Celda1yx5POgQ4F3hd0jfNrE+2HQuyIVysbYykI4BTgGPwXoT/Af5kZqdmdoy8LmbBtZ9ZuFV3Nr4GeW+lMPt2Q9IiuMt3qWZG6kq6BvhlJ+brpQCxHXDvwRjgM3T/Hj7GjfyJ1XCr8Ugzu6Hu4/nN5lXAdnjE69/xCOLj+mjbsaBBwsXahkhaVNLZwDfwprR/Sy2I9ga+JWmnDA93CC6+s4A30s8rgJ3xdaEtgZ16KEvXrqwJPNMLaSz9oWh5pigvKa9N8TZT7+FBWfvQ/Xv4IlP5E9vhbcE2bFAcV07H+bKZPWhm0/Hv9pLAjZKG1v2Ggj5LWJBthqRhwMV4EvkR3ZsIS9oWd7lua2b/zey4ea2Mu7CeLA7MSaW+tsYTtq+1nL2c1TH7MpL2xC2W0U0+zlfxOqHHNPM4fYVUAGB7YFXgMeDfxU2P530P3+dJfsK/8cjq1fFC5YPqXHMcjKeMXGlm+W6vCTgBGAccZmZX1vXGgj5JCGQbIWlXvIP7T4Bfl7sYSDoc+B6eFN10wUolv0bhids3Wc6mN/uYrUbSt4GVzGxsk4+zEzDOzEY28zh9gaLv0WLAjT19jySdhnsxPokL5F3UIZIpHekC3EX7hR7OqW2Av+DBYSfVu8YZ9C1CINsASQPxAI/DgTFmVrGyiqRT8C4Ho3ojuT7d+Y8EhuDRl9OK7/zbDUnn4K69PB7MNDMrd2u6aK+MX/i3B/JmVm3ka7+kyBPxLu6JeKnsttKGuDs0l5psk6JOaxZJST/B1xx3qHSeJDfspDTHg/pYwFhQByGQ/ZxUrPoCPIrv82bV5R0W3RkvAuzfG3e8qfPHJsDmwKv4he6NZh+3FaQ+gkfgKQhD8bJzr+MNe1/G3/8bwNv4utlsulIVCikrg/GuKUvh/QiXB1ZKj9eAp3DxvcbMzu6Ft9XrpF6O2+Jruk/jdVXLlo5LN4vT8XK163Z7bVO808wH+PkyGL8Gloy2lnQ0MBb4lFl5Qe62z8J4YNw+wL5mdmc1+wV9kxDIfoykLYC/AhfhifE1WWSSBgFX4qHvvZYwrbyG4NbkQOBflrMneuO4rSRduFfALb/lccFbGlgCdz0vQlfa1Rz8Ij4LX7t9ExfEV/BiAs+b9VxftB1QXsvijY6XpspoaEmXA8OBT5Sy+IpEci5uUa4KfKz7DaKkvYHT8SC3mlNoJO0L/I4+ULAiqJ8QyH5ICgw4EvgxcLSZ/b2BsZbCAxD+0ZtdN5TXEvh60orAA8AttXR6D9ob5bUWbjl+gDc6rtjLUdJ2+BrgMWZ2bQ/bjQD+jVdcmg0camaXFL0+El9P3MXM7qr7PUjr4qkgt+I3oH2mTnBQHSGQ/YxUKuu3wBbA58ysbCulGsZcCb9gnGFmv2h0vKqPm9cAYCu8lusLwHXlCksHnYHyGoivNa6Pu6Ovs1xpF+h8+3mk6f14h5hRFba9Dq/TWqgdfJeZbZZe+yTwD3zZ4YZ630fRsZYA/h+wHl69p+29Je1ECGQ/QtKaeArHg8BRWfark7QaLpKnmNmZWY1b1bHzWgNP8p4DTLWczezN4wd9g+RV2BF3Rd8H3FatV0HSPXh06/qVlhokfQX3viyMu7jfw4vEG3A1cLiZXVHv+yhxPAFfBb6f9dhBcwmB7CdIGo1XpvkxcFoz1guTAN+AR//1agkt5bUMfnFcFrgDuLvTqu90MsprNTwiV8ANlrMZVe/r630T8AjuqoJiUqWjfYEf4NbdFLybzLFmdnFts696np/C4wX+AIyPVJC+TwhkP0DSScBhuNvn5izGnDhm9GnA5WMnTb6m27HWAaYCP2yBSC6Eu77WBmbi1mSU8GpjUmTz5nh08yt4ZPObVe/va+h3AtPM7PCaj+/W3YHAL/CScZNqHaPG462Er29+gJ/PrzfzeEFjhED2cVI6xhxgbzO7NIsxJ44ZvT7upv3q2EmTTytxzHWA64Ef97a7FUB5DcddXu/ia1AvFnWKf6KRFlpBayn+HPE0l5F4S7OH8eT/WiOxH8atzvXMag/ySvmRVwLHm9lFte5fDyk16yVgazO7pTeOGdRHdPPo45jZ3ORePVPSrWb2XAbDjsHD3P9W5piPpIjA6yUt1puBOwCWs+nK6yXc5bqv8tob2AaPOBykvKYAh0RAT/8hdd0oNDWejech3o+7G6dazmrpeuJjSsfhqUI71ymOWwOX4pHgl1TaPgtSus95wK9CHPs+Uay8H5AW9c8ELk65i3Uzccxo4QJ5w9hJk8taYin3a1vgaEn55IrqNVLN1r8DB9DVpWHp9HNX/CIT9B8K4lj8OW4M7FqnOK6C10C9oM48xR2By+iW4tELnIQHE32rF48Z1EkIZP/hZOB/wO8aFKuN8D6FFddazOxpfE1wd+D0dPfbmyyHB050L6M2GNg1FaYO+jjJrdq9JRr45zqq1s8xff//hXtBxtc8H2kMXkXqc2Z2Va3714ukz+M3fPuZWVU9P4PWEgLZT0gupMOATfHyV/UyBl/TrKq4gJm9iNeiXA+4KOVh9hbDcHdcKebguaBBH0Z5LY3fYJULdpiNf8618BP82rVNrdHckr4GTMRrEP+nxuPWTap69Ru8WXNVZeuC1hNrkP0IM3tb0h7AzZIeNbPLatk/uVc/D1w7dtLkqrt4mNmbkj6Ld1K/TtKevdEFBK8zWs6lvAiwrvJaFHgIeMRyTe+9GFRBKgCxGp7sPwTvmVjO+zAI/5yrG9sDyPYDfpZu3qrdbyDwf3iHj0+b2VPV7tsoKcf4Urz93L29ddygccKC7Gckt+dewFmSNq9x9y3wwtk1h7Kn2p8H4sUEbpG0Xq1j1HzMnD1HVxPcYmYBk4HL8XJhnwIOUl4jlNdHmj2voDTKa7HUyPgLwE505bT+Dv+8Sn2OU6qNSk4R3ZOBOWb2+6rn5dVsLsbXPHtbHJfGG4hPrPWGNmg9YUH2Q8zsdklHAJdJGlFD+arP44JSV7pIcvN+V9KjwL8lHWRm11Tar0EOYcHoxyuAQ1MU6yPKawXcWlkHGK68XsDTWJ60XCRjN5u0hrgB7iodgOew3gg8XaiEo7zKfo41HOo8PKVjs6rn5tbb5Xiu5P5ZtRyr8tiL4ML8LzzPMuhnRB5kP0bSscDx+F1xjy7PiWNGD8DbBd05dtLkPTM49ra4Jfpz4BfN7gQyr1O8i15Ji0N5DcJFcgO8RdQsvFPJdMvZW82cX6eR2lCtjd+YLIffeD0MPNRTC7NqPseS+3mN1AuAsdVaYuk7+hd8zfHUer+j48ePH4AX1V8Vdx0/MH78+B4jb5O1ez7ermyfqJrTPwkLsh9jZqdL+igwRdIOZj2KwBZ4QnYm4eVm9m9JW+GNaTeTlGlt2AWO5xfTHi+oqU/g/crrAfy9ro9H7W6svJ7GrcqZUcKufpTXcvj/dW08CvVl3O3+WDVJ/tV8jgsc03ss/gl4pRpxTFGuxwEnAoeY2dU9bT9+/PilcOFbtczPIXQVNgf4Nn5j2NPx/w9vaL1jiGP/JQSy/3Mifnd7iaTdeugTeBvwCbyCSSaY2VOpMfDLuAvr1KzGboQkgDOBmakA9np4j8DPAm8qr+nAw1HGrjpS0M0wXBhXwSOIH8etxaoDZRrg+vRzRJXbDwd+DWxgZg91f3H8+PHfxQtPrJYeS3XbZA7wLPAM3qrqb7j35Zn0s9I59D28yMW20eKqfxMu1jYgRej9Bb/h2b83c6wk7Qf8DNjMzF7trePWSq0X+U4qbVfuvXa7uVgUeAuPGO61mwtJuwG/wi3Bm6rcR/j58JaZHdH99fHjx/8R2JD5Ra/w82ng+fHjx9dU8q7o2MfhBQxGZFT1KmghIZBtQgoIuBR4HTi4N9w6KZJ1Gt5YtqouCn2BMm7CB3HBHMSCwSRtWdquTPm3KcA4XDBXx4NietU9nW74vox3lrkMuNvM9q9xjCVxr8nPe6vovqTD8cIF25pV340k6LuEQLYRKYl/Mn43fHg99SlrONYS+AXoVDM7q1nHaSbKaxFgLTyoZ1k80ORQvIlzcdWXQjrCPr0+ySaivC5mwQo3HwAPAL+kRQFOknYHzsKLC7yFFyKv+YZP0nB8fXRnM7sr21kucKyD8ZZb22fRxDzoG4RAthmSFsfD5x8HjmyGSCYX1oXAO2b2pazHbwXJzbgNHinZvbQduEgOawd3q/IajN8Y3EHpQgyzgTUsZ//r1Ykxz3q8EXeDz8XXB79tZmfXOd7+uHBt3qwlAEkH4kE7O5jZ9GYcI2gNEaTTZpjZO6n7x2TgHElfaoK79Xg8neLTGY/bMixnzymvZ/EWW0uX2gQ4XnndB7yJWzbz/UxRtHWT1bpn6qu5BC4uS+GVbJYs+nshYA1cgEoxC3ev9rpA4pVuPopbsosAd+Nu/Lows4tS147zJe2e9Q2jpENwAd4xxLH9CAuyTUmW5OXAC3jHgkwCd1LU6t+Brcys6hJh/YEkUE+wYFFtcKtqL+BDugSn+3bvU0Y8cQEteXHuYS2w5LpnajK8GPOLXrEILtZtlw9LzGkwLjyl3mtLrOWUOzgNXx9+BV/Pu7DRG7yUJjIVuNbMftToPIvGPQKfY4hjmxIC2cakNcmL8Yvu53tIAal2vJVxt9xRZjYlgyn2Ocqsy5Vcg0xrmN2ts+K/u5dyfJvS4nkmbjl1P+Z1uLVeGK+esd+0XOlUg1rea29QVHziUuCHWRb1Tu2x7sDX5nvMi6xyvBOAr+NFzx9tdLygbxIC2eak6NYL8CCUvSsUE+hpnIXwC/a/zCyX4RT7FGWsueLSdtWO093K6/6zYOUtjbcyK7Xu+QGeU/cmXdbpPIuUKqzTCnPM5L1mRfqObdCsgt5JgC8CPllvPda0/p7D21aNSrWRgzYlBLIDSIEPZ+BVZXatpxOHpJ8V7d/2lUHqLYlWw/iFdcLtgT/iwtmdt4D9gX82ur5ZYS5Nfa99CUlj8ZrEI8xqy+VM59Gv8LX3XczshSZMMehDhEB2COnO98d4q6BdaihwjqTP4VVyNu+lNlcdQ4V1z7aJnO0rpPPgr3jZui/XsN9gvLbq8sBeZuXrzQbtQ7S76hDM+T5+Bzyt2lZZktbFrc/92l0cJa2Ruj/0GhVaelXdCioLJC0jaePeOl4rSAXLvwh8RtJh1ewjaTngWjzqd5cQx84hBLLDMLPTga8AV0rqsatHioS9GDjRzG7vjfm1mG8Bd0q6U9JJkrZNlkOzOYQukXwj/bwiPd80JA2QtKGkr0q6Fu/G8ccU9dm2pHX4fYCfV7ohkLQWcDNwC/CFRgPdgv5FuFg7FElb4NGCv8CbuVq314UH98zGI//a/otSZCkMwWu1zsZvIg81sxuafvxl9E3msCvf5IBmW46pke+N+DroQvj7nAN8rkNuhpD0eTxAanMze63E64WgnvFmdkZvzy9oPSGQHUxRM9m7gGOK744lfRX4ErB1J3UkSBbDlXhUqeFFukeZ2QNNPq6AGXibrjWaHR0paRBeSm5RPBp2UeDrZva3Zh63ryHpV3jRhD2LiwikHMefAAea2bWtml/QWsLF2sGki/A2eNrBP1OuGKnyyIl4o9eOEUcAM3sMX6MaQFcHi0sl3SRp1SYeegvgI3hqxxebdRBJg5MoPIAXEBBuRf6208Qx8U284fN3wYsKSPpNen5EiGNnExZkUKhg8n28g8JxwG9wi3JySyfWQiTtg7d5OhmP/P0xLppzgS+a2Y0ZH+8cfM1xIN5Q+KNZurXTzc9f8DJu4NWQfgjsBGwJ5JpZ3L4vI+ljwO14I+SjcIv6IDN7vaUTC1pOCGQwj9R7bzLwYzP7Qavn09dIAR2TcKE0vGv8WY0KS6p49ApusYKvfe5kZv9uZNw09ifx9ISCuOeBP3fCmnItSNoO+CfwIyDfqTcLwfyEQAbzIWlAXBx6RtIKeAWatXGhvBr4Vr3u6CSQ/wB2SE/dhQdG1VVRJq1nHopX4VGa4wFmdkc943UK8d0PuhMCGQR1ksr45fBqN8ILw48xs5l1jnc1bjmqzv0HA6cAo9NTT+Guwig0EAR1EAIZBA2SLLYxuHuu4Mo8zMxuqnGcugQyrS9eiKenGJ6+c2Lk7AVBY4RABkGGSNoED4YprFP+DDinGtddrQIpaUvgT3SJ8o+AC2J9MQiyIQQyCJqApBXxdcq1cKG8Cl+nLFsguxqBTNbqwXgaTkEYD+yU5P4g6E1CIIOgiaR1yh/hpc0EPIf35ny2xLZlBTKtL54M7JHGeRoXxueaOP0g6GhCIIOgF0iW3+fxNIuC5Xeomd1ctM0CApmaVP8ZWA23RC8Hvl9rq6YgCGonBDIIehlJm+JBNQNx0TsFOBcvcbeTmSnVyr2ALjE9GTgv1heDoPcIgQyCFiFpJTyJf4301MK4pfgoXcJ4sJnd2poZBkFnEwIZBBmQkv1n4rmQzwDP4uuNzwMv4pVyXgNex0uZvQ3MMjcXB+Gu1yOBJfEuGweY2XPJNbswXi91SWBpYFm8busKwErAKniR8yHARsCnQlSDoHFCIIMgAyQNB64DdgZWxQXro7iArYB3ol8WF7ilcMFbBC8r9z7eampOGm4A7n5dBBiEW5Lv4IXTX0+PV4CXcEF+HhfkmcA3gNvM7BfNfL9B0Aks1OoJBEGbMBR4MLXFqqo1VioSPyg9Cj0ZwQVxDi6cs83sw2onIekOYPXqpx0EQTlCIIMgG4bi/RyrJhUPeC89smIGMCLD8YKgY4l+kEGQDUOpUSCbxJPAsFZPIgjagRDIIMiGoVQQyJnjpmnmuGkfafI8ZqS5BEHQICGQQZANw3DrrSd+Atw6c9y0FZs4j9fwugTLNvEYQdARhEAGQTasjreX6onL8MjWyTPHTVu8GZNIhQRmEFZkEDRMCGQQNIikxfHUjR77Lg6ZMOIWvNzcZsBFM8dNa1aQXKxDBkEGhEAGQeOsDjxdTUurIRNGXA58BdgVOGPmuGl1NUeuwFNEqkcQNEwIZBA0zlBqiGAdMmHEmcCPgS8BuSbMJyzIIMiAEMggaJyh1J7i8UO8QHlu5rhpR2Y8nxnEGmQQNEwIZBAKkDV1AAAD80lEQVQ0TjURrPMxZMIIA47CGyn/bua4aaMznM8MQiCDoGFCIIOgcYZSR5GAIRNGfADsB9yDB+18MqP5zACGpkLnQRDUSQhkEDTO6tRZRWfIhBFvA7vhnT8mzxw3be0M5vM63mcyciGDoAFCIIOgcYbRQJm5IRNGvADskv68qtEcyZQLGYE6QdAgIZBB0ACSlgAWx9tO1c2QCSMeBUYDPx0yYcQ7GUxtBrEOGQQNEf0gg6ABJG0AXGxm67V6LsVI+iXwjJlNbPVcgqC/EhZkEDTGUPpGF4/uzCAsyCBoiBDIIGiMmlM8eokZxBpkEDRECGQQNMZQ+q4FGeXmgqABmlUsOQg6hbWBFSR9ApgJvGYtXNiXtBgwBFgT+LgktXI+QdCfiSCdIGgASWPwmqofw4VpETyn8XngpfR4Fe/T+AbwJvA28F56vJ8ec4BCsXMBA4GF03iDgcXwaNklgaWBZYDlgOWBFYCVgFXSts8CTwO3A98JgQyC+giBDIIMSWkfq+CCtSLwkfRYBhe2JYElcMFbFBiEC+FAupY8DBfMD3DxnAW8C7wDvIWL7Gvp8TIuwi/govxqCGIQZEMIZBAEQRCUIIJ0giAIgqAEIZBBEARBUIIQyCAIgiAoQQhkEARBEJQgBDIIgiAIShACGQRBEAQlCIEMgiAIghKEQAZBEARBCUIggyAIgqAEIZBBEARBUIIQyCAIgiAoQQhkEARBEJQgBDIIgiAIShACGQRBEAQlCIEMgiAIghKEQAZBEARBCUIggyAIgqAEIZBBEARBUIIQyCAIgiAoQQhkEARBEJQgBDIIgiAIShACGQRBEAQlCIEMgiAIghKEQAZBEARBCUIggyAIgqAEIZBBEARBUIIQyCAIgiAoQQhkEARBEJQgBDIIgiAIShACGQRBEAQlCIEMgiAIghKEQAZBEARBCUIggyAIgqAEIZBBEARBUIIQyCAIgiAoQQhkEARBEJQgBDIIgiAIShACGQRBEAQlCIEMgiAIghKEQAZBEARBCUIggyAIgqAEIZBBEARBUIIQyCAIgiAoQQhkEARBEJQgBDIIgiAIShACGQRBEAQlCIEMgiAIghKEQAZBEARBCUIggyAIgqAEIZBBEARBUIIQyCAIgiAoQQhkEARBEJQgBDIIgiAIShACGQRBEAQlCIEMgiAIghKEQAZBEARBCUIggyAIgqAEIZBBEARBUIIQyCAIgiAoQQhkEARBEJQgBDIIgiAIShACGQRBEAQlCIEMgiAIghKEQAZBEARBCUIggyAIgqAEIZBBEARBUIIQyCAIgiAoQQhkEARBEJQgBDIIgiAIShACGQRBEAQlCIEMgiAIghL8f0kYTvdnkL9NAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.patches as patches\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import Rectangle, Arrow\n",
    "from matplotlib.colors import hsv_to_rgb\n",
    "from matplotlib.collections import PatchCollection\n",
    "\n",
    "def envelope(th, theta, B_theta):\n",
    "    if B_theta==np.inf:\n",
    "        env = np.ones_like(th) \n",
    "    elif B_theta==0:\n",
    "        env = np.zeros_like(th)\n",
    "        env[np.argmin(th < theta)] = 1.\n",
    "    else:\n",
    "        env = np.exp((np.cos(2*(th-theta))-1)/4/B_theta**2)\n",
    "    return env/env.max()      \n",
    "\n",
    "patch_list = []\n",
    "fig = plt.figure(figsize=(8, 8))\n",
    "\n",
    "ax2 = fig.add_subplot(111, alpha=0.)\n",
    "ax2.set_facecolor((1,1,1,0))\n",
    "ax = fig.add_subplot(111, projection='polar', alpha=0.)\n",
    "ax.set_facecolor((1,1,1,0))\n",
    "\n",
    "opts= dict(ha='center', fontsize=14)\n",
    "opts_small= dict(ha='center', fontsize=11)\n",
    "N = 24\n",
    "s = 42\n",
    "theta = np.linspace(0, 2*np.pi, N+1, endpoint=True)\n",
    "\n",
    "## connexions\n",
    "N_arrow = 1 #number of connection arrows \n",
    "dthetas = alphas = np.linspace(-N_arrow, N_arrow, 2*N_arrow+1, endpoint=True)\n",
    "dthetas *= 1.75*np.pi/N\n",
    "alphas = np.exp( - alphas**2/ .4**2 / 2)\n",
    "\n",
    "for dtheta, alpha in zip(dthetas, alphas): #extra-layers arrows\n",
    "    #feedforward arrows\n",
    "    plt.arrow(np.pi/2, 1.22, dtheta, -.085, color='k', alpha=alpha, head_width = .03)\n",
    "    plt.arrow(np.pi/4, 1.01, dtheta, -.135, color='k', alpha=alpha, head_width = .03)\n",
    "    plt.arrow(5*np.pi/4, 1.01, dtheta, -.135, color='k', alpha=alpha, head_width = .03)\n",
    "    plt.arrow(-np.pi/2, 1.22, dtheta, -.085, color='k', alpha=alpha, head_width = .03)\n",
    "    #plt.arrow(np.pi, .82, dtheta, -.1, color='k', alpha=alpha, head_width = .03)\n",
    "    #feedback arrows\n",
    "    plt.arrow(0, .83, dtheta, .135, color='k', alpha=alpha, head_width = .03)\n",
    "    plt.arrow(-np.pi/4, 1.1, dtheta, .08, color='k', alpha=alpha, head_width = .03)\n",
    "    \n",
    "    \n",
    "    #plt.arrow(np.pi, 1.25, dtheta, 0., color='b', alpha=alpha)\n",
    "    #set_connectionstyle(\"arc,angleA=0,armA=30,rad=10\")\n",
    "#set_arrowstyle(\"Fancy,head_length=0.2\")\n",
    "N_arrow = 0 #number of connection arrows \n",
    "dthetas = alphas = np.linspace(-N_arrow, N_arrow, 2*N_arrow+1, endpoint=True)\n",
    "dthetas *= 1.75*np.pi/N\n",
    "alphas = np.exp( - alphas**2/ .4**2 / 2)\n",
    "for dtheta, alpha in zip(dthetas, alphas):\n",
    "    plt.arrow(np.pi/2+0.06, .6, dtheta, -.10,color='k', alpha=alpha, head_width = .05)\n",
    "\n",
    "## neurones\n",
    "colors = theta\n",
    "for r, c in zip([1.05, 1.4], ['g', 'k']): #scattering neurons\n",
    "    if c!= 'k':\n",
    "        ax.plot(theta, r*np.ones_like(theta), c=c, alpha=.4) #ring drawing\n",
    "        c = ax.scatter(theta[:-1], r*np.ones_like(theta[:-1]), c=c, s=s)\n",
    "    \n",
    "theta = np.linspace(0, 2*np.pi, 8+1, endpoint=True)\n",
    "rad = 1.36\n",
    "ys = np.ones_like(theta[:-1])\n",
    "jet= plt.get_cmap('jet')\n",
    "colors = iter(jet(np.linspace(0,1,len(theta[:-1]))))\n",
    "for i,xs in enumerate(theta[:-1]):\n",
    "    '''ax.arrow(x=xs,y=rad*ys[i],\n",
    "                        dx=-0.05*i*(np.pi/8), dy=-0.1,\n",
    "                        width=.01, color=next(colors), \n",
    "             head_width=0)'''\n",
    "        # Create a Rectangle patch\n",
    "    rect = patches.Rectangle((xs-.125,rad*ys[i]-.13),.25,.2,linewidth=1,edgecolor='k',facecolor='none')\n",
    "    plt.plot([xs,xs+.1 -0.05*i*(np.pi/6)], [rad*ys[i], rad*ys[i]-.08] )\n",
    "    # Add the patch to the Axes\n",
    "    ax.add_patch(rect)\n",
    "    #ax.Rectangle(xy = (xs-.5, rad*ys[i]), width = .5, height = .5)\n",
    "    #c.set_alpha(0.15)\n",
    "    \n",
    "rad = .75\n",
    "ys = np.ones_like(theta[:-1])\n",
    "jet= plt.get_cmap('jet')\n",
    "colors = iter(jet(np.linspace(0,1,len(theta[:-1]))))\n",
    "for i,xs in enumerate(theta[:-1]):\n",
    "    '''ax.arrow(x=xs+.1,y=rad*ys[i],\n",
    "                        dx=-0.05*i*(np.pi/8), dy=-0.1,\n",
    "                        width=.01, color=next(colors), \n",
    "             head_width=0)'''\n",
    "    plt.plot([xs,xs+.1 -0.05*i*(np.pi/6)], [rad*ys[i], rad*ys[i]-.1] )\n",
    "    rect = patches.Rectangle((xs-.15,rad*ys[i]-.13),.3,.2,linewidth=1,edgecolor='k',facecolor='none')\n",
    "    ax.add_patch(rect)\n",
    "    \n",
    "## entrée\n",
    "N = 360\n",
    "theta = np.linspace(0, 2*np.pi, N, endpoint=True)\n",
    "#ax.fill_between(theta, 1.45, 1.45 + envelope(theta/2, np.pi/4, np.pi/24)/2.5, lw=0, color='g', alpha=.3)\n",
    "ax.fill_between(theta, .4, .38 + envelope(theta/2, np.pi/4, np.pi/26)/-3.5, lw=0, color='g', alpha=.6)\n",
    "\n",
    "ax.set_ylim((0, 2))\n",
    "\n",
    "\n",
    "ax.text(np.pi/2, 1.52, 'Oriented\\nvisual input', **opts_small)\n",
    "ax.text(-np.pi/2, 0.2, 'Orientation\\n output', **opts_small)\n",
    "#ax.text(np.pi, 1.9, 'Convolutional\\nnetwork', **opts)\n",
    "#ax.text(11*np.pi/12, 1.4,  'LSTM\\nnetwork', **opts)\n",
    "#ax.text(10*np.pi/12, 1.1,  '{', **opts)\n",
    "\n",
    "# Polar barplot\n",
    "#N = 128\n",
    "#theta = np.linspace(np.pi/3, 2*np.pi/3, N)\n",
    "#radius = envelope(theta, np.pi/2, np.pi/16)/3\n",
    "#rands = np.random.normal(.15, .1, N)/4\n",
    "\n",
    "# using np.random.vonmises\n",
    "N, N_samples = 128, 256\n",
    "theta = np.linspace(np.pi/4, 3*np.pi/4, N)\n",
    "#theta = np.linspace(0, np.pi, N)\n",
    "B_theta = np.pi/36\n",
    "mu, kappa = 0.0, 1/4.0/B_theta**2 # mean and dispersion\n",
    "s = np.random.vonmises(np.pi/2, kappa, 1000)\n",
    "print('min', s.min(), s.max())\n",
    "hist, bins = np.histogram(s, bins=theta, normed=True)\n",
    "hist /= hist.max()\n",
    "\n",
    "#width = theta[1] - theta[0]\n",
    "bars = ax.bar(theta[:-1], hist/3, width=theta[1] - theta[0], bottom=1.45, color = 'g', alpha = .4)\n",
    "#for i, t in enumerate(theta) :\n",
    "#    bars = ax.bar(t, radius[i]+np.abs(np.sin(20*t)/5)+rands[i], width=width, bottom=1.45, color = 'g', alpha = .4)\n",
    "    #bars = ax.bar(t, radius[i]*np.sin(t), width=width, bottom=1.45, color = 'g', alpha = .3)\n",
    "\n",
    "for ax_ in [ax, ax2]:\n",
    "    ax_.grid(False, axis='both')\n",
    "\n",
    "    ax_.set_xticks([])\n",
    "    ax_.set_yticks([])\n",
    "    ax_.set_axis_off()\n",
    "\n",
    "#ax.add_collection(PatchCollection(patch_list))\n",
    "#fig.subplots_adjust(hspace = .0, wspace = .0, left=0.01, bottom=0.01, right=.99, top=.99)\n",
    "plt.show()\n",
    "fig.savefig('./figs/Fig_ring_model.pdf', format='pdf', dpi=200, transparent = False, bbox_inches = 'tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8, 8))\n",
    "ax = fig.add_subplot(111, projection='polar', alpha=0.)\n",
    "ax.set_facecolor((1,1,1,0))\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])\n",
    "ax.set_axis_on()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-01T10:40:09.225597Z",
     "start_time": "2018-10-01T10:40:07.460289Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6499: MatplotlibDeprecationWarning: \n",
      "The 'normed' kwarg was deprecated in Matplotlib 2.1 and will be removed in 3.1. Use 'density' instead.\n",
      "  alternative=\"'density'\", removal=\"3.1\")\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mu, kappa = 0.0, 4.0 # mean and dispersion\n",
    "s = np.random.vonmises(mu, kappa, 1000)\n",
    "from scipy.special import i0\n",
    "plt.hist(s, 50, normed=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))\n",
    "plt.plot(x, y, linewidth=2, color='r')\n",
    "plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-01T10:47:54.293470Z",
     "start_time": "2018-10-01T10:47:53.256913Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min 0.9005728593427751 2.0722575929986347\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/site-packages/ipykernel_launcher.py:8: VisibleDeprecationWarning: Passing `normed=True` on non-uniform bins has always been broken, and computes neither the probability density function nor the probability mass function. The result is only correct if the bins are uniform, when density=True will produce the same result anyway. The argument will be removed in a future version of numpy.\n",
      "  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x13c178978>]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N, N_samples = 128, 256\n",
    "theta = np.linspace(np.pi/4, 3*np.pi/4, N)\n",
    "#theta = np.linspace(0, np.pi, N)\n",
    "B_theta = np.pi/36\n",
    "mu, kappa = 0.0, 1/4.0/B_theta**2 # mean and dispersion\n",
    "s = np.random.vonmises(np.pi/2, kappa, 1000)\n",
    "print('min', s.min(), s.max())\n",
    "hist, bins = np.histogram(s, bins=theta, normed=True)\n",
    "plt.plot(bins[:-1], hist )#, linewidth=2, color='r')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}