{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random numbers from Base Python\n",
    "\n",
    "1. Module random from the base Python — It generates A SINGLE pseudo-random number\n",
    "2. To generate an array of random numbers, the most efficient is to use the random module from numpy. \n",
    "3. Note that the two modules have the same name: random from base and random from numpy\n",
    "\n",
    "\n",
    "1. If you need the density, cumulative function or quantile (and random numbers) use the stats module from the scipy package.\n",
    "2. Besides these distributional functionals, it can also generate random numbers from a VERY LARGE number of distributions: discrete, continuous and multivariate.\n",
    "\n",
    "\n",
    "## Outline of this notebook\n",
    "\n",
    "1. We start with random from base (mostly copied from https://docs.python.org/3/library/random.html)\n",
    "2. Move to explain random from numpy \n",
    "3. End with stats from scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Module random from base Python\n",
    "\n",
    "import random\n",
    "\n",
    "# Initialize the random number generator.\n",
    "random.seed(123) # random.seed() uses the current system time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Algorithm\n",
    "\n",
    "1. Python uses the Mersenne Twister as the core generator. \n",
    "2. It produces 53-bit precision floats and has a period of 2 to the power 19937-1. \n",
    "3. The underlying implementation in C is both fast and threadsafe. \n",
    "4. The Mersenne Twister is one of the most extensively tested random number generators in existence. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sampling integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "<class 'list'>\n",
      "[5, 4, 4, 9, 8, 1, 1, 0, 10, 5, 5, 7, 7, 6, 2, 2, 3, 2, 10, 10, 5, 3, 7, 2, 10, 8, 3, 6, 5, 6]\n",
      "[5, 7, 8, 9, 9, 3, 6, 10, 6, 6, 5, 8, 10, 8, 3, 10, 8, 10, 3, 6, 3, 7, 5, 7, 5, 10, 5, 5, 6, 5]\n",
      "2\n",
      "[4, 5, 5, 2, 5, 5, 4, 4, 3, 2]\n",
      "[5, 9, 7, 3, 7, 5, 9, 7, 9, 9, 3, 3, 5, 5, 9, 9, 5, 3, 9, 3]\n"
     ]
    }
   ],
   "source": [
    "## an integer from {0, 1,.., stop-1}\n",
    "## USAGE: random.randrange(stop)\n",
    "print(random.randrange(7))\n",
    "\n",
    "# Generating an array with 20 random  integers from 0 to 11-1 \n",
    "# A better way, a more efficient one, is explained in the next section using the random module from numpy \n",
    "x = [ random.randrange(11) for _ in range(30) ]\n",
    "print( type(x) )\n",
    "print(x)\n",
    "\n",
    "# Selecting from {start, start+1, ..., stop-1}\n",
    "# random.randrange(start, stop) (stop is optional)\n",
    "x = [ random.randrange(3, 11) for _ in range(30) ]\n",
    "print(x)\n",
    "\n",
    "# Another option to select a random integer in {a, a+1, ..., b} (includes b) \n",
    "# random.randint(a, b)\n",
    "# It is an alias for randrange(a, b+1).\n",
    "print( random.randint(0, 10)) \n",
    "\n",
    "x = [ random.randint(2, 5) for _ in range(10) ]\n",
    "print(x)\n",
    "\n",
    "# Selecting from {start, start+step, start+2*step, ..., stop-1 } (in fact, the last start+k*step <= stop-1)\n",
    "# random.randrange(start, stop, step)  (stop ans step are optional)\n",
    "x = [ random.randrange(3, 11, 2) for _ in range(20) ]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sampling from sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "two\n",
      "['four', 'three']\n",
      "<class 'list'>\n",
      "['five', 'five', 'five', 'three', 'three', 'one', 'five', 'five', 'five', 'two']\n",
      "Permuted items saved in new list y:  ['five', 'two', 'one', 'three', 'four']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['four', 'three', 'five', 'one', 'two']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a sequence (a python list) \n",
    "items = ['one', 'two', 'three', 'four', 'five']\n",
    "\n",
    "# Select ONE random element from this list with equal probability\n",
    "print( random.choice(items) )\n",
    "\n",
    "# Select k elements WITH REPLACEMENT (note the ending 's' in choices)\n",
    "print( random.choices(items , k=2) )\n",
    "\n",
    "# Select k elements WITH REPLACEMENT and with probabilities proportional to a list of positive weights\n",
    "w = [10, 5, 30, 5, 100]\n",
    "x = random.choices(items, weights=w , k=10)\n",
    "print( type(x))\n",
    "print(x)\n",
    "\n",
    "# Select k elements WITHOUT replacement. (k <= len(items)) No weights here.\n",
    "random.sample(items, k=2)  \n",
    "\n",
    "# Permuting a list \n",
    "y = random.sample(items, k=len(items)) \n",
    "print(\"Permuted items saved in new list y: \", y)\n",
    "\n",
    "# Permuting in place (permuting and changing the original list) \n",
    "random.shuffle(items)\n",
    "items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Selecting from continuous intervals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8653162277486719\n",
      "[0.274, 0.501, 0.262, 0.666, 0.801, 0.463, 0.123, 0.465, 0.138, 0.99]\n",
      "0.4162972144974141\n",
      "0.3704151557823648\n",
      "1.6957786065730736\n",
      "1.7481644881712621\n"
     ]
    }
   ],
   "source": [
    "# Sampling from continuous intervals \n",
    "\n",
    "# Sampling ONE single value in the interval [0,1)\n",
    "# Function random selects a float from the continuous interval [0, 1)\n",
    "print(random.random())\n",
    "\n",
    "# Sampling some values from [0,1) (it is better to use the random module from numpy. See below)\n",
    "x = [ random.random() for _ in range(10) ]\n",
    "\n",
    "# Rounding these values to exhibit\n",
    "rounded_x = [ round(elem, 3) for elem in x ]\n",
    "print(rounded_x)\n",
    "\n",
    "# We can sample from: uniform, normal, lognormal, negative exponential, gamma, beta, and von Mises. \n",
    "# Some examples:\n",
    "\n",
    "# random.triangular(low, high, mode)\n",
    "print( random.triangular(0,1,0.1))\n",
    "\n",
    "# random.betavariate(alpha, beta)\n",
    "print( random.betavariate(10, 20) )\n",
    "\n",
    "# random.gauss(mu, sigma)\n",
    "print(random.gauss(0,1))\n",
    "\n",
    "# random.normalvariate(mu, sigma) : slower than gauss, the above function \n",
    "print( random.normalvariate(0, 1)  )                                                                                             "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module random from numpy\n",
    "\n",
    "This random module from NumPy is more flexible than the random module from the Base Python. \n",
    "\n",
    "It can immediately generate multi-dimensional arrays, .....\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.random.seed(444)\n",
    "np.set_printoptions(precision=3)  # Output decimal fmt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sampling integers with numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[5 3 5 4 2 4 4 2 2 3 5 5 4 3 3 3 5 5 5 2 5 2 5 5 2]\n",
      "<class 'int'>\n",
      "10\n",
      "[0 0 4 3 0 2 2 2 4 0]\n",
      "2\n",
      "<class 'numpy.ndarray'>\n",
      "[[3 4 2 2]\n",
      " [4 5 3 5]]\n"
     ]
    }
   ],
   "source": [
    "# Warnings: \n",
    "#   w1: function random_integers is deprecated. ---> Use randint instead\n",
    "#   W2: function randint is almost like random_integers (it only does not include the final extreme)\n",
    "\n",
    "# randint(low=a, high=b, size=n): Sampling n integers uniformly WITH REPLACEMENT from {a, a+1, a+2, ..., b-1} \n",
    "# (with a < b)    Note that b is **not** included\n",
    "# This has the SAME syntax as the randint function from the Base Python random module\n",
    "\n",
    "# Sampling 25 values from {2, 3, 4, 5}\n",
    "x = np.random.randint(2, 5+1, 25)\n",
    "print(type(x))   # it is a numpy array\n",
    "print(x)\n",
    "\n",
    "# randint(low, high): Sampling ONE single integer in {low, low+1, ..., high-1}\n",
    "x = np.random.randint(5, 11)\n",
    "print(type(x))   # an integer atom\n",
    "print(x)\n",
    "\n",
    "# randint(low, size=10): Sampling 10 integers with replacement from {1, ..., low-1}\n",
    "print( np.random.randint(5, size=10))\n",
    "\n",
    "# randint(low): Sampling ONE SINGLE integer from {1, ..., low-1}\n",
    "# If high is None (the default), then results are from {1,2,..., low-1}. \n",
    "print( np.random.randint(5))\n",
    "\n",
    "# randint(low, high, size=(n, m)): sampling n*m values from {low, ..., high-1} in array 2 x 4 \n",
    "x = np.random.randint(2, 5+1, size=(2, 4))\n",
    "print(type(x))   # it is a numpy array\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sampling from sequences with numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "['two' 'four' 'four' 'two' 'one' 'three' 'one' 'three' 'three' 'five']\n",
      "[ 9 15 12  1  4]\n",
      "['three' 'four' 'five' 'two' 'one']\n",
      "[1 2 7 3 6 9 8 5 4 0]\n"
     ]
    }
   ],
   "source": [
    "# Sampling from sequences with numpy\n",
    "# Function choice\n",
    "# It is the **same** syntax from the Base Python random module\n",
    "\n",
    "# numpy.random.choice(items, size=None, replace=True, p=None)\n",
    "# items = 1-D array-like (of integers, floats or strings)\n",
    "\n",
    "items = ['one', 'two', 'three', 'four', 'five']\n",
    "x = np.random.choice(items, 10, replace=True, p=[0.1, 0.2, 0.3, 0.2, 0.2])\n",
    "print(type(x))\n",
    "print(x)\n",
    "\n",
    "# Permuting a list with numpy\n",
    "print( np.random.permutation([1, 4, 9, 12, 15]) )\n",
    "print( np.random.permutation(items) )\n",
    "print( np.random.permutation(10) ) # random permutation of the integers {0, 1,...,9} (starts at zero, ends at 10-1)\n",
    "\n",
    "########################################\n",
    "# The sample function from numpy is used to sample float. See below..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sampling from continuous intervals "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sampling from U(0,1)\n",
    "# numpy.random.uniform(low=0.0, high=1.0, size=None)\n",
    "\n",
    "x = np.random.uniform(low=0.0, high=1.0, size=(2,4))\n",
    "print( type(x))\n",
    "print( x) \n",
    "\n",
    "#########################################################################################\n",
    "# Sampling from triangular distribution\n",
    "# numpy.random.triangular(left, mode, right, size=None)\n",
    "x = np.random.triangular(left=0.0, mode=0.1, right=1.0, size=(2,10))\n",
    "print( type(x))\n",
    "print( x) \n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "h = plt.hist(np.random.triangular(-3, 0, 8, 100000), bins=200, density=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[ 0.736  1.496  2.152 ...  0.061 -0.637  0.103]\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": [
    "#########################################################################################\n",
    "# Sampling from the Student's t-distribution with df degrees of freedom\n",
    "# numpy.random.standard_t(df, size=None)\n",
    "\n",
    "x = np.random.standard_t(df=3, size=10000)\n",
    "print( type(x))\n",
    "print( x) \n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "h = plt.hist(x, bins=200, density=True)\n",
    "plt.show()\n",
    "\n",
    "# OBS: no docs oficial em \n",
    "# https://numpy.org/doc/stable/reference/random/generated/numpy.random.standard_t.html\n",
    "# lemos esta afrimacao erronea\n",
    "# So the p-value is about 0.009, which says the null hypothesis has a probability of about 99% of being true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More distributions in numpy\n",
    "\n",
    "1. Gaussian: numpy.random.normal(loc=0.0, scale=1.0, size=None)\n",
    "2. Pareto: numpy.random.pareto(a, size=None) (it has shape a. We sample X-mu where mu is the shift; values start at zero) \n",
    "3. F-noncentral: numpy.random.noncentral_f(dfnum, dfden, nonc, size=None)\n",
    "4. Chi-2 noncentral: numpy.random.noncentral_chisquare(df, nonc, size=None)\n",
    "5. numpy.random.negative_binomial(n, p, size=None)\n",
    "6. Many others... BUT SEE WHAT WE CAN DO WITH SCIPY...NEXT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random numbers in SciPy\n",
    "\n",
    "1. The random module in the numpy library only generates random variables from a limited number of distributions.\n",
    "2. The scipy library versions will also provide useful functions related to the distribution, e.g. PDF, CDF and quantiles.\n",
    "3. Probability distribution classes are located in the stats module of the scipy library: scipy.stats \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Main methods\n",
    "\n",
    "The main methods associated with probability distribution classes are:\n",
    "\n",
    "1. rvs (random numbers), \n",
    "2. pdf, \n",
    "2. cdf, \n",
    "4. sf (survival function), \n",
    "5. ppf (quantile fcn or cdf inverse), \n",
    "6. stats (Mean, variance, skew, or kurtosis)\n",
    "\n",
    "It returns numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Example: Gaussian or normal random variables: rvs(loc=0, scale=1, size=1, random_state=None)\n",
    "\n",
    "import scipy.stats as stats\n",
    "\n",
    "# Evaluating the normal density at one single point\n",
    "fx = stats.norm.pdf(5.7, 3, 4) \n",
    "print(\"density of N(3,4) at the point 5.7 is \", fx)\n",
    "print(type(fx), '\\n')\n",
    "\n",
    "# Evaluating the normal density at several points\n",
    "fx = stats.norm.pdf([4.7, 5.7, 6.7], 3, 4) \n",
    "print(\"density of N(3,4) at the point 4.7, 5.7, and 6.7 is \", fx)\n",
    "print(type(fx), '\\n')\n",
    "\n",
    "# Evaluating different normal densities, same sd, at several points\n",
    "fx = stats.norm.pdf([4.7, 5.7, 6.7], [0, 3, 3],  4) \n",
    "print(\"density of N(0,4), N(3,4), and N(3,4) at the points 4.7, 5.7, and 6.7 is \", fx)\n",
    "print(type(fx), '\\n')\n",
    "\n",
    "# Evaluating normal densities with different means and sds at several points\n",
    "fx = stats.norm.pdf([4.7,5.7,6.7], [0, 3, 6.7], [1,4,1]) \n",
    "print(\"density of N(0,1), N(3,4), and N(6.7,1) at the points 4.7, 5.7, and 6.7 is \", fx)\n",
    "print(type(fx), '\\n')\n",
    "\n",
    "# Generating Gaussin random variables\n",
    "x = stats.norm.rvs(0, 1, 5) \n",
    "print(\"Sample of 5 values of N(0,1):\", x)\n",
    "print(type(x), '\\n')\n",
    "\n",
    "# Note a small inconsistency: the rvs function reqires loc and scale as its first arguments but other functions require \n",
    "# them after their other arguments: stats.norm.rvs(0, 1, 1000) but stats.norm.pdf(5.7, 0, 1)   \n",
    "\n",
    "# We can omit the mean and sd if they are the default values BUT then we need to declare the size parameter \n",
    "x = stats.norm.rvs(size=5)\n",
    "print(\"Sample of 5 values of N(0,1):\", x)\n",
    "print(type(x), '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# More statistics:\n",
    "\n",
    "# cdf of N(loc, scale)=N(0,1) of some points\n",
    "Fx = stats.norm.cdf([-2, -1, 0, 1, 1.96])\n",
    "print(\"cdf of N(0,1) at the points -1, -1, 0, 1, and 2 is \", np.round(Fx, 3))\n",
    "print(type(Fx), '\\n')\n",
    "\n",
    "# Statistics of a normal distribution: use the stats method\n",
    "m, v, skew, kurt = stats.norm.stats(moments='mvsk')  # it is using the standard Gaussian\n",
    "print('N(0,1) moments: Mean: ', m, ' , variance: ', v, ' , skewness: ', skew, ' , kurtosis: ', kurt, '\\n')\n",
    "\n",
    "m, v, skew, kurt = stats.norm.stats(loc=2, scale=4, moments='mvsk')  # passing other parameters\n",
    "print('N(0,1) moments: Mean: ', m, ' , variance: ', v, ' , skewness: ', skew, ' , kurtosis: ', kurt, '\\n')\n",
    "\n",
    "qx = stats.norm.ppf([0.025, 0.5, 0.95, 0.975], loc=0, scale=1 )\n",
    "print(\"percentiles of N(0,1) at the probabilities 0.025, 0.5, 0.95, and 0.975 are \", np.round(qx, 3))\n",
    "print(type(qx), '\\n')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ploting the normal density on top of a normal sample histogram\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "\n",
    "x = np.linspace(-8, -2, 100)\n",
    "r = stats.norm.rvs(loc=-5, scale=1, size=1000)\n",
    "\n",
    "ax.plot(x, stats.norm.pdf(x, loc=-5, scale=1), 'r-', lw=5, alpha=0.6, label='norm pdf')\n",
    "ax.hist(r, density=True, histtype='stepfilled', alpha=0.2)\n",
    "ax.legend(loc='best', frameon=False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Main univariate probability distributions and their parameterizations\n",
    "\n",
    "SciPy has very large list of probability distribution functions. See complete list at: https://docs.scipy.org/doc/scipy/reference/stats.html\n",
    "\n",
    "SciPy uses an unusual location-scale parametrization family, even for distributions that do not use loc-scale parametrization usually. \n",
    "\n",
    "\n",
    "| Distribution  | Parameters     | 10 r.v.'s using rvs                 | Example: pdf ou pmf             |\n",
    "|-------------- |--------------- | ----------------------------------- | ------------------------------- | \n",
    "| U(a, b)       | a=loc,b-a=scale| stats.uniform.rvs(a, b-a, size=100) | stats.uniform.pdf(x, a, b-a)    |\n",
    "| binom         | size, prob     | stats.binom.rvs(n, p, size=100)     | stats.binom.pmf(k, n, p)        |   \n",
    "| poisson\t    | mu             | stats.poisson.rvs(mu=1.5, size=100) | stats.poisson.pmf(2, mu=2.5)    |\n",
    "| betabinom     | n, a, b        | stats.betabinom.rvs(n,a,b,size=7)   | stats.betabinom.rvs(k, n, a, b) |\n",
    "| nbinom        | n=sucesses, p  | stats.nbinom.rvs(n, p, size=100)    | stats.nbinom.pmf(k, n, p, loc)  |                 \n",
    "| hypergeom\t    | M=tot,n=A,N=sam| stats.hypergeom.rvs(M, n, N, size=) | stats.hypergeom.pmf(k, M, n, N) |\n",
    "| zipf          | a, loc         | stats.zipf.rvs(a, loc=0, size=100)  | stats.zipf.rvs(k, a, loc=0)     |  \n",
    "| beta\t        | a, b           | stats.beta.rvs(a, b, size=)         | stats.beta.pdf(x, a, b)         |\n",
    "| normal        | loc, scale(sd) | stats.norm.rvs(loc, scale, size=100)| stats.norm.pdf(x, loc, scale)   |\n",
    "| exp(lambda)   | scale=1/lambda | stats.expon.rvs(scale, size=100)    | stats.expon.pdf(x, scale)       |       \n",
    "| gamma(a,b)\t| a, shape=1/b   | stats.gamma.rvs(x, a, scale=, size=)| stats.gamma.pdf(x, a, scale=)   |\n",
    "| pareto(b, loc)| b, loc         | stats.pareto.rvs(b, loc=1, size=100)| stats.pareto.pdf(x, b, loc=1)   |\n",
    "| t             | df, loc, scale | stats.t.rvs(df,loc=0,scale=1,size=) | stats.t.rvs(x,df,loc=0,scale=1) |\n",
    "| lognorm\t    | sdlog          |                                     |                                 |\n",
    "| cauchy        |                |                                     |                                 |\n",
    "| chi2\t        | df             |                                     |                                 |\n",
    "| f \t        | df1, df2       |                                     |                                 |\n",
    "| geom \t        | p              |                                     |                                 |\n",
    "| invgamma      | shape          |                                     |                                 |\n",
    "| logistic      |                |                                     |                                 |\n",
    "| exponweib     | exponent, shape|                                     |                                 |\n",
    "| randint (disc)| low, high      | stats.randint.rvs(0, 10, size=7)    | stats.randint.pmf(3, 0, 10)     |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some examples:\n",
    "# Poisson (parameter is mu, it is not the usual lambda)\n",
    "x = stats.poisson.rvs(mu=2.5, size=10) # sampling 10 Poisson(2.5) values\n",
    "print(\"Random sample of 10 values of Poisson(mu=2.5): \", x)\n",
    "\n",
    "# Evaluating different Poisson probability mass function at some points\n",
    "fx = stats.poisson.pmf([0, 1, 2, 3, 4], mu=2.5) \n",
    "print(\"probability function of Poisson(2.5) at the points 0:4 is \", np.round(fx,2))\n",
    "print(type(fx), '\\n')\n",
    "\n",
    "x = np.arange(0, 11)\n",
    "fx = stats.poisson.pmf(x, mu=2.5)\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "ax.plot(x, fx, 'bo', ms=8, label='poisson pmf')\n",
    "ax.vlines(x, 0, fx, colors='b', lw=5, alpha=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n, p = 20, 0.1\n",
    "x = np.arange(0, 20)\n",
    "fx = stats.binom.pmf(x, n, p)\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "ax.plot(x, fx, 'bo', ms=8, label='binom pmf')\n",
    "ax.vlines(x, 0, fx, colors='b', lw=5, alpha=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# BetaBinomial: a binomial distribution with a probability of success p that follows a beta distribution.\n",
    "# parameters: n=number of trials and and random p ~ Beta(a,b)\n",
    "\n",
    "n, a, b = 10, 1, 9\n",
    "x = stats.betabinom.rvs(n, a, b, size=7)\n",
    "\n",
    "k = np.arange(0, 10)\n",
    "fk = stats.betabinom.pmf(k, n, a, b)\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "ax.plot(k, fk, 'bo', ms=8, label='betabinom pmf')\n",
    "ax.vlines(k, 0, fk, colors='b', lw=5, alpha=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# contrastando com a binomial\n",
    "\n",
    "f2k = stats.binom.pmf(k, n, p=0.1)\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "ax.plot(k, fk, 'bo', ms=8, label='betabinom pmf')\n",
    "ax.vlines(k, 0, fk, colors='b', lw=5, alpha=0.5)\n",
    "ax.plot(k+0.2, f2k, 'ro', ms=8, label='binom pmf')\n",
    "ax.vlines(k+0.2, 0, f2k, colors='r', lw=5, alpha=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Distribuicao uniforme\n",
    "\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "x = np.linspace(0, 1, 100)\n",
    "ax.plot(x, stats.uniform.pdf(x),'r-', lw=5, alpha=0.6, label='uniform pdf')\n",
    "\n",
    "r = stats.uniform.rvs(size=1000)\n",
    "ax.hist(r, density=True, histtype='stepfilled', alpha=0.2)\n",
    "ax.legend(loc='best', frameon=False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exponential distribution\n",
    "r = stats.expon.rvs(scale=10, size=1000) # simulating a sample with lambda = 1/scale = 0.1\n",
    "x = np.linspace(0, 60, 100)\n",
    "\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "ax.plot(x, stats.expon.pdf(x, scale=10), 'r-', lw=5, alpha=0.6, label='expon pdf')\n",
    "ax.hist(r, density=True, histtype='stepfilled', alpha=0.2, bins=30)\n",
    "ax.legend(loc='best', frameon=False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1, 1)\n",
    "x = np.linspace(0, 3.5, 100)\n",
    "ax.plot(x, stats.pareto.pdf(x, b=4.5),'r-', lw=5, alpha=0.6, label='pareto pdf')\n",
    "r = stats.pareto.rvs(b=4.5, size=1000)\n",
    "ax.hist(r, density=True, histtype='stepfilled', alpha=0.2, bins=100)\n",
    "ax.legend(loc='best', frameon=False)\n",
    "plt.show()\n",
    "\n",
    "# Nao ficou bom, fazer uns graficos com varias amostras variando b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Distributions have a general form and a \"frozen\" form. \n",
    "\n",
    "The general form is stateless: you supply the distribution parameters as arguments to every call. \n",
    "\n",
    "The frozen form creates an object with the distribution parameters set. \n",
    "\n",
    "For example, you could evaluate the PDF of a normal(3, 4) distribution at the value 5.7 by\n",
    "```\n",
    "stats.norm.pdf(5.7, 3, 4)\n",
    "```    \n",
    "or by \n",
    "```\t\n",
    "mydist = stats.norm(3, 4)\n",
    "mydist.pdf(5.7)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "from scipy import stats\n",
    "A = stats.norm(3, math.sqrt(16)) # Declare A to be a normal random variable\n",
    "print A.pdf(4)       # f(3), the probability density at 3\n",
    "print A.cdf(2)       # F(2), which is also P(Y < 2)\n",
    "print A.rvs()        # Get a random sample from A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T01:01:26.185602Z",
     "start_time": "2020-07-04T01:01:26.170576Z"
    }
   },
   "source": [
    "## Main multivariate probability distributions \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T02:42:47.190647Z",
     "start_time": "2020-07-04T02:42:44.578632Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Density at [1.3, 2.7]:  0.0016828369534797917\n",
      "Density at 5 points:  [0.04826618 0.04259475 0.07475612 0.00950417 0.07022687]\n",
      "CDF at [1.3, 2.7]:  0.7395808611024745\n",
      "(500, 2)\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"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'pdf')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASEAAAEWCAYAAAApYiEOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAVUElEQVR4nO3de7AcZZ3G8e+zwQDGqFxCuIQgBRQptCQrx7gWtRaIQKBcI1bUULuKihXXhdq13N0CdRfxslXe2VphdaOi6MpNXSRquAS1CilXzUkqKIEgIUY5nEBAIIAXMPrbP6ZPdph0z5lL97w9c55P1anT0/1Oz29q6jzn7el++1VEYGaWyp+lLsDMZjaHkJkl5RAys6QcQmaWlEPIzJJyCJlZUg4hGwqSQtLR2fK+kr4laaekr6WuzfqzV+oCzHqwHJgPHBARu1IXY/1xT8iG0RHAzx1Ao8EhZMlI2ibpPZLulPSopC9K2ifb9s+StkualPS2pud8ALgIeKOkJyWdm6p+K4cPxyy1vwZOB34DfAv4F0m3Af8EnAL8AvjcVOOIeL+kAI6OiL9JUK+VzD0hS+3SiLgvIh4B/g04G3gD8MWIuCMifgNcnLJAq5ZDyFK7r2n5l8Ch2U/rehtRDiFL7fCm5YXAJLA9Z72NKIeQpXaepAWS9gfeC1wDXAu8RdJxkp4NvD9phVYph5CldiVwM7A1+/lwRNwA/DvwPWBL9ttGlHxTM0tF0jbg7RFxS+paLB33hMwsqaQhJOlySTsk3dG0bn9JayXdk/3er+C552Rt7pF0zuCqNrMyJT0ck/QK4EngyxHxomzdx4BHIuIjki4E9ouIC1qetz8wDowBAawHToiIRwf6Bsysb0l7QhFxK/BIy+plwBXZ8hXAa3OeejqwNiIeyYJnLbC0skLNrDJ1HLYxPyK2A0TEdkkH5bQ5jGdezDaRrduDpJXASoA5c+acsGjRopLLNbMp69evfzgi5nXznDqGUCeUsy73uDIiVgGrAMbGxmJ8fLzKusxmNEldX91ex7NjD0o6BCD7vSOnzQTPvKJ2AY0rbc1syNQxhFYDU2e7zgGuz2lzE3CapP2ys2enZevMbMikPkV/FfC/wLGSJrJ7w3wEOFXSPcCp2WMkjUn6PEA24vpDwLrs54PZOjMbMjPqiml/J2RWLUnrI2Ksm+fU8XDMzGYQh5CZJeUQMrOkHEJmlpRDyMyScgiZWVIOITNLyiFkZkk5hMwsKYeQmSXlEDKzpBxCZpaUQ8jMknIImVlSDiEzS8ohZGZJOYTMLCmHkJklVcsQknSspI1NP49LeldLm5Mk7Wxqc1Gqes2sd7Wcdywi7gYWA0iaBdwPXJfT9AcR8epB1mZm5aplT6jFKcC9EdH1pGpmVn/DEEIrgKsKtr1c0u2SbpD0wkEWZWblqHUISZoNvAb4Ws7mDcAREXE88GngmwX7WClpXNL4Qw89VF2xZtaTWocQcAawISIebN0QEY9HxJPZ8hrgWZIOzGm3KiLGImJs3rx51VdsZl2pewidTcGhmKSDJSlbXkLjvfx6gLWZWQlqeXYMQNKzaUwD/Y6mdX8LEBGfBZYD75S0C/gdsCJm0nSyZiOitiEUEb8FDmhZ99mm5UuBSwddl5mVq+6HY2Y24hxCZpaUQ8jMknIImVlSDiEzS8ohZGZJOYTMLCmHkJkl5RAys6QcQmaWlEPIzJJyCJlZUg4hM0vKIWRmSTmEzCwph5CZJeUQMrOkHEJmlpRDyMySqm0ISdom6WfZPPPjOdsl6T8kbZH0U0kvSVGnmfWntje6z5wcEQ8XbDsDOCb7eRnwmey3mQ2R2vaEOrAM+HI0/Ah4vqRDUhdlZt2pcwgFcLOk9ZJW5mw/DLiv6fFEtu4ZPA20Wb3VOYROjIiX0DjsOk/SK1q2K+c5e0x+6GmgzeqttiEUEZPZ7x3AdcCSliYTwOFNjxcAk4OpzszKUssQkjRH0typZeA04I6WZquBN2dnyf4C2BkR2wdcqpn1qa5nx+YD10mCRo1XRsSNLXPRrwHOBLYAvwXemqhWM+tDLUMoIrYCx+esb56LPoDzBlmXmZWvlodjZjZzOITMLCmHkJkl5RAys6QcQmaWlEPIzJJyCJlZUg4hM0vKIWRmSTmEzCwph5CZJeUQMrOkHEJmlpRDyMyScgiZWVK1vJ+QdeeMQ3xbpWFzw/bLUpdQG+4JmVlSDiEzS6p2ISTpcEnfl3SXpE2S/iGnzUmSdmZTRG+UdFGKWs2sf3X8TmgX8I8RsSGbcWO9pLURcWdLux9ExKsT1GdmJapdTygitkfEhmz5CeAucmZWNbPRULsQaibpBcCfAz/O2fxySbdLukHSC9vsw9NAm9VYbUNI0nOAbwDviojHWzZvAI6IiOOBTwPfLNqPp4E2q7dahpCkZ9EIoK9GxP+0bo+IxyPiyWx5DfAsSQcOuEwzK0HtQkiNaVe/ANwVEZ8qaHNw1g5JS2i8j18PrkozK0sdz46dCLwJ+Jmkjdm69wILYfcsrMuBd0raBfwOWJHNyGpD7ulFCwq3zd48McBKbFBqF0IRcRugadpcClw6mIqsX+2CpYr9OKyGS+1CyIZbWYFTRQ0Op3pyCFlf6hA6nWqu1YFUHw4h69owBU8RB1J9OISsY/2Gz86j9i6pkmLPu/eprp/jQErLIWRt9Ro8gwicTl6321Caer8Oo8FxCFmuXsKn3+B54oi2J0UBmPvL7q7E6DWUHEaD4xCyPXQTQN0GTydB0+vzOwmo5no7CSSHUfUcQrZb2eHTb+B0q/X1pgulqffgMErLIWRA5wFUZvg8tfDpjtq1s/evZndUR7tA6jaMHETlcghZRwE0XfhMFzxlBE6n+80Lpk4CaedRezuIEnAIzWBl9H7ahU+nwfOCBd3f52nbRPFtWZpft10g5YVRp70iB1F5HELWVi8B1C58egmcTvZTFEpTtRSFUT+9IgdRORxCM1Q/h2BVhs+pB2/OXb/2gUVtn9e8/7xAKgqj6XpFDqLqOYRmoEEF0HTBUxQ43bTNC6ep1y0Ko256RQ6i6jmEZpjUAdRN8HSieX+tgVQURg6ienEI2TNUFUCdhM/y526Yts3XH39J4bap18gLo0EEkfXGITSDlD36vYwA6iR4itoXBdKpB2/uK4hssGp3j2lLp5teUL8BtPy5G7oOoG72kfe6efXlvY+iXt9010qNwi1OUmgbQpKeK+monPUvrq6k3a+xVNLdkrZIujBn+96Srsm2/zibo8wS6TaAytRNEFn9FIaQpDcAm4FvZHPCv7Rp85eqLErSLOAy4AzgOOBsSce1NDsXeDQijgYuAT5aZU1WjrIDqNv9lnWdkpWnXU/ovcAJEbEYeCvwFUmvy7ZVPTJxCbAlIrZGxNPA1cCyljbLgCuy5a8Dp0xNA2TVqmoIhs1M7b6YnhUR2wEi4ieSTga+LWkBUPX0OocB9zU9ngBeVtQmInZJ2gkcADzc3EjSSmAlwMKFC6uq18x61K4n9ETz90FZIJ1EowdSOPd7SfJ6NK3B10kbTwNtVnPtQuidwJ81fxcTEU8AS4G3V1zXBHB40+MFwGRRG0l7Ac8DHqm4LqP97TOm0+46n35UtV+rXmEIRcTtEXEPcK2kC9SwL/Ap4O8qrmsdcIykIyXNBlYAq1varAbOyZaXA9/zLKzp5A2RKBrvVXZgFO0v7/Xbjb63NDq5TuhlNHocP6QRDpM0pmquTETsAs4HbgLuAq6NiE2SPijpNVmzLwAHSNoCvBvY4zS+dafoiuC8K4g77Q1VHUT9BlDe+ygaWe8rpqvRyRXTf6Ax3/u+wD7ALyLiT5VWBUTEGmBNy7qLmpZ/D7y+6jpGyezNE5VeULdtYl7uKfC1DyzKvWanOUC6OXU/XYD1E0D98Nix3nQSQuuA64GX0jj79F+SlkfE8korsySed+9TuVcGz/1l7HEl8d6/mr3H6fqpP/bWMJoKhqILCMvoGRX1uro5BHMvaPA6ORw7NyIuiog/RMQDEbGMRijZEOrkv3W3h2V5PYqiP/y1Dyya9t5A3Wq3z6IeUNmHYe4F9W7anlBEjOes+0o15dgg9HNYltcjgu56RZDfa+lkmEWnAVYUgkWHYA6gdDyK3nIVHZZB+yCCPa+obg6EdsMm+u0htTvs6jZ8wAE0KA6hGaqT3tDUH2HRd0SQP+K8KIxgz6DoZyxXJ9/1tPvyud8AsnI4hGawTg/LpusVQfswguLxZlVctzPdWa/pJkV0D2iwHEIz3NQfUz+9ImgfRrBnMJQ5CLbTU+1lhA84gMrmEDKgu14RTB9G0H5OskHd0bCT+em7OfRyAJXPIWS7dXPWbLowgj0DYBBz03cSOlMcPvXgELJn6PTwbErzH/J0tz8tCohewqmbsGnWyxfODqBqOYQsV7dhBN0FUrNeA6VTvZ7pcvgMhkPI2uoljGDPP/xuQqlf/Zxed/AMnkPIOtL8x9nL1dbTBUOnIVXV9TsOn3QcQta1fgMpT4qLAx089eAQsr60/iHXee4th049OYSsVHUJJQfO8HAIWaU6CYNegsohMzocQpacA2Vmq1UISfo48FfA08C9wFsj4rGcdtuAJ4A/ArsiYmyQdZpZeTq5s+IgrQVeFBEvBn4OvKdN25MjYrEDyGy41SqEIuLmbKYNgB/RmG/MzEZYrUKoxduAGwq2BXCzpPXZNM+FJK2UNC5p/KGHer+BlplVY+DfCUm6BTg4Z9P7IuL6rM37gF3AVwt2c2JETEo6CFgraXNE3JrXMCJWAasAxsbGPDmiWc0MPIQi4lXttks6B3g1cErRjKoRMZn93iHpOmAJkBtCZlZvtTock7QUuAB4TUT8tqDNHElzp5aB04A7BlelmZWpViEEXArMpXGItVHSZwEkHSppajbW+cBtkm4HfgJ8JyJuTFOumfWrVtcJRcTRBesngTOz5a3A8YOsy8yqU6sQst7csP2y1CWY9axuh2NmNsM4hMwsKYeQmSXlEDKzpBxCZpaUQ8jMknIImVlSDiEzS8ohZGZJOYTMLCmHkJkl5RAys6QcQmaWlEPIzJJyCJlZUg4hM0vKIWRmSdUuhCRdLOn+7B7TGyWdWdBuqaS7JW2RdOGg6zSzctT19q6XRMQnijZKmgVcBpwKTADrJK2OiDsHVaCZlaN2PaEOLQG2RMTWiHgauBpYlrgmM+tBXUPofEk/lXS5pP1yth8G3Nf0eCJbtwdPA21Wb0lCSNItku7I+VkGfAY4ClgMbAc+mbeLnHVFs7WuioixiBibN29eae/BzMqR5Duh6aaCniLpc8C3czZNAIc3PV4ATJZQmpkNWO0OxyQd0vTwLPKneF4HHCPpSEmzgRXA6kHUZ2blquPZsY9JWkzj8Gob8A5oTAUNfD4izoyIXZLOB24CZgGXR8SmVAWbWe9qF0IR8aaC9bungs4erwHW5LU1s+FRu8MxM5tZHEJmlpRDyMyScgiZWVIOITNLyiFkZkk5hMwsKYeQmSXlEDKzpBxCZpaUQ8jMknIImVlSDiEzS8ohZGZJOYTMLCmHkJkl5RAys6QcQmaWVK1u7yrpGuDY7OHzgcciYnFOu23AE8AfgV0RMTawIs2sVLUKoYh449SypE8CO9s0PzkiHq6+KjOrUq1CaIokAW8AXpm6FjOrVl2/E/pL4MGIuKdgewA3S1ovaeUA6zKzkg28JyTpFuDgnE3vi4jrs+Wzgava7ObEiJiUdBCwVtLmiLi14PVWAisBFi5c2EflZlYFReRO4Z6MpL2A+4ETImKig/YXA09GxCemazs2Nhbj4+P9F2lmuSSt7/ZEUR0Px14FbC4KIElzJM2dWgZOI3+qaDMbAnUMoRW0HIpJOlTS1Gyr84HbJN0O/AT4TkTcOOAazawktTs7FhFvyVm3ewroiNgKHD/gssysInXsCZnZDOIQMrOkHEJmlpRDyMyScgiZWVIOITNLyiFkZkk5hMwsKYeQmSXlEDKzpBxCZpaUQ8jMknIImVlSDiEzS8ohZGZJOYTMLCmHkJkl5RAys6QcQmaWVJIQkvR6SZsk/UnSWMu290jaIuluSacXPP9IST+WdI+kayTNHkzlZla2VD2hO4DXAc+YsFDScTRm23ghsBT4T0mzcp7/UeCSiDgGeBQ4t9pyzawqSUIoIu6KiLtzNi0Dro6IpyLiF8AWYElzg2ye+lcCX89WXQG8tsp6zaw6dZvy5zDgR02PJ7J1zQ4AHouIXW3a7NY8DTTwlKRRnCjxQODh1EVUYFTfF4zuezu22ydUFkIdzjm/x9Ny1rXOU91Jm//fELEKWJXVNN7tFLXDwO9r+Izqe5PU9TzrlYVQRLyqh6dNAIc3PV4ATLa0eRh4vqS9st5QXhszGxJ1O0W/GlghaW9JRwLH0JjqebeICOD7wPJs1TlAUc/KzGou1Sn6syRNAC8HviPpJoCI2ARcC9wJ3AicFxF/zJ6zRtKh2S4uAN4taQuN74i+0OFLryrxbdSJ39fwGdX31vX7UqNjYWaWRt0Ox8xshnEImVlSIx9C/Q4RGRaSLpZ0v6SN2c+ZqWvqh6Sl2eeyRdKFqespi6Rtkn6WfUZdn86uE0mXS9rRfO2dpP0lrc2GVK2VtN90+xn5EKL/ISLD5JKIWJz9rEldTK+yz+Ey4AzgOODs7PMaFSdnn9GwXyf0JRp/O80uBL6bDan6bva4rZEPoX6GiFgyS4AtEbE1Ip4GrqbxeVmNRMStwCMtq5fRGEoFHQ6pGvkQauMw4L6mx22HfwyJ8yX9NOsmT9sNrrFR/GymBHCzpPXZkKJRMz8itgNkvw+a7gl1GzvWkwqHiNRKu/cJfAb4EI338CHgk8DbBlddqYbus+nCiRExKekgYK2kzVmPYsYaiRCqcIhIrXT6PiV9Dvh2xeVUaeg+m05FxGT2e4ek62gceo5SCD0o6ZCI2C7pEGDHdE+YyYdj0w4RGSbZBz7lLBpfyA+rdcAx2c3rZtM4gbA6cU19kzRH0typZeA0hvtzyrOaxlAq6HBI1Uj0hNqRdBbwaWAejSEiGyPi9IjYJGlqiMgumoaIDKmPSVpM47BlG/COtOX0LiJ2STofuAmYBVyeDekZdvOB6xq3xGIv4MqIuDFtSb2TdBVwEnBgNgzr/cBHgGslnQv8Cnj9tPvxsA0zS2kmH46ZWQ04hMwsKYeQmSXlEDKzpBxCZpaUQ8hqTdKNkh6TNMwXX1obDiGru48Db0pdhFXHIWS1IOml2eDbfbIrizdJelFEfBd4InV9Vp2Rv2LahkNErJO0GvgwsC/w3xExakMaLIdDyOrkgzTGjf0e+PvEtdiA+HDM6mR/4DnAXGCfxLXYgDiErE5WAf8KfBX4aOJabEB8OGa1IOnNwK6IuDK7x/QPJb0S+ACwCHhONlL73Ii4KWWtVi6PojezpHw4ZmZJOYTMLCmHkJkl5RAys6QcQmaWlEPIzJJyCJlZUv8HgBl6s39oZxAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Multivariate Gaussian distribution\n",
    "import numpy as np\n",
    "import scipy.stats as stats\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# using the frozen method\n",
    "# First, create an object \"containing\" the distribution. Later, extract samples, density plots, etc\n",
    "# Mean vector\n",
    "mu = [0.0, 0.0]\n",
    "# Covariance matrix\n",
    "sigma = [[4.0, 0.0], [0.0, 1.0]]\n",
    "# Distribution object (frozen method)\n",
    "distrib = stats.multivariate_normal(mean=mu, cov=sigma)\n",
    "\n",
    "# Evaluating the density in the point (1.3, 2.7)\n",
    "print(\"Density at [1.3, 2.7]: \", distrib.pdf([1.3, 2.7]) )\n",
    "\n",
    "# Evaluating at n=5 2-dim points\n",
    "x = np.array([[0, 1], [1, 1], [0.5, 0.25], [1, 2], [-1, 0]])\n",
    "\n",
    "dens = distrib.pdf(x)\n",
    "print(\"Density at 5 points: \", dens) \n",
    "\n",
    "# Evaluating the CDF of the multivariate normal\n",
    "print(\"CDF at [1.3, 2.7]: \", distrib.cdf([1.3, 2.7]))\n",
    "\n",
    "# sampling 500 2-dim vectors from the population object pop ~ N_2(mu, sigma)\n",
    "# using 12345 as a seed\n",
    "samplex = distrib.rvs(size=500, random_state=12345) \n",
    "print( samplex.shape )\n",
    "\n",
    "# Scatter plot with the sample generated \n",
    "plt.scatter(samplex[:,0], samplex[:,1])\n",
    "plt.axis('equal')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "# Density plot \n",
    "x1, x2 = np.mgrid[-5:5:.01, -3:3:.01]\n",
    "pos = np.dstack((x1, x2))\n",
    "z = distrib.pdf(pos)\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111,aspect='equal')\n",
    "ax.contourf(x1,x2,z)\n",
    "ax.set_xlim(-10,10)\n",
    "ax.set_ylim(-10,10)\n",
    "ax.set_xlabel('x1')\n",
    "ax.set_ylabel('x2')\n",
    "ax.set_title('pdf')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T19:32:52.950040Z",
     "start_time": "2020-07-04T19:32:52.632890Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\assun\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:15: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
      "  from ipykernel import kernelapp as app\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": [
    "from mpl_toolkits import mplot3d\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import multivariate_normal\n",
    "x = np.linspace(-1, 3, 100)\n",
    "y = np.linspace(0, 4, 100)\n",
    "X, Y = np.meshgrid(x, y)\n",
    "pos = np.dstack((X, Y))\n",
    "mu = np.array([1, 2])\n",
    "cov = np.array([[.5, .25],[.25, .5]])\n",
    "rv = multivariate_normal(mu, cov)\n",
    "Z = rv.pdf(pos)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "ax.plot_surface(X, Y, Z)\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T19:32:58.240465Z",
     "start_time": "2020-07-04T19:32:57.809617Z"
    }
   },
   "outputs": [
    {
     "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": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import multivariate_normal\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "# Create grid and multivariate normal\n",
    "x = np.linspace(-10,10,500)\n",
    "y = np.linspace(-10,10,500)\n",
    "X, Y = np.meshgrid(x,y)\n",
    "pos = np.empty(X.shape + (2,))\n",
    "pos[:, :, 0] = X \n",
    "pos[:, :, 1] = Y\n",
    "# Create a frozen RV object\n",
    "mean = np.array([1, 2])\n",
    "cov  = np.array([[3,0],[0,15]])\n",
    "rv = multivariate_normal(mean,cov)\n",
    "# Make a 3D plot\n",
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "ax.plot_surface(X, Y, rv.pdf(pos),cmap='viridis',linewidth=0)\n",
    "ax.set_xlabel('X axis')\n",
    "ax.set_ylabel('Y axis')\n",
    "ax.set_zlabel('Z axis')\n",
    "plt.show()"
   ]
  },
  {
   "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.7.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
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}