{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementing CDFs\n",
    "\n",
    "Copyright 2019 Allen Downey\n",
    "\n",
    "BSD 3-clause license: https://opensource.org/licenses/BSD-3-Clause"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import seaborn as sns\n",
    "sns.set_style('white')\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import inspect\n",
    "\n",
    "def psource(obj):\n",
    "    \"\"\"Prints the source code for a given object.\n",
    "\n",
    "    obj: function or method object\n",
    "    \"\"\"\n",
    "    print(inspect.getsource(obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constructor\n",
    "\n",
    "For comments or questions about this section, see [this issue](https://github.com/AllenDowney/EmpyricalDistributions/issues/11).\n",
    "\n",
    "The `Cdf` class inherits from `pd.Series`.  The `__init__` method is essentially unchanged, but it includes a workaround for what I think is bad behavior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def __init__(self, *args, **kwargs):\n",
      "        \"\"\"Initialize a Pmf.\n",
      "\n",
      "        Note: this cleans up a weird Series behavior, which is\n",
      "        that Series() and Series([]) yield different results.\n",
      "        See: https://github.com/pandas-dev/pandas/issues/16737\n",
      "        \"\"\"\n",
      "        if args or ('index' in kwargs):\n",
      "            super().__init__(*args, **kwargs)\n",
      "        else:\n",
      "            underride(kwargs, dtype=np.float64)\n",
      "            super().__init__([], **kwargs)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from empiricaldist import Cdf\n",
    "\n",
    "psource(Cdf.__init__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create an empty `Cdf` and then add elements.\n",
    "\n",
    "Here's a `Cdf` that representat a four-sided die."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "d4 = Cdf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "d4[1] = 1\n",
    "d4[2] = 2\n",
    "d4[3] = 3\n",
    "d4[4] = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "1    1\n",
       "2    2\n",
       "3    3\n",
       "4    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a normalized `Cdf`, the last probability is 1.\n",
    "\n",
    "`normalize` makes that true.  The return value is the total probability before normalizing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def normalize(self):\n",
      "        \"\"\"Make the probabilities add up to 1 (modifies self).\n",
      "\n",
      "        :return: normalizing constant\n",
      "        \"\"\"\n",
      "        total = self.ps[-1]\n",
      "        self /= total\n",
      "        return total\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf.normalize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.normalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the Cdf is normalized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "1    0.25\n",
       "2    0.50\n",
       "3    0.75\n",
       "4    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Properties\n",
    "\n",
    "For comments or questions about this section, see [this issue](https://github.com/AllenDowney/EmpyricalDistributions/issues/2).\n",
    "\n",
    "In a `Cdf` the index contains the quantities (`qs`) and the values contain the probabilities (`ps`).\n",
    "\n",
    "These attributes are available as properties that return arrays (same semantics as the Pandas `values` property)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.qs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.ps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sharing\n",
    "\n",
    "For comments or questions about this section, see [this issue](https://github.com/AllenDowney/EmpyricalDistributions/issues/12).\n",
    "\n",
    "Because `Cdf` is a `Series` you can initialize it with any type `Series.__init__` can handle.\n",
    "\n",
    "Here's an example with a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>0.666667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "a    0.333333\n",
       "b    0.666667\n",
       "c    1.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = dict(a=1, b=2, c=3)\n",
    "cdf = Cdf(d)\n",
    "cdf.normalize()\n",
    "cdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example with two lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "1    0.25\n",
       "2    0.50\n",
       "3    0.75\n",
       "4    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qs = [1,2,3,4]\n",
    "ps = [0.25, 0.5, 0.75, 1.0]\n",
    "d4 = Cdf(ps, index=qs)\n",
    "d4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can copy a `Cdf` like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "1    0.25\n",
       "2    0.50\n",
       "3    0.75\n",
       "4    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4_copy = Cdf(d4)\n",
    "d4_copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, you have to be careful about sharing.  In this example, the copies share the arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.index is d4_copy.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.ps is d4_copy.ps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can avoid sharing with `copy=True`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "1    0.25\n",
       "2    0.50\n",
       "3    0.75\n",
       "4    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4_copy = Cdf(d4, copy=True)\n",
    "d4_copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.index is d4_copy.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.ps is d4_copy.ps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or by calling `copy` explicitly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "1    0.25\n",
       "2    0.50\n",
       "3    0.75\n",
       "4    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4_copy = d4.copy()\n",
    "d4_copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.index is d4_copy.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.ps is d4_copy.ps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Displaying CDFs\n",
    "\n",
    "For comments or questions about this section, see [this issue](https://github.com/AllenDowney/EmpyricalDistributions/issues/13).\n",
    "\n",
    "`Cdf` provides `_repr_html_`, so it looks good when displayed in a notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def _repr_html_(self):\n",
      "        \"\"\"Returns an HTML representation of the series.\n",
      "\n",
      "        Mostly used for Jupyter notebooks.\n",
      "        \"\"\"\n",
      "        df = pd.DataFrame(dict(probs=self))\n",
      "        return df._repr_html_()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf._repr_html_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Cdf` provides `plot`, which plots the Cdf as a line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def plot(self, **options):\n",
      "        \"\"\"Plot the Cdf as a line.\n",
      "\n",
      "        :param options: passed to plt.plot\n",
      "\n",
      "        :return:\n",
      "        \"\"\"\n",
      "        underride(options, label=self.name)\n",
      "        plt.plot(self.qs, self.ps, **options)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf.plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorate_dice(title):\n",
    "    \"\"\"Labels the axes.\n",
    "    \n",
    "    title: string\n",
    "    \"\"\"\n",
    "    plt.xlabel('Outcome')\n",
    "    plt.ylabel('CDF')\n",
    "    plt.title(title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAESCAYAAAAVLtXjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3dd4BU5dn38S9LW8rSq/R6AdKkSBEVY6+A6BMfEwsJMZiYoomAsQTLYyEaY2KMQaPRhGgMC4ii2I0KYo3ssrgXLL13WGCXbTPvHzPknRBgKXt2dmZ+n3+Yc+6ZOdfh7P72zD1nrqkWDocREZHUkhbvAkREpPIp/EVEUpDCX0QkBSn8RURSkMJfRCQFKfxFRFJQjXgXIFLZzGwCcCNQEwgDXwK3u/uagLY3CJjh7h2j227k7g8GsS2Ro6Xwl5RiZg8D/YBL3H2tmaUB3wY+NrMh7r4uyO27+5NBPr/I0VL4S8ows7bABKCdu+8EcPcQ8LyZDQRuA35oZquAPwNnA+2B5939zuhzXArcAdQCCoCfu/vHh9jWjcDNwG4gO2b9FKCZu99kZm2Ax6PbqAm86O73V/iOixyC5vwllQwBvj4Q/Ad5GxgRs1zf3U8HhgM/N7NOZtYNuB+4yN1PAW4AZppZvdgnMrP+wBTgDHcfDBQfpp6/AM+4+0DgVOAcM/uf4989kaOn8JdUU/Mw62sTmf8/4GUAd18PbAGaAOcCrYF3zOwrYDoQAroe9FxnA2+6+6bo8rSDNxb9g3EmcG/0uRYSeQXQ/zj2SeSYadpHUslCoJuZtYoJ5gPOAhbELBfG3A4D1YDqwDvu/s0DA2bWDthwiG1Vi7ldeojx6tH7DHf3guhzNQP2H+W+iJwQnflLyoiexf8WeCE63w6AmY0DxgIPlfMU7wDnmVmP6OMuArKAOgfd783o/dpGl68/RC35RP4Y3RJ9rkbAfGDUse2VyPFR+EtKcffbgL8CL5vZYjNbBpwDDHP31eU8dgmRef4XzWwRcC9wmbvvPeh+2cBEItNDnwPph3nKq4GhZpYNfAK84O7TT2D3RI5aNbV0FhFJPTrzFxFJQQp/EZEUpPAXEUlBCn8RkRSUENf5DxkyJNymTZvy7ygiIv+Wk5Ozzd2bH2osIcK/TZs2zJw5M95liIgkFDM77OXLmvYREUlBCn8RkRSk8BcRSUEKfxGRFKTwFxFJQQp/EZEUFFj4m9kQM3v/EOsvNbPPzOxjM/teUNsXEZHDCyT8zWwi8DQHtbI1s5rAo8B5RL7F6AYzaxVEDSIiiayguJSXPltL/v6SQJ4/qDP/5cDlh1jfE8hz953uXgx8BJweUA0iIglpQd42LvjNh0zMzGLppj2BbCOQ8Hf3TOBQf64aALtjlvcADYOoQUQk0ewuLGFyZhZXP/0JadXgxRuGMqhjk0C2VdntHfKBjJjlDGBXJdcgIlLlvLVkM3fMzmbrniK+f2Znbj6nO+k1qwe2vcoO/6+JfIF2E2AvcAbwcCXXICJSZWzbW8SUOTm8mrWRHq0yeOraQfRt2yjw7VZK+JvZ1UB9d59mZrcAbxCZcnom+qXaIiIpJRwOM/ur9dz9yhIKisr42bndmTCyCzWrV84V+IGFv7uvAoZGb/8tZv0rwCtBbVdEpKrbsKuQ22dl855v5ZT2jZg6ti/dWmaU/8AKlBAtnUVEkkEoFGb6p2t46PVcykJh7rqkF9cN70j1tGqVXovCX0SkEqzcto9JmVl8unIHI7o244HL+9CuSd241aPwFxEJUGlZiKc/Wsmjby2ldo00pl7RlysHtqVatco/24+l8BcRCciSDflMzFzE4vX5nH9yS+4d1ZsWDdLLf2AlUPiLiFSwotIyHn83jz+8v5xGdWvyxLcGcGHvVnE/24+l8BcRqUBfrN7JpMws8rbs5fIBbbjz4l40rlcr3mX9F4W/iEgF2FdUysNvOn9esIqTGtbhz+MGM9JaxLusw1L4i4icoA+XbeW2mdms21nIdcM6cOsFPahfu2rHa9WuTkSkCttdUMJ9c5fwjy/W0bl5Pf4xYRiDA2rEVtEU/iIix2He4k3c+fJiduwr5gcju/Djs7sF2oitoin8RUSOwZY9+5kyJ4fXsjfRq3UDnr1+ML3bJF5neoW/iMhRCIfDzPxyPfe8uoTCkjJuPd+44YzOldaIraIp/EVEyrFuZwG/mLWYD5ZuZVCHxjw4ti9dW9SPd1knROEvInIYoVCYv36ymodezyUM3H3ZyVwztANpcWjEVtEU/iIih7B8614mzcji89U7OaN7c+4f05u2jePXiK2iKfxFRGKUlIWY9sEKHntnGXVqVufhK/sxdkCbKtWaoSIo/EVEohav382kzCxyNuRzUZ9WTLnsZFpkVI1GbBVN4S8iKW9/SRm/fWcZf/xgBU3q1eLJbw/ggt6t411WoAIJfzNLA54A+gFFwHh3z4sZnwT8L5APTHX3V4OoQ0SkPJ+t2sGkzCxWbN3HlQPbcsfFvWhYt2a8ywpcUGf+o4F0dx9mZkOBR4BRAGbWB7gaGBK97wIze9fdCwKqRUTkv+wtKmXqvFye/3g1bRvX4S/fPZXTuzWPd1mVJqjwHwHMA3D3hWY2KGasJ/C+u+8HMLNlQF9gYUC1iIj8h38u3covZmazYXch1w/vyK3nG/WqeCO2ihbU3jYAdscsl5lZDXcvBbKB28wsA6gFDAemBVSHiMi/7Soo5p5XlzDzy/V0aV6PGROGMbBDYjRiq2hBhX8+kBGznBYNftz9azN7HHgdyAM+AbYFVIeICACvZW/krpcXs6ughJvO6spN3+iaUI3YKlpQ4T8fuBR4KTrnn31gwMyaA83cfYSZNQTeBBYHVIeIpLgt+fu56+Uc5uVsonebBjz3nVM5+aTEa8RW0YIK/1nAuWa2AKgGjDOzW4ic6b8CdDazz4Bi4FZ3LwuoDhFJUeFwmH98sY77Xl1CUWmIyRf2YPyITtRI0EZsFS2Q8Hf3EDDhoNW5Mbe/H8R2RUQA1u4o4LaZ2XyUt41TOzbhwbF96Nw8sRuxVbTUentbRJJaWSjM8x+vYuo8J60a3Du6N986tX1SNGKraAp/EUkKeVv2MHFGFl+u2cVIa87/jelDm0Z14l1WlaXwF5GEVlIW4o//XM5v38mjXu3qPPrNfozun3yN2Cqawl9EElb2ut3cOmMRuZv2cEnf1ky57GSa1a8d77ISgsJfRBLO/pIyHn17KU99sIJm9Wsz7ZqBnHdyq3iXlVAU/iKSUD5ZsZ3JM7NZuW0fVw1ux20X9aRhneRvxFbRFP4ikhD27C/hoXm5/HXhGto1qcP08UM4rWuzeJeVsBT+IlLlvZe7hdtnZbMxfz/fHdGJn53Xnbq1FF8nQv97IlJl7dhXzL2vLmHWv9bTrUV9Mm8czoD2jeNdVlJQ+ItIlRMOh3k1ayNT5uSwu7CEn5zdjR+c1YXaNVK3EVtFU/iLSJWyOX8/t89azNtfb6Zv24ZM/94QerRqEO+yko7CX0SqhHA4zN8/W8v/vfY1xaUhbr+oJ+NO66hGbAFR+ItI3K3ZXsDkmVksWL6dIZ2a8NDYvnRsVi/eZSU1hb+IxE1ZKMyz81fy8JtOzbQ07h/Th6sGt1Mjtkqg8BeRuPBNe5iUmcVXa3dxdo8W3DemN60bqhFbZVH4i0ilKi4N8cT7efz+vTwy0mvy2FX9uazfSWrEVskU/iJSaRat3cXEGVn45j2M6n8Sd13Si6ZqxBYXCn8RCVxhcRm/fsv500craZGRztPXDuKcXi3jXVZKCyT8zSwNeALoBxQB4909L2b858D/AiHgfnefFUQdIhJ/Hy/fzuSZWazeXsDVQ9oz+cIeNEhXI7Z4C+rMfzSQ7u7DzGwo8AgwCsDMGgE/BroC9YCviHzhu4gkkfz9JTzwWi4vfLqGDk3r8sL3hjKsS9N4lyVRQYX/CGAegLsvNLNBMWP7gNVEgr8ekbN/EUkiby/ZzB2zF7Nlz35uOKMzN5/TnTq11JqhKgkq/BsAu2OWy8yshruXRpfXAkuA6sADAdUgIpVs+94i7n5lCXMWbaBHqwz+eM1A+rVrFO+y5BCCCv98ICNmOS0m+C8EWgOdostvmNl8d/80oFpEJGDhcJg5izYwZU4Oe4tKufmc7tw4sgu1aqg1Q1UVVPjPBy4FXorO+WfHjO0ECoEidw+b2S5ApwYiCWrj7kLumLWYd3K30L9dI6Ze0ZfuLTPKf6DEVVDhPws418wWANWAcWZ2C5Dn7nPM7BxgoZmFgI+AtwKqQ0QCEgqFeeGzNTzwWi5loTB3XtKL64d3pLpaMySEQMLf3UPAhINW58aM/xL4ZRDbFpHgrdq2j8kzs1i4YgendW3KA2P60r5p3XiXJcdAH/ISkaNWWhbimfkreeTNpdSqkcZDY/vwP4PaqTVDAlL4i8hR+XpjPpMys8hat5tze7XkvtG9adkgPd5lyXFS+IvIERWVlvH795bzxHt5NKxTk8evPoWL+7TW2X6CU/iLyGF9uWYnk2ZksWzLXi4/pQ13XtKLxvVqxbssqQAKfxH5LwXFpTzy5lKemb+S1g3SeXbcYM6yFvEuSyqQwl9E/sP8vG1MnpnF2h2FXDO0AxMvMDLUiC3pKPxFBIDdhSXcP/dr/v75Wjo1q8ffbxjKkM5qxJasFP4iwps5m7hj9mK27ytmwpld+Ok53UivqUZsyUzhL5LCtu4pYsorOczN2kiPVhn86brB9GnbMN5lSSVQ+IukoHA4zOyv1nP3K0soKCrj5+d15/tndqFmdTViSxUKf5EUs35XIbfPyuZ938qA9pFGbF1bqBFbqlH4i6SIUCjM9E9W8+DruYSBKZf24pphasSWqhT+Iilgxda9TM7M5tNVOzi9WzPuH9OHdk3UiC2VKfxFklhpWYinPlzJo28vJb1GGr+6oi9XDGyr1gyi8BdJVks25DMxcxGL1+dz/sktuXdUb1qoEZtEKfxFksz+kjIefzePJ/+5nEZ1a/GHbw3gwj6t412WVDEKf5Ek8sXqHUyckcXyrfsYO6Atd17Sk0Z11YhN/pvCXyQJ7Csq5VdvOM99vIqTGtbhue+cypndm8e7LKnCFP4iCe6DpVu5bWY2G3YXcu3QDtx6QQ/q19avthxZID8hZpYGPAH0A4qA8e6eFx3rD/wm5u5DgdHuPi+IWkSS1e6CEu6du4QZX6yjc/N6vPT9YQzu2CTeZUmCCOr0YDSQ7u7DzGwo8AgwCsDdvwJGApjZlcAGBb/IsZm3eCN3vpzDjn3F/GBkF358thqxybEJKvxHAPMA3H2hmQ06+A5mVg+4GzgjoBpEks6WPfv55cs5vL54E71aN+DZ6wfTu40ascmxCyr8GwC7Y5bLzKyGu5fGrPsu8A933xZQDSJJIxwOk/nleu59dQmFJWXcer5xwxmd1YhNjltQ4Z8PxHaKSjso+AG+BVwR0PZFksbaHQX8YlY2Hy7bxqAOjXlwbF+6tqgf77IkwQUV/vOBS4GXonP+2bGDZtYQqO3uawPavkjCC4XCPP/xKqa+4VQD7hl1Mt8e0oE0NWKTChBU+M8CzjWzBUA1YJyZ3QLkufscoDuwKqBtiyS8vC17mZyZxeerd3JG9+bcP6Y3bRurEZtUnEDC391DwISDVufGjH9G5IogEYlRUhZi2gcreOztZdSpVZ1HruzH5QPaqBGbVDh9EkSkili8fjcTZ2SxZGM+F/Vpxd2X9aZ5Ru14lyVJSuEvEmf7S8p47J1lTPtgBU3q1eLJbw/ggt5qxCbBUviLxNFnq3YwaUYWK7bt48qBbbnj4l40rFsz3mVJClD4i8TB3qJSps7L5fmPV9O2cR3+8t1TOb2bGrFJ5VH4i1Sy930Lt89azIbdhYw7rSM/P8+op0ZsUsn0EydSSXbuK+beuUuY+eV6uraoz4wJwxnYoXG8y5IUpfAXCVg4HOb1xZu46+XF7Coo4Uff6MpN3+hK7RpqxCbxc8TGIGY2I+b2hcGXI5JctuTvZ8Jfv+AH07+kdcM6zLlpBD87zxT8Enflnfk3jbl9K/B6gLWIJI1wOMw/Pl/HvXOXUFwaYvKFPRg/ohM11IhNqohjmfbRRwxFjsLaHQXcNjObj/K2cWrHJjw4tg+dm6sRm1Qt5YV/NTOrSWR66MDtagDuXhx0cSKJpCwU5rkFq/jVG071tGrcO7o33zq1vRqxSZVUXvh3AJz/f9a/NPpvGOgcVFEiiWbZ5j1MysziyzW7GGnNuX9MH05qVCfeZYkc1hHD3907VVYhIomopCzEk+8v53fv5lGvdnV+883+jOp/khqxSZVX7py/mV0MfBNoBqwDXnD394IuTKSqy1q3i4kzssjdtIdL+rZmymUn06y+GrFJYjhi+JvZD4ELgceAzUSmgW43s27uPq0S6hOpcvaXlPHoW0t56sMVNKtfm2nXDOS8k1vFuyyRY1Lemf+3gNPdvSy6nGVmbwJvAgp/STkLV2xncmYWq7YXcNXgdtx2UU8a1lEjNkk85YV/cUzwA+DuRWZ28PfxiiS1PftLePD1XKZ/soZ2TeowffwQTuvaLN5liRy38sI/dJj1ejdLUsZ7uVv4xaxsNufvZ/yITtxyXnfq1lJnFEls5f0ED4x+D2+sakDPIz3IzNKAJ4B+QBEw3t3zYsYvBH4ZXfwS+KG7h4+lcJGg7dhXzD2v5DD7qw10a1GfJ24czint1YhNkkN54d8POB94FygG2gO9Kb/Nw2gg3d2HmdlQ4BFgFICZZQC/Aka6+zYzm0jkSqKtx70XIhUoHA7zatZGpszJYXdhCT85uxs/OKuL+vFIUimv0ch1wLnAendfDayNLl9TzuNGAPMA3H0hMChmbDiQDTxiZh8Cm91dwS9Vwqbd+/ne81/woxf+RZvGdXj1xyO4+dzuCn5JOuWF/0XAle5eAODuq4hc839ZOY9rAOyOWS4zswOvMpoBZwGTiFxG+lMz636MdYtUqHA4zAufruHcX/+TD5dt5faLejLzxuH0aNUg3qWJBKK8aZ99B8/Fu3uJme0p53H5QEbMcpq7H7hCaDvwmbtvAjCzD4D+/P/WESKVavX2fUzOzObjFdsZ0qkJD43tS8dm9eJdlkigygv/AjPr7O4rDqwws85EevscyXzgUuCl6Jx/dszYF0BvM2sG7AKGAk8dc+UiJ6gsFObZ+St5+E2nZloa94/pw1WD26kRm6SE8sJ/EjDbzN4BVhB5w/d8Iu8FHMks4NzolULVgHFmdguQ5+5zzOw24I3ofV9y98XHvQcix8E37WFiZhaL1u7i7B4tuG9Mb1o3VCM2SR3lNXbLMbPTiVypcxKRyzLvcfcjTvu4ewiYcNDq3JjxF4EXj6tikRNQXBriiffz+P17eWSk1+Sxq/pzWT81YpPUU+4nVdx9N/B8JdQiEqiv1u5i0owsfPMeRvU/ibsu6UVTNWKTFKWPKUrSKywu49dvOX/6aCUtMtJ5+tpBnNOrZbzLEokrhb8ktQXLtzE5M5s1Owq4ekh7Jl/YgwbpasQmovCXpJS/v4QHXsvlhU/X0KFpXf72vSEM76JGbCIHKPwl6by9ZDO3z85m654ibjijMzef0506tfQJXZFYCn9JGtv3FnH3K0uYs2gDPVplMO2aQfRr1yjeZYlUSQp/SXjhcJg5izYwZU4Oe4tKufmc7tw4sgu1apTXvUQkdSn8JaFt2FXIHbMX827uFvq3a8TUK/rSvWVG+Q8USXEKf0lIoVCYFz5bwwOv5VIaCnHHxT0Zd1onqqs1g8hRUfhLwlm5bR+TM7P4ZOUOhndpyoOX96V907rxLkskoSj8JWGUloV4Zv5KHnlzKbWqp/Hg5X345uB2as0gchwU/pIQvt6Yz6TMLLLW7eacni25b3RvWjVMj3dZIglL4S9VWlFpGb9/N48n3l9Owzo1efzqU7i4T2ud7YucIIW/VFlfrtnJpBlZLNuylzGntOGuS3rRuF6teJclkhQU/lLlFBSX8vAbS3l2wUpaNUjn2esHc1aPFvEuSySpKPylSpmft43JM7NYu6OQbw9tz6QLepChRmwiFU7hL1XC7sIS7p/7NX//fC2dmtXj7zcMZUjnpvEuSyRpKfwl7t7I2cSdsxezbW8R3z8z0ogtvaYasYkEKZDwN7M04AmgH1AEjHf3vJjx3wKnAQe+DnJU9BvDJIVs3VPElDk5zM3eSI9WGTx93SD6tlUjNpHKENSZ/2gg3d2HmdlQ4BEi3wN8wADgfHffFtD2pQoLh8PM+td67nl1CQVFZfz8vO58/8wu1KyuRmwilSWo8B8BzANw94VmNujAQPRVQTdgmpm1BP7k7s8EVIdUMet3FXL7rGze960MaB9pxNa1hRqxiVS2oMK/ARA7jVNmZjXcvRSoB/wO+DVQHXjPzD5396yAapEqIBQKM/2T1Tz4ei6hMNx1SS+uG95RjdhE4iSo8M8HYk/n0qLBD1AAPObuBQBm9i6R9wYU/klqxda9TM7M5tNVOxjRtRkPXN6Hdk3UiE0knoIK//nApcBL0Tn/7Jix7sCLZjYASCMyRfRcQHVIHJWWhXjqw5U8+vZS0mukMfWKvlw5sK1aM4hUAUGF/yzgXDNbAFQDxpnZLUCeu88xs+nAQqAEeN7dcwKqQ+IkZ8NuJmVmsXh9Puef3JJ7R/WmRQM1YhOpKgIJf3cPARMOWp0bMz4VmBrEtiW+9peU8bt3l/HkP1fQuG4t/vCtAVzYp3W8yxKRg+hDXlJhvli9g4kzsli+dR9jB7Tlzkt60qiuGrGJVEUKfzlh+4pK+dUbznMfr+KkhnV47juncmb35vEuS0SOQOEvJ+SDpVu5bWY263cVct2wDtx6QQ/q19aPlUhVp99SOS67Coq5b+7XzPhiHZ2b1+MfE4YxuGOTeJclIkdJ4S/H7PXsjdz5cg47C4r5wcgu/PjsbmrEJpJgFP5y1Lbs2c8vX87h9cWb6NW6AX8eN5jebRrGuywROQ4KfylXOBxmxhfruG/u1xSWlHHr+cYNZ3RWIzaRBKbwlyNau6OAX8zK5sNl2xjUoTEPju1L1xb1412WiJwghb8cUigU5vmPVzH1DQfg7stO5pqhHUhTIzaRpKDwl/+St2UvkzOz+Hz1Ts7o3pz7x/SmbWM1YhNJJgp/+beSshDTPljBY28vo06t6jxyZT8uH9BGjdhEkpDCXwBYvH43E2dksWRjPhf1acXdl/WmeUbteJclIgFR+Ke4/SVlPPbOMqZ9sIIm9Wrx5LcHcEFvNWITSXYK/xT22aodTJqRxYpt+7hyYFvuuLgXDevWjHdZIlIJFP4paG9RKVPn5fL8x6tp27gOf/nuqZzeTY3YRFKJwj/FvOdbuH1mNhvz93P98I7cer5RT43YRFKOfutTxM59xdz76hJm/ms9XZrXY8aEYQzsoEZsIqlK4Z/kwuEwr2Vv4pdzFrOroIQffaMrN32jK7VrqBGbSCpT+CexLfn7uWP2Yt5cspk+bRry/HeG0OukBvEuS0SqgEDC38zSgCeAfkARMN7d8w5xn7nAy+7+ZBB1pKpwOMw/Pl/HvXOXUFwaYvKFPRg/ohM11IhNRKKCOvMfDaS7+zAzGwo8Aow66D73AZp0rmBrdxRw28xsPsrbxqkdm/Dg2D50bq5GbCLyn4IK/xHAPAB3X2hmg2IHzewKIAS8HtD2U05ZKMxzC1bxqzectGpw7+jefOvU9mrEJiKHFFT4NwB2xyyXmVkNdy81s97A1cAVwF0BbT+lLNu8h4mZWfxrzS5GWnP+b0wf2jSqE++yRKQKCyr884GMmOU0dy+N3r4WaAO8C3QEis1slbvPC6iWpFVcGuLJfy7n8XfzqFe7Or/5Zn9G9T9JjdhEpFxBhf984FLgpeicf/aBAXefeOC2mU0BNin4j13Wul1MnJFF7qY9XNK3NVMuO5lm9dWITUSOTlDhPws418wWANWAcWZ2C5Dn7nMC2mZK2F9SxqNvLeWpD1fQrH5tpl0zkPNObhXvskQkwQQS/u4eAiYctDr3EPebEsT2k9XCFduZnJnFqu0FXDW4Hbdd1JOGddSITUSOnT7klQD27C/hwddzmf7JGto1qcP08UM4rWuzeJclIglM4V/FvZu7mdtnLWZz/n7Gj+jELed1p24tHTYROTFKkSpqx75i7nklh9lfbaBbi/o8ceNwTmnfON5liUiSUPhXMeFwmFeyNjJlTg75hSX85Oxu/OCsLmrEJiIVSuFfhWzaHWnE9vbXm+nbtiFTvzeEHq3UiE1EKp7CvwoIh8O8+Nla7p/7NcVlIW6/qCfjTuuoRmwiEhiFf5yt3r6PyZnZfLxiO0M6NeGhsX3p2KxevMsSkSSn8I+TslCYZ+ev5OE3nZppadw/pg9XDW6nRmwiUikU/nHgmyKN2Bat3cXZPVpw35jetG6oRmwiUnkU/pWouDTEE+/n8fv38shIr8ljV/Xnsn5qxCYilU/hX0m+WruLSTOy8M17GNX/JO66pBdN1YhNROJE4R+wwuIyfv2W86ePVtIiI52nrx3EOb1axrssEUlxCv8ALVi+jcmZ2azZUcDVQ9oz+cIeNEhXIzYRiT+FfwDy95fwwGu5vPDpGjo0rcsL3xvKsC5N412WiMi/Kfwr2NtLNnP77Gy27inihjM6c/M53alTS60ZRKRqUfhXkO17i5jyyhJeWbSBHq0ymHbNIPq1axTvskREDknhf4LC4TBzFm1gypwc9haVcvM53blxZBdq1VBrBhGpuhT+J2DDrkLumL2Yd3O30L9dI6Ze0ZfuLTPKf6CISJwFEv5mlgY8AfQDioDx7p4XM/5D4HogDNzj7q8GUUdQQqEwL3y2hgdey6U0FOKOi3sy7rROVFdrBhFJEEGd+Y8G0t19mJkNBR4BRgGYWTPgB0B/IB1YYmZz3T0cUC0VauW2fUzOzOKTlTsY3qUpD17el/ZN68a7LBGRYxLUxPQIYB6Auy8EBh0YcPdtQD93LwFaAbsSIfhLy0L88Z/LueA3H7BkYz4Pje3D9PFDFPwikpCCOvNvAOyOWS4zsxruXgrg7qVmdhNwN/DbgGqoMF9vzGdSZhZZ63Zzbq+W3De6Ny0bpMe7LBGR4xbUmX8+EPvOZ9qB4D/A3UdBTr0AAAccSURBVB8HWgNnmNlZAdVxQopKy/j1m86lv/uI9TsLefzqU5h2zUAFv4gkvKDO/OcDlwIvRef8sw8MmJkBDwBjgRIibwiHAqrjuH25ZieTZmSxbMtexpzShrsu6UXjerXiXZaISIUIKvxnAeea2QKgGjDOzG4B8tx9jpktAj4mcrXP6+7+z4DqOGYFxaU8/MZSnl2wklYN0nn2+sGc1aNFvMsSEalQgYS/u4eACQetzo0Zv5vIfH+VMj9vG5NnZrF2RyHXDO3AxAuMDDViE5EkpA95AbsLS7h/7tf8/fO1dGpWj7/fMJQhndWITUSSV8qH/xs5m7hz9mK27ytmwpld+Ok53UivqUZsIpLcUjb8t+4pYsqcHOZmb6Rn6wb86brB9GnbMN5liYhUipQL/3A4zKx/reeeV5dQUFTGz8/rzvfP7ELN6mrEJiKpI6XCf/2uQm6flc37vpUB7SON2Lq2UCM2EUk9KRH+oVCY6Z+s5sHXcwmF4ZeX9uLaYR3ViE1EUlbSh//yrXu5LTObT1ft4PRuzbh/TB/aNVE/HhFJbUkd/l+u2clV0xaSXiONX13RlysGtqVaNZ3ti4gkdfg3qVuL75zWie+c1pEW6scjIvJvSR3+HZvVY/KFPeJdhohIlaPrG0VEUpDCX0QkBSn8RURSkMJfRCQFKfxFRFKQwl9EJAUp/EVEUpDCX0QkBSXEh7xycnK2mdnqeNchIpJgOhxuoFo4HK7MQkREpArQtI+ISApS+IuIpCCFv4hIClL4i4ikIIW/iEgKUviLiKSghLjO/2iZ2RDgIXcfedD6S4G7gFLgGXd/Kg7lHZMj7MstwHeBrdFV33d3r+TyjoqZ1QSeAToCtYH73H1OzHjCHJej2JdEOi7VgacAA8qAce6+PGY8IY7LUexHwhyTA8ysBfAFcK6758asr/BjkjThb2YTgWuAfQetrwk8CgyOjs03s1fcfVPlV3l0DrcvUQOAa939i8qt6rh8G9ju7teYWVPgX8AcSMjjcth9iUqk43IpgLufZmYjgV8DoyDhjsth9yMqkY7Jgf/7PwKFh1hf4cckmaZ9lgOXH2J9TyDP3Xe6ezHwEXB6pVZ27A63LwADgdvM7CMzu60Sazoe/wDujFkujbmdaMflSPsCCXRc3H02cEN0sQOwOWY4YY5LOfsBCXRMoh4GngQ2HLQ+kGOSNOHv7plAySGGGgC7Y5b3AA0rpajjdIR9AXgRmAB8AxhhZpdUWmHHyN33uvseM8sAZgB3xAwn1HEpZ18ggY4LgLuXmtlzwO+I7M8BiXZcDrcfkEDHxMyuB7a6+xuHGA7kmCRN+B9BPpARs5wB7IpTLSfEzKoBv3H3bdEzgLnAKXEu64jMrB3wHvAXd/9bzFDCHZfD7UsiHhcAd78O6A48ZWb1oqsT7rgcaj8S8Jh8BzjXzN4H+gPPm1mr6FggxyRp5vyP4Gugm5k1AfYCZxB5eZWIGgCLzawnkbm/bxB5E7JKMrOWwJvATe7+zkHDCXVcytmXRDsu1wBt3f0BoAAIEXnDFBLouJSzHwl1TNz9jAO3o38AJsTM6QdyTJI2/M3saqC+u0+Lvuv/BpFXOs+4+/r4VndsDtqXXxA5+ywC3nH31+Jb3RH9AmgM3GlmB+bLnwLqJeBxKW9fEum4zASeNbMPgJrAT4HLzSzRfl/K249EOib/JegMU1dPEZEUlApz/iIichCFv4hIClL4i4ikIIW/iEgKUviLiKSgpL3UU+RIzKwTkWulmxK5THARMMnd9xzm/mOAT9z94I/eiyQknflLyjGzOkSask1195HufhrwCfDCER72EyIfHBJJCrrOX1KOmV0BjHT3mw5avxBYCvzN3eeZ2QXAVUSauk2Pjo0AJgKjibxy/oO7/9HMfha9bynwgbtPMrMpQFegGdAEeAIYS6QVwXXuvtDMfgRcDYSBF939t8HuvUiEzvwlFXUm0jn1YCuJfHT+P7j7XOAr4FrgZOBCYAgwHOhlZn2A/4kuDyfyUfwDTcQK3f0CIp9GvcjdLwUeBK4ys17AN4n8QRkBjDYzq7C9FDkCzflLKloPnHqI9d2AD2KWqx3iPgZ86u5lRPrJ/MTMrgQWunsJgJl9SOSPBMCX0X93AUuit3cC6UBvIq2ID/QKakzklUKV/sIRSQ4685dU9DKRDor//gNgZuOJfONTAdA6unpAzGNCRH5fcoEBZpZmZjXN7C0i00FDzKxGtJvkGdF1EJnOORwHcoCzot/Y9mcg+wT3TeSoKPwl5bj7XiLfAnWHmc03s0+ITOP8L/A0cLOZvQ20iXnYAuB5YA0wD5hP5Es1prv7IuCl6LpPgVXA7KOoYxGRs/6PzOxzIq88qmoTNUkyesNXRCQF6cxfRCQFKfxFRFKQwl9EJAUp/EVEUpDCX0QkBSn8RURSkMJfRCQF/T+OiFUzFN/dMAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "d4.plot()\n",
    "decorate_dice('One die')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Cdf` also provides `step`, which plots the Cdf as a step function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def step(self, **options):\n",
      "        \"\"\"Plot the Cdf as a step function.\n",
      "\n",
      "        :param options: passed to plt.step\n",
      "\n",
      "        :return:\n",
      "        \"\"\"\n",
      "        underride(options, label=self.name, where=\"post\")\n",
      "        plt.step(self.qs, self.ps, **options)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf.step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "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": [
    "d4.step()\n",
    "decorate_dice('One die')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make Cdf from sequence\n",
    "\n",
    "For comments or questions about this section, see [this issue](https://github.com/AllenDowney/EmpyricalDistributions/issues/14).\n",
    "\n",
    "\n",
    "The following function makes a `Cdf` object from a sequence of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    @staticmethod\n",
      "    def from_seq(seq, normalize=True, sort=True, **options):\n",
      "        \"\"\"Make a CDF from a sequence of values.\n",
      "\n",
      "        seq: any kind of sequence\n",
      "        normalize: whether to normalize the Cdf, default True\n",
      "        sort: whether to sort the Cdf by values, default True\n",
      "        options: passed to the pd.Series constructor\n",
      "\n",
      "        :return: CDF object\n",
      "        \"\"\"\n",
      "        pmf = Pmf.from_seq(seq, normalize=False, sort=sort, **options)\n",
      "        return pmf.make_cdf(normalize=normalize)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf.from_seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>e</th>\n",
       "      <td>0.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>l</th>\n",
       "      <td>0.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>n</th>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "a    0.2\n",
       "e    0.4\n",
       "l    0.8\n",
       "n    1.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cdf = Cdf.from_seq(list('allen'))\n",
    "cdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "1    0.2\n",
       "2    0.6\n",
       "3    0.8\n",
       "5    1.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cdf = Cdf.from_seq(np.array([1, 2, 2, 3, 5]))\n",
    "cdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selection\n",
    "\n",
    "For comments or questions about this section, see [this issue](https://github.com/AllenDowney/EmpyricalDistributions/issues/15).\n",
    "\n",
    "`Cdf` inherits [] from Series, so you can look up a quantile and get its cumulative probability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Cdf` objects are mutable, but in general the result is not a valid Cdf."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1.25</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "1    0.25\n",
       "2    0.50\n",
       "3    0.75\n",
       "4    1.00\n",
       "5    1.25\n",
       "dtype: float64"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4[5] = 1.25\n",
    "d4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "1    0.2\n",
       "2    0.4\n",
       "3    0.6\n",
       "4    0.8\n",
       "5    1.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.normalize()\n",
    "d4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluating CDFs\n",
    "\n",
    "For comments or questions about this section, see [this issue](https://github.com/AllenDowney/EmpyricalDistributions/issues/16).\n",
    "\n",
    "Evaluating a `Cdf` forward maps from a quantity to its cumulative probability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "d6 = Cdf.from_seq([1,2,3,4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(0.5)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.forward(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`forward` interpolates, so it works for quantities that are not in the distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(0.5)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.forward(3.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(0.)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.forward(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(1.)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.forward(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`__call__` is a synonym for `forward`, so you can call the `Cdf` like a function (which it is)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(0.16666667)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6(1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`forward` can take an array of quantities, too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorate_cdf(title):\n",
    "    \"\"\"Labels the axes.\n",
    "    \n",
    "    title: string\n",
    "    \"\"\"\n",
    "    plt.xlabel('Quantity')\n",
    "    plt.ylabel('CDF')\n",
    "    plt.title(title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAESCAYAAAAVLtXjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAciUlEQVR4nO3de5xcdX3/8dfsZrObZDcXck+4JOHyyQWJyi3hpj40IqjIz9ZHrUohFDWt/rTy6A9RW8XWR6nF2FYp9Sc/FPFSxUAUtA2xgEUCFAQqsJN8knCJhJnck53NJnud+f1xzoZh2WuyZ87Mmffz8eDBzDkzZz65vefs93vO55sqFAqIiEh1qYm7ABERKT2Fv4hIFVL4i4hUIYW/iEgVUviLiFQhhb+ISBUaE3cBUr3MrAA8B/QUbf6tu18TU0mvYWZnAWvcfV7En/Nr4GZ3X3OU7383cK67f9HMLgPe4e6fGs0aJXkU/hK3t7n7nriLqHBnA8cBuPs9wD3xliOVQOEvZcnMLgRuAsYDncBfufs6M7sK+FNgAtACnA4sd/etZvY5YJW7nxQe4z+B1cB+4B+AemA28Ct3/1Mzmwf8BtgIzAPeAlwOfCY89rOD1Hce8NWwjh7gy+7+CzN7BFjt7neFr/tq+Ja/Af4VOBWYCrQCH3J3LzrmPOA5d2/s+9zMJvT3fmAysAqoNbMWYAvwh+7+HjM7PnzPPCAFfM/dbwqPez/w78C5wBTgOndfO+gfiiSKxvwlbg+a2f8U/TfDzKYCa4BPu/sZwJXAD8xsfvieJcBb3f1twL3Au8Lt7wLGmtlpZjYJWEoQcp8Gvuju5wKLgcvM7MzwPccDf+vupwEzgRuAi9z9bIIvndcxsynAd4Er3P3NwPuAfzWzE4FbgZXh62qBjwD/D7gEOODuy8PPegL45Ah+n/p9v7v/N/At4Cfu/oU+7/kh8KC7vwE4H/iImX0w3LcAuM/dzwGuB/5pBLVIAujMX+L2umEfM7sU2BoGG+7ebGYbgLcCBeAZd8+FL18LrDKz7wGzgB8BK4B9wDp37zSzK4FLzezzwEJgHNAI7AW6gUfDY70dWO/uO8Ln3+bVL5Ziywl+gviZmfVuKwBnAD8BvmZms4A3A5vdfQuwxcxeMLP/DZwS/loe7Xvggbj7mpG8P/xJ4XzgneH7W8zsdoIvkceALoIzf4CnCIeNpHoo/KUc1RKEabEaoI7gbPxg0fZfEZxZvxv4dfj8z4BDwI/D1zwEPAOsA+4kGOpIhfs63L276HiposfF2/vWtzH8SQIAM5sD7Hb3LjP7KcGQzPKwNszsz4CPATcTfEHtA+b3OW6hz+ePLTr+cN5frKbPsXq31YWPO909P8DnShXQsI+Uo0eBhWZ2DoCZLQEuIgj313D3duC/gC8B68PHy4ELgfvMbDLBhOhn3f1ugmGeUwgCvK/1wDvDsXKAqwao7zHgVDO7KKzvjQRj7XPD/bcSDFWdD9wVbrsYuN3dbwMceG8/NRwgGLZaHD7/46J9g72/m1dDvff3pTWs8xNhjZOAPyH4chRR+Ev5CYeBPgB808yeJTjTXenumwd4y1rgNOABdz8M/A7Y4O7t7n4AuBF4ysyeIxjf3kDwBdD3c58FrgPuN7PfAg0D1Lcb+APgJjP7HfB9gvH/l8L9TxJMAq8Jv5wAvgZ83MyeIZhkfqpvDe7eEn7+f5jZE8Dhot2Dvf8B4GIz+2afUj8MvD38PXwcuBu4vb9fk1SflFo6i4hUH535i4hUIYW/iEgVUviLiFQhhb+ISBWqiOv8zz333MLcuXOHfqGIiBzR3Ny8x92n97evIsJ/7ty53H333XGXISJSUcxs20D7NOwjIlKFFP4iIlVI4S8iUoUU/iIiVUjhLyJShRT+IiJVKLLwN7Nzw4Wp+25/r5k9YWaPmtlHo/p8EREZWCTX+ZvZdcAVQFuf7XXAPxL0V28DNpjZvUUrJ4mIROb53Qf5+f9koEK6GdfX1fLhc09k8vixQ794hKK6yet54P0Efc6LLSJYnm8/gJk9TLDoxk8jqkNE5IibH9jK2qdfIVUh65bVj6nhvJOn8qYTKyT83f0uM5vXz66JQEvR81ZgUhQ1iIj01Zxp4e0LZ3DbVWfHXUrsSj3hmwOaip43ESxdJyISqfauHp7f3cbiORPjLqUslLq3z0aCtU+PI1iE+yKC5elERCK1eWcrPfkCi2cr/KFE4W9mHwIa3f3bZnYtcB/BTx3fcfdXSlGDiFS35kwOgCVzNNIMEYZ/uJj1svDxj4q23wvcG9Xnioj0J53J0VQ/huOnjIu7lLKgm7xEpCqkszkWzZ5ITU2FXOoTMYW/iCRePl9gYzanyd4iCn8RSbyX9rZxqLNH4V9E4S8iiZfOBpO9utLnVQp/EUm8dCbHmJoUp85sjLuUsqHwF5HES2dznDKjkfoxtXGXUjYU/iKSeM2ZnK7v70PhLyKJtqu1nd2tHZrs7UPhLyKJtjHbCmiyty+Fv4gkWjqjK336o/AXkURrzrRw/JRxTBpfF3cpZUXhLyKJls7mdNbfD4W/iCTWoc5uXtyjHv79UfiLSGJt2tFKoaDx/v4o/EUksY708J+ra/z7UviLSGKlMzkmjatjzqSGuEspOwp/EUms3sneVEo9/PtS+ItIInX35NmkHv4DUviLSCK9uKeNju68JnsHoPAXkUTq7eG/ZK7Cvz8KfxFJpHQmx9jaGk6erh7+/VH4i0gipbM5TpvVSF2tYq4/+l0RkcQpFAo0Z9TWYTAKfxFJnJ25Dva1dWoBl0Eo/EUkcdLZFgBd5jkIhb+IJE5vD/+Fs5pirqR8jYm7ABGpXIVCgdsefpFXDhyOu5TXeHjLHk6aOp6mBvXwH4jCX0SO2vb9h/nKLzcyrq6WMbXl1ULhI8tOiruEsqbwF5Gj1pwJxtZ//LFlLD1hcszVyEhozF9Ejlo6k6MmBaax9Yqj8BeRo5bO5jh5eiMNdbVxlyIjFMmwj5nVALcAS4EO4Bp331q0/y+BPwbywN+5+9oo6hCRaKUzOc6ef1zcZchRiOrM/3Kgwd2XA9cDq3t3mNlk4FPAcuCdwD9FVIOIRGh/WyeZlnbdRVuhogr/C4B1AO7+GHBW0b42YBswIfwvH1ENIhKhI10zdRdtRYoq/CcCLUXPe8yseIjpZSANPAV8I6IaRCRCvTdSLZqtyd5KFFX454DivxE17t4dPr4EmA3MB04ELjezcyKqQ0Qiks7mmDWxgamN9XGXIkchqvDfAFwKYGbLgGeL9u0HDgMd7t4OHAB0gbBIhWnOtKh3TgWL6iavtcAKM3sESAErzexaYKu732Nm7wAeM7M88DDwq4jqEJEItHf18PzuNi5eMivuUuQoRRL+7p4HVvXZvKlo/5eAL0Xx2SISvc07W+nJF3SlTwXTTV4iMmK9k70a9qlcCn8RGbHmTI7G+jGcMGV83KXIUVL4i8iIpbPBEok1NeXVyVOGT+EvIiOSzxfYmM1pyKfCKfxFZES27TvEoc4eTfZWOIW/iIxIbw9/nflXNoW/iIxIOpNjTE2KU2c2xl2KHAOFv4iMSDqb45QZjdSPUQ//SqbwF5ERSWc02ZsECn8RGbbdrR3sau3QZG8CKPxFZNjUwz85FP4iMmxH2jrozL/iKfxFZNjS2RxzJ49j0vi6uEuRY6TwF5FhUw//5FD4i8iwHOrs5sU9bSxR+CeCwl9EhmXTjlYKBY33J4XCX0SGRT38k0XhLyLD0pzJMWlcHXMnj4u7FBkFCn8RGZbeHv6plHr4J4HCX0SG1N2TZ5N6+CdKJAu4i8jRa860cMcj28gXCnGXcsThrh46uvOa7E0Qhb9Imfnuhpf42dOvMKOpPu5SXuOUGY0sP3lq3GXIKFH4i5SZdCbHeadM446rz4m7FEkwjfmLlJHO7jxbdrVqeEUip/AXKSNbdrXS1VPQXbQSOYW/SBnRjVRSKgp/kTKSzuYYV1fLvKkT4i5FEk7hL1JG0pkcC2c3UVujG6kkWgp/kTJRKBRIZ3Ma75eSUPiLlInt+w/T2t7N4tlaIlGip/AXKRPNmuyVElL4i5SJdDZHTQpsZlPcpUgViOQOXzOrAW4BlgIdwDXuvrVo/yXAl8KnTwGfcPfyaWQiEoN0poWTpzcybmxt3KVIFYjqzP9yoMHdlwPXA6t7d5hZE3AT8B53Xwa8BEyLqA6RipHOqGumlE5U4X8BsA7A3R8Dziradx7wLLDazH4D7HT33RHVIVIR9rd1kmlpV1sHKZmown8i0FL0vMfMeoeYpgFvAz4LXAL8hZmdFlEdIhVhY1aTvVJaUYV/Diietapx9+7w8V7gCXff4e4HgYeAN0ZUh0hFOHKlj878pUSiCv8NwKUAZraMYJin15PA6WY2LfxpYBmQjqgOkYqQzuaYNbGBqY3l1cNfkiuqfv5rgRVm9giQAlaa2bXAVne/x8w+B9wXvvZOd38uojpEKoIme6XUIgl/d88Dq/ps3lS0/8fAj6P4bJFK097Vw9bdB1mxeGbcpUgV0U1eIjHbvLOVnrx6+EtpKfxFYqYe/hIHhb9IzNLZHI31Yzhhyvi4S5EqovAXiVk6k2PR7CZq1MNfSkjhLxKjfL7AxmyOJXPUxllKS+EvEqNt+w7R1tmjm7uk5BT+IjHSZK/EZdDwN7M1RY8vib4ckeqSzrYwpibFKTMa4y5FqsxQZ/5Tix7/nygLEalGzZkcp8xopKFOPfyltEYy7KNLEURGmdo6SFyGau+QMrM6gi+J3scpAHfvjLo4kSTb3drBrtYOTfZKLIYK/5MA59Wz/s3h/wvAgqiKEqkG6uEvcRo0/N19fqkKEak26uEvcRqyq6eZvRv4I4IVuLYD/+buD0ZdmMhoKRQKfHWds21vW9ylvMZzmRbmTh7H5PFj4y5FqtCg4W9mnyBYavGfgZ0Ew0BfMLNT3f3bJahP5JhlW9r51n89z+xJDTQ1RLWExciNq6vlsqVz4i5DqtRQ/xI+DFzo7j3h82fMbD2wHlD4S0XovZHq5g+9iTNPOi7makTKw1CXenYWBT8A7t4BdA/wepGyk87mSKXAZmlsXaTXUOGfH2C7rvmXipHO5Jg3dQKN9eUz5CMSt6H+NZwZrsNbLAUsiqgekVHXnG3hjOMnx12GSFkZKvyXAhcDDwCdwInA6cB/RFyXyKhoOdzFy/sO88GzT4y7FJGyMtSwz5XACuAVd98GvBw+vyLqwkRGwybdSCXSr6HC/1LgA+5+CMDdXyK45v+yiOsSGRXpMPyX6EYqkdcYKvzb3L1QvMHdu4DW6EoSGT3NmRzTGscyvak+7lJEyspQ4X/IzF7Twyd8Xhjg9SJlJeiaOYlUSheoiRQbasL3s8DPzOx+4AWCCd+LCeYCRMpaZ3eeLbtauei06XGXIlJ2Bj3zd/dm4ELgaWAC8BRwvrs/XYLaRI7J1l0H6eopaLJXpB9D3vXi7i3AHSWoRWRU9U72qmumyOtpAXdJrOZMC+Pqapk/bULcpYiUHYW/JFY6k2Ph7CZqazTZK9KXwl8SqVAokM7mNOQjMgCFvyTS9v2HaW3v1mSvyAAiaXNoZjXALQS9gTqAa9x9az+v+SXwc3f/VhR1SPXqXSJxyZxJMVciUp6iOvO/HGhw9+XA9cDqfl7zFUAra0gk0tkcNSmwmU1xlyJSlqIK/wuAdQDu/hhwVvFOM/tDgrUC1B1UIpHO5FgwvZFxY2vjLkWkLEUV/hOBlqLnPWY2BsDMTgc+BHwxos8WYaMme0UGFVX454Din7dr3L136cc/AeYSrBFwFXCtmb0rojqkCu1v6+SVA4dZoslekQFFta7dBuC9wJ1mtgx4tneHu1/X+9jMbgB2uPu6iOqQKrRRPfxFhhRV+K8FVoRLQKaAlWZ2LbDV3e+J6DNFgFfbOizSsI/IgCIJf3fPA6v6bN7Uz+tuiOLzpbqlMzlmTqxnWqN6+IsMRDd5SeI0Z3K6vl9kCAp/SZT2rh627j6oK31EhqDwl0TZsvMgPXn18BcZisJfEiWdDW4v0Zm/yOAU/pIozZkcjfVjOPG48XGXIlLWFP6SKOlMjkWzm6hRD3+RQSn8JTHy+YLaOogMU1Q3eUnCPbltP9+4fwv5QiHuUo7o6snT1tmjyV6RYVD4y1FZ8+TLPPrC3rLrn3PeyVN5y2kz4i5DpOwp/OWopDM5zjppCj/66LK4SxGRo6Axfxmx7p48m3a0amxdpIIp/GXEXtjTRkd3niVzFf4ilUrhLyOWDtfHXTxb/XNEKpXCX0Ysnc0xdkwNC6ZPiLsUETlKCn8ZseZMCzazibpa/fURqVT61ysjUigUSGdyZXeJp4iMjMJfRmRHrp39h7p0I5VIhVP4y4i8Otmr8BepZAp/GZHmTI5UChYq/EUqmsJfRiSdyTFv6gQa63VzuEglU/jLiKTVNVMkERT+Mmy59i5+v++QJntFEkDhL8O2UZO9Iomh8JdhS2eD8Nc1/iKVT+Evw5bO5JjWOJbpTfVxlyIix0jhL8OWzuZYNHsiqZTWxxWpdAp/GZbO7jybd7ZqslckIRT+Mixbdx2kq6fAkjlq4yySBAp/GZbeyV5d6SOSDAp/GZZ0JkdDXQ3zp6mHv0gSKPxlWJozLSycNZHaGk32iiSBwl+GVCgUSGfVw18kSSLpzmVmNcAtwFKgA7jG3bcW7f8M8MHw6b+7+5ejqENGx/b9h2lt79aVPiIJEtWZ/+VAg7svB64HVvfuMLMFwIeB84DlwDvN7IyI6pBRoMlekeSJKvwvANYBuPtjwFlF+14G3uXuPe6eB+qA9ojqkFHQnMlRk4KFsxT+IkkRVVP2iUBL0fMeMxvj7t3u3gXsMbMUcBPwtLtvjqgOGQXpTI4F0xsZN7Y27lJEZJREdeafA5qKP8fdu3ufmFkD8MPwNX8eUQ0ySjaqh79I4kQV/huASwHMbBnwbO+O8Iz/58Dv3P3j7t4TUQ0yCg4c6uSVA4c12SuSMFEN+6wFVpjZI0AKWGlm1wJbgVrgLUC9mV0Svv5z7v5oRLXIMdCC7SLJFEn4hxO5q/ps3lT0uCGKz5XRd+RKH535iySKVuEuI9et+R1bdh2Mu4zX2L7/MDMn1jOtUT38RZJE4V8mdrW2c+dvt3PazEZmTiyfH4wWzmriHYtmxl2GiIwyhX+Z6B1b/5v3nc6yBVNjrkZEkk69fcpE79j6Ik2sikgJKPzLRHMmx/FTxjFpXF3cpYhIFVD4l4mNGXXNFJHSUfiXgbaObl7c28bi2VoiUURKQ+FfBjbtaKVQ0LX0IlI6Cv8ykM4EPfAU/iJSKgr/MpDO5pg8vo45k8rn+n4RSTaFfxlIZ4KumamU1scVkdJQ+MesuyfPph2tapwmIiWl8I/ZC3va6OjOa7xfREpK4R+z3rYOS+boMk8RKR2Ff8zS2Rxjx9SwYPqEuEsRkSqi8I9ZOpPDZjZRV6s/ChEpHSVOjAqFAmmtjysiMVD4x2hHrp19bZ0smavwF5HSUvjHSOvjikhcFP4x6g3/hQp/ESkxhX+M0tkc86aOp7FeC6qJSGkp/GPUnMnp+n4RiYXCPya59i5+v++Q7uwVkVgo/GOyKdsKaLJXROKh8I+JeviLSJwU/jFpzuSY1jiWGU31cZciIlVI4R+TdDbHIvXwF5GYKPxj0NmdZ8vOgxryEZHYKPxj8Pzug3T25DXZKyKxUfjHoFk9/EUkZgr/GKQzORrqapg/TT38RSQekfQVMLMa4BZgKdABXOPuW4v2fxT4ONANfMXdfxFFHeUqnW1h4ayJ1NZosldE4hHVmf/lQIO7LweuB1b37jCzWcCngPOBi4EbzaxqrncsFAqkMzlN9opIrKLqKHYBsA7A3R8zs7OK9p0DbHD3DqDDzLYCZwBPjHYRz2w/wPV3PUtXT360D33U8oUCufZulij8RSRGUYX/RKCl6HmPmY1x9+5+9rUCkcx8Tmyo49SZjWUV/gBLj5/MisUz4y5DRKpYVOGfA5qKnteEwd/fvibgQBRFzJs2gX/+4JuiOLSISEWLasx/A3ApgJktA54t2vc4cKGZNZjZJGAR8FxEdYiISD+iOvNfC6wws0eAFLDSzK4Ftrr7PWb2DeA3BF8+X3D39ojqEBGRfkQS/u6eB1b12bypaP+twK1RfLaIiAxNN3mJiFQhhb+ISBVS+IuIVCGFv4hIFVL4i4hUoagu9RxVzc3Ne8xsW9x1iIhUmJMG2pEqFAqlLERERMqAhn1ERKqQwl9EpAop/EVEqpDCX0SkCin8RUSqkMJfRKQKVcR1/kdjqEXky5GZnQt81d3fGnctgzGzOuA7wDygHviKu98Ta1EDMLNagg6yBvQAK939+XirGpqZzQCeBFa4+6ahXh8XM3uaV1fme9HdV8ZZz1DM7HPAZcBY4BZ3vy3mkvplZlcBV4VPG4A3ArPcfdQWvkps+FO0iHy4oMxq4H0x1zQgM7sOuAJoi7uWYfgIsNfdrzCzqcDTQFmGP/BeAHc/38zeCnydMv57AEe+XP8vcDjuWgZjZg0A5X6y0iv88z8POB8YD/xlrAUNwt1vB24HMLN/Ab4zmsEPyR72ec0i8sBZg788ds8D74+7iGH6KfDXRc+7B3ph3Nz9Z8DHwqcnATtjLGe4vgZ8C8jEXcgQlgLjzWy9mT0QnmSVs4sJVhVcC9wL/CLecoZmZmcBS9z926N97CSHf7+LyMdVzFDc/S6gK+46hsPdD7p7q5k1AWuAv4q7psG4e7eZfQ/4JkG9ZSv8cX+3u98Xdy3DcIjgi+pigsWbfljO/8aAaQQngR/g1XpT8ZY0pM8DX47iwEkO/8EWkZdjZGYnAA8C33f3H8Vdz1Dc/UrgNOBWM5sQdz2DuJpgCdRfE4zz3mFms+ItaUCbgR+4e8HdNwN7gdkx1zSYvcB97t7p7g60A9NjrmlAZjYZWOjuD0Zx/HL+lj5WGwjGe+/sZxF5OQZmNhNYD3zS3e+Pu57BmNkVwPHufiPBmWqeYOK3LLn7Rb2Pwy+AVe6+I76KBnU18Abgz81sDsFP29l4SxrUw8CnzezrBF9SEwi+EMrVRcB/RnXwJIf/6xaRj7meJPk8MAX4azPrHfu/xN3LcYLybuC7ZvYQUAf8hbu3x1xTUtwG3G5mDwMF4Opy/una3X9hZhcBjxOMenzC3cv2RIDgCrUXojq4unqKiFShJI/5i4jIABT+IiJVSOEvIlKFFP4iIlVI4S8iUoWSfKmnyKDM7EzgRoI+LzUEN6192d07R+HYFwEH3P0ZM7vb3d9vZm8Aprj7Q8d6fJFjpTN/qUpmdjzwA4Ib1S4gaPbVAfzjKH3E1cAcAHfv7dn0B8DiUTq+yDHRdf5Slczs80CHu68u2pYiuKlmF3Clu28ys1UErXRvMLMbCXrDNAEb3X2lmd0AzAdmEDSO+wywB/hleJz3ENxUdCbBXeedBF1Rb3b3c8LP/QnwNXd/IvpfuUhAZ/5SrU6iz92T7l4g6Pr5ul46ZjYR2O/uKwjaAi8zs7nh7g53vwT4NPAZd3+SoKPsde7++/DYrxC06P26uz8OHDazxWZ2HDBfwS+lpjF/qVbbgAXFG8IFgE4EXina3Nv18TAww8z+DTgINBK0i4BgPQOAlwkW3hiOWwkW6/g9wfCTSEkp/KVafR9Yb2b3ALuBO4HtBD3eTyRo/LUJeDPBl8ElwAnu/kdmNh34X7z6xdDf2Gme1/9kXbxtDcFiInsJWgyLlJSGfaQqufvLhGPvBOPz0wkCfyxwB/AvZnYfUBu+5XFggZk9RhDcLxBO6A7gv4G/N7NFRdueBD5pZm8Lm8s9BOxy932j9ysTGR5N+IoUMbMzgBfc/WAJPusWYI27PxD1Z4n0pfAXiYGZrQcy7n5V3LVIdVL4i4hUIY35i4hUIYW/iEgVUviLiFQhhb+ISBVS+IuIVKH/D56SpT69GonSAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "qs = np.linspace(0, 7)\n",
    "ps = d6(qs)\n",
    "plt.plot(qs, ps)\n",
    "decorate_cdf('Forward evaluation')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Cdf` also provides `inverse`, which computes the inverse `Cdf`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(3.)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.inverse(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`quantile` is a synonym for `inverse`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(3.)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.quantile(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`inverse` and `quantile` work with arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAESCAYAAAAVLtXjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAYOklEQVR4nO3deZhldX3n8Xdt3VXVXVXsW7NJ1K8YFRWGRUCiIzIwYojGybhFMcTwqI9GxnGduI0zaCL6jJMQDSRx3IMsEU0COBrHCCJGiCLKl7QEXFBZlK5uuqq7ljt/nFvdt6tvVTXS596u+r1fz3OeOuf8zv2d7y2az/ndc+qe09NoNJAklaW32wVIkjrP8JekAhn+klQgw1+SCmT4S1KBDH9JKpDhr66LiLsi4rhu19FJEXFkRGx6hH1cEhHHNucvjYhn7Z7qVIL+bhcg6Vd2OvARgMw8r8u1aJkx/LVHiYhJ4L3As4GDgT/OzD+PiBuAizLziuZ27wPIzDdFxO8Br6L6JPsA8JrMvD0iPgrsA/wa8AXg88AHgD6gAVyYmVdExCrgfcBpzbZbgNdm5nib+t4GPL+5r7ua+10L3AAckplbI6IP+CHwLGAM+GNgdfP9fDEzf29en+8E9svM18xfjogT270+Iv4HcAjwyYj43Wb9f5qZl0fEOcA7mjVuBC7IzJua/R7Z7OcI4CfASzLzp7v4n0criKd9tKdZDdyfmU8Dfhv4YEQMApcA5wI0w/UlwKURcRrwMuDUzHwKVVBe1dLfcGb+ema+CXgX8IHMPBZ4BfDM5jZvBqaBYzPzGOAeqgPQDpoh+0Tg+Mx8MvD3wKWZeQdwG/Dc5qbPBv4tM78PvA54e2aeADweeO7cqZpd1Pb1mfm2Zp0vzsxvtNT4OODDwPOb7+XtwOciYrS5yanACzLzccBDwPkPoxatII78tSf6XPPnzVQHgzXA3wDvj4iDgKcCd2Tmv0bE7wOPBm6IiLnX7x0R+zTnv9bS72XAn0XE2cD/Bd7aXP8cYC/g9GYfq4B729T1HOB44J+b2/UBw822S4GXA5dTHaQuaa5/GXBWRLwVeBwwRPVJ4YFd/F0s9PqFPBP4UmbeCZCZX46Ie4G5A85XWj7R3EL1yUgFcuSvPdEEQGbO3XiqJzM3A58FXkQVrpc22/qAj2fmk5uj8acCxwG/bLZvu6iamR+hGrl/ETgD+E7zU0Uf8LqWPo6n+tQxXx/wvpbtjgNObrZ9FjghIo6mOn302eb6rwJnAbcD76Y61dIzr9/GvHWrWuZ35fXza5x/w65eYKA5P7HIflUQw1/LySVUI+GTgSua664FXhgRBzeXzwe+1O7FzesGT8nMjwKvpBrtH9Ts4zURsSoiepv7ubBNF9cC57WcQnk38HGAzJwEPgN8FLgiMzdHxF7AvwPelJlXAodSfUrpm9fvfcCxEdETESNUnzDYhddPsz3U53wJOCMijmr28UzgMOAbSC0Mfy0bmfktYAa4vBm2ZOZ1VBc7vxgR36H6ZPC8lk8Nrd4IvDsibgG+ArwrM+8C/jvVxdtbgO9RjYb/S5vXX0p14fjGiLgNeBLVqZ45l1B9ari0WduDVAeRmyPiu1TXFq6nCvBWn6Q6APxrs///t4uvvxL4REQ8u+V39D2qi9BXNl/zXuDszNzQ5v2oYD3e0lmSyuPIX5IKZPhLUoEMf0kqkOEvSQVaFl/yOuGEExrr1q3rdhmStKzcdttt92fm/u3alkX4r1u3jiuvvLLbZUjSshIRdy/U5mkfSSqQ4S9JBTL8JalAhr8kFcjwl6QCGf6SVKDawj8iToiIr7RZf3ZEfDMivt58EIckqcNqCf+IeCPVbW0H560fAD5I9Zi704BXNp/MJEma5+pv38OGiala+q5r5P8D4Hlt1h8NrM/MX2bmVqpH7J1aUw2StGw9sGkLr/30LfzDrT+tpf9awj8zrwDaHa5GgdaHSmwExuqoQZKWs5nms1amZ+t55kqnL/iOAyMtyyPAgx2uQZKK1+l7+3wfeExE7EP1YO2nA+/vcA2SVLyOhH9EvAhYm5l/EREXUD0Iuxf4q8z8SSdqkCRtV1v4Nx+MfWJz/lMt6z8PfL6u/UqSluaXvCSpQIa/JBXI8JekAhn+klQgw1+SCmT4S1KBDH9JKpDhL0kFMvwlqUCGvyQVyPCXpAIZ/pJUIMNfkgpk+EtSgQx/SSqQ4S9JBTL8JalAhr8kFcjwl6QCGf6SVCDDX5IKZPhLUoEMf0kqkOEvSQUy/CWpQP3dLkCStN2W6Rk2TExx9wOba92P4S9Ju9nkVBXg26bNUzsuT0wxPjnF+MTO6yenZnfoa83qvlpqNPwlaZ5Go8FES4CPT0zvHN5tgntu2jo9u2j/I6v7GR0aYKw5HbXf2mp+uFqea9t3zSpOeNQ+tbxHw1/SitRoNNi8daZtOC8W3HNtUzONRfsfGezfFt5jQwM85oC12+Zbg33+NDLYT39f9y+3Gv6SloV7xydZf9+mBYJ7eqfwHp+YYnp24QDv6YHRwR2D+ZCxobbBPTrUPy/AB+jr7engu9/9DH9Jy8JZH/oa92/assO63h52CutD9x5acNTdOjIfWd1P7zIP8EeilvCPiF7gYuAYYAtwXmaub2l/A/BCYBb4n5l5VR11SFo5Nk5O8dxjDuGVTz9q2/nxtavKDvBHoq6R/znAYGaeFBEnAhcBvwkQEXsBrwUeDawB/gUw/CUt6eC9BnnCurFul7Ei1HXV4RTgGoDMvBE4rqXtIeBuquBfQzX6lyR1UF3hPwpsaFmeiYjWTxk/Ar4H3Ax8qKYaJEkLqCv8x4GR1v1k5nRz/kzgYOBRwOHAORFxfE11SJLaqCv8rwfOAmie87+1pe2XwASwJTMngQeBvWqqQ5LURl0XfK8CTo+IG4Ae4NyIuABYn5lXR8SzgBsjYhb4GvDFmuqQJLVRS/hn5ixw/rzVt7e0vwN4Rx37liQtrfvfMZYkdZzhL0kFMvwlqUCGvyQVyPCXpAIZ/pJUIMNfkgpk+EtSgQx/SSqQ4S9JBTL8JalAhr8kFcjwl6QCGf6SVCDDX5IKZPhLUoEMf0kqkOEvSQUy/CWpQHU9wF2S2pqamWXDxBTjE1NsaJnmL2+fphmfmGLL9Cy9PT3dLn/FMPwlPWxbp2d3Mbh3bt+8dWbRvocG+hgbGtg2rdtrkKMPHmGvoVX8p+MO69A7XPkMf6lQk1MzS4b2XHCPT0zvsG5iavEAH161PcBHhwY4bJ9hntAS6K3T6A7z/azu7+vQb6Bshr+0TDUaDSanZpccaS8U8FumZxftf+3qfsaGBhgZrH4ese/wjsE9vHN4jw0NMDo4wKp+Lyfu6Qx/aRl6w2e/zdX/cg9bZxYP8JHV/TuE86/tv3bR4N4e4P309xngK5nhLy1Dt/zwlxy+7zC/9ZR1bcN7bsRugGshhr+0TMVBI7z6GY/udhlaphwWSFKBDH9JKpDhL0kFMvwlqUCGvyQVyPCXpALV8qeeEdELXAwcA2wBzsvM9S3tZwLvaC7eDLw6Mxt11CJJ2lldI/9zgMHMPAl4M3DRXENEjAB/AjwnM08E7gL2q6kOSVIbdYX/KcA1AJl5I3BcS9vTgFuBiyLin4CfZ+Z9NdUhSWqjrvAfBTa0LM9ExNwppv2AZwBvAs4E/jAiHltTHZKkNuoK/3FgpHU/mTndnH8A+GZm/iwzNwFfBZ5cUx2SpDbqCv/rgbMAIuJEqtM8c74FPCEi9mt+GjgR+F5NdUiS2qjrxm5XAadHxA1AD3BuRFwArM/MqyPiLcC1zW0vy8zv1lSHJKmNWsI/M2eB8+etvr2l/TPAZ+rYtyRpaX7JS5IKZPhLUoEMf0kqkOEvSQUy/CWpQIa/JBXI8JekAi0a/hFxecv8mfWXI0nqhKVG/vu2zP/XOguRJHXOwznt01NbFZKkjlrq9g49ETFAdZCYm+8ByMytdRcnSarHUuF/BJBsH/Xf0fzZAI6qqyipVDOzDTZOTrFhYuFpfGKKn49v4XEHd7taLWeLhn9mPqpThUgrxfTMLOOT09uCul14LxTsGyenF+17oK+HsaEBDhhdzWmP3b9D70gr0ZJ39YyI/wj8DtUTuH4MfDoz/7HuwqRumpqZfZjBPb2tbdOWxQN8VX8vY0MD26YDRwd57IEjjA0NMNpcNzrYv32b4e3bDg300dPj5Tc9couGf0S8mupRi/8L+DnVaaC3RcRjMvMvOlCf9CvbOj1bBfZkm/DevPAplQ0TUzy0dWbRvlfPC/BDxgY5+qCRbeG9wzS84/LgQF+HfgPSwpYa+b8YODUz5/5P+E5EXAdcBxj+2iNcd9vPuOyff7zTqHxiavEAHxro2yGUD917mLFDti+PDvXvHOTN0bkBruVuqfDf2hL8AGTmlohY/HOt1EGfuumHfOPOX/DEQ8c4fN/htoHdekplLthX9xvgKtdS4T+7wHpPOmqP8tgD13LZH5zU7TKkZWOp8D+2+RzeVj3A0TXVI0nqgKXC/xjgDODLwFbgcOAJwD/UXJckqUZL3d7hZcDpwE8y827gR83ll9ZdmCSpPkuF/1nACzJzM0Bm3kX1N//PrbkuSVKNlgr/hzKz0boiM6eAjfWVJEmq21LhvzkidriHT3O5scD2kqRlYKkLvm8C/jYivgTcSXXB9wyqawGSpGVq0ZF/Zt4GnArcAqwBbgZOzsxbOlCbJKkmS97YLTM3AB/rQC2SpA7xAe6SVCDDX5IKZPhLUoEMf0kq0JIXfH8VEdELXEx1b6AtwHmZub7NNn8HfC4zP1xHHZKk9uoa+Z8DDGbmScCbgYvabPMeYJ+a9i9JWkRd4X8KcA1AZt4IHNfaGBG/TfWsAO8OKkldUFf4jwIbWpZnIqIfICKeALwIeHtN+5YkLaGWc/7AODDSstybmXOPfvxdYB3VMwKOBLZGxF2ZeU1NtUiS5qkr/K8HzgYui4gTgVvnGjLzjXPzEfFO4GcGvyR1Vl3hfxVwevMRkD3AuRFxAbA+M6+uaZ+SpF1US/hn5ixw/rzVt7fZ7p117F+StDi/5CVJBTL8JalAhr8kFcjwl6QC1fXXPtJu12g02LRlmg0TU9um8YkpfrZhktX9jmOkh8PwV0fNzjbYtHWaDZu3h/eGRabW9vHJaWZmG237ffbjD+zwO5GWN8NfD9vsbIONk9MLB/Zk+/CeW14gvwHo6+1hbGiAsaEBRocGGBtexWH7DG9bN38abf48eGywc78AaQUw/As1M9tg4+Suj7q3TZun2LhlmsYiAd4/L8D3Hl7FkfuuWTC4x4YGGBuufq5Z1UdPT0/nfhFSoQz/FebejZN88Xs/58HNi59S2Tg5vWg/q/p6m+Hcz9jQAPuvXc2j91/bPrhbwntsaIChAQNc2tMZ/ivMn3/lB/z19XcBsLq/d4eAPmh0kDhwZIfg3inEm9PgQK8BLq1ghv8KMzUzy97DA3z9Lf+ewYG+bpcjaQ/l38etQL09PQa/pEUZ/pJUIMNfkgpk+EtSgQx/SSqQ4S9JBTL8JalAhr8kFcjwl6QCGf6SVCDDX5IKZPhLUoEMf0kqkOEvSQUy/CWpQIa/JBXI8JekAhn+klQgw1+SCmT4S1KBDH9JKlB/HZ1GRC9wMXAMsAU4LzPXt7S/HvjPzcW/z8x31VGHJKm9ukb+5wCDmXkS8GbgormGiDgKeDHwNOAk4NkR8aSa6pAktVFX+J8CXAOQmTcCx7W0/Qj4D5k5k5mzwAAwWVMdkqQ2ajntA4wCG1qWZyKiPzOnM3MKuD8ieoA/AW7JzDtqqkOS1EZdI/9xYKR1P5k5PbcQEYPAJ5vbvKqmGorSaDSYnJphcmq226VIWgbqGvlfD5wNXBYRJwK3zjU0R/yfA76cme+raf/LUqPRYGJqhg0TU9W0eWr7/MQU4xM7Lm+fphmfmGLrTBX8B48NdvmdSNrT1RX+VwGnR8QNQA9wbkRcAKwH+oDTgNURcWZz+7dk5tdrqqWjGo0Gm7fOtA3phcN7e9vUTGPR/kcG+xkbGtg2HTg6uG1+tPnzSYeOdejdSlquagn/5oXc8+etvr1lfo8emjYaDTZtmd6F4J7eqX18Yorp2YUDvKcHRgcHdgjwQ8aGtgV3u2l0qAr8kcEB+np7OvibkLRS1TXy32Pc8+AEv3ho66Kj7vnhPj45zcwiAd7bw7xwHuCwvYd2GH23D/EBRlb302uAS+qyFR3+V978Yy647Ntt2/p7e7YF8ujQAGPDqzh83zWMDfW3De3W5bWr++npMcAlLV8rOvzv27gFgA+98CkcMLJ6hwAfXtVngEsq1ooO/znPOvoAhlcV8VYlaZd4YzdJKpDhL0kFMvwlqUCGvyQVyPCXpAIZ/pJUIMNfkgpk+EtSgQx/SSqQ4S9JBTL8JalAhr8kFcjwl6QCGf6SVCDDX5IKZPhLUoEMf0kqkOEvSQUy/CWpQIa/JBXI8JekAhn+klQgw1+SCmT4S1KBDH9JKpDhL0kFMvwlqUD9dXQaEb3AxcAxwBbgvMxc39L++8AfANPAezLzC3XUIUlqr66R/znAYGaeBLwZuGiuISIOAl4LnAycAVwYEatrqkOS1EZd4X8KcA1AZt4IHNfSdjxwfWZuycwNwHrgSTXVIUlqo5bTPsAosKFleSYi+jNzuk3bRmCsjiLO+PWDmJ5tMLyqrrcpSctTXSP/cWCkdT/N4G/XNgI8WEcRR+63hlc/49F1dC1Jy1pd4X89cBZARJwI3NrSdhNwakQMRsQYcDTw3ZrqkCS1Udf5kKuA0yPiBqAHODciLgDWZ+bVEfEh4J+oDj5vy8zJmuqQJLVRS/hn5ixw/rzVt7e0XwJcUse+JUlL80teklQgw1+SCmT4S1KBDH9JKpDhL0kFWhZffb3tttvuj4i7u12HJC0zRyzU0NNoNDpZiCRpD+BpH0kqkOEvSQUy/CWpQIa/JBXI8JekAhn+klSgZfF3/o9ERJwAvC8zf6PbtdQtIgaAvwKOBFYD78nMq7taVM0ioo/qDrEBzADnZuYPultV/SLiAOBbwOmZeftS2y93EXEL258A+G+ZeW436+mEiHgL8FxgFXBxZv7l7ux/RYd/RLwReCnwULdr6ZCXAA9k5ksjYl/gFmBFhz9wNkBmnhwRvwF8APjNrlZUs+ZB/iPARLdr6YSIGAQoYQA3p/lv+WnAycAw8IbdvY+VftrnB8Dzul1EB30W+KOW5emFNlwpMvNvgVc2F48Aft7Fcjrl/cCHgXu6XUiHHAMMR8R1EfHl5tMBV7ozqJ6AeBXweeALu3sHKzr8M/MKYKrbdXRKZm7KzI0RMQJcDvy3btfUCZk5HRH/B/jfVO97xYqIlwP3Zea13a6lgzZTHfDOoHpI1CcjYkWftQD2A44DXsD299yzO3ewosO/RBFxGPCPwMcz81PdrqdTMvNlwGOBSyJiTbfrqdErqB6R+hXgycDHIuKg7pZUuzuAT2RmIzPvAB4ADu5yTXV7ALg2M7dmZgKTwP67cwcr/ehZlIg4ELgOeE1mfqnb9XRCRLwUODQzL6QaIc5SXfhdkTLz6XPzzQPA+Zn5s+5V1BGvAJ4IvCoiDgFGgZ92t6TafQ14XUR8gOpAt4bqgLDbGP4ry1uBvYE/ioi5c/9nZuZKvjB4JfDXEfFVYAD4w8yc7HJN2r3+EvhoRHwNaACvyMwVfT0rM78QEU8HbqI6Q/PqzNytgxrv6ilJBfKcvyQVyPCXpAIZ/pJUIMNfkgpk+EtSgfxTTxUrIo4FLqS6d0ov1Zfj3pWZW3dD308HHszM70TElZn5vIh4IrB3Zn71kfYvPVKO/FWkiDgU+ATVF+JOobqB1hbgg7tpF68ADgHIzLn7Sz0fePxu6l96RPw7fxUpIt4KbMnMi1rW9QB3AvcCL8vM2yPifOCgzHxnRFxIdb+VEeD7mXluRLwTeBRwANWN5V4P3A/8XbOf51B9UedY4HpgK9XdV/80M49v7vdvgPdn5jfrf+dSxZG/SnUEVdBvk5kNqruC7nSvnIgYBX6ZmadT3Wr3xIhY12zekplnAq8DXp+Z3wKuAd6YmT9s9v0T4KPABzLzJmAiIh4fEfsAjzL41Wme81ep7gaOal0REb3A4cBPWlbP3UlxAjggIj4NbALWUt1OAqrnJgD8CBjcxf1fArwc+CHV6Sepowx/lerjwHURcTVwH3AZ8GOq+6YfTnUzrduBp1IdDM4EDsvM34mI/YHfYvuBod2501l2/mTduu5yqgd0PEB1216pozztoyJl5o9onnunOj+/P1XgrwI+BvxZRFwL9DVfchNwVETcSBXcd9K8oLuAbwDvjYijW9Z9C3hNRDyjefO5rwL3ZuYvdt87k3aNF3ylFhHxJODOzNzUgX1dDFyemV+ue1/SfIa/1AURcR1wT2a+vNu1qEyGvyQVyHP+klQgw1+SCmT4S1KBDH9JKpDhL0kF+v+ijR1Z3B1r/QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ps = np.linspace(0, 1)\n",
    "qs = d6.quantile(ps)\n",
    "plt.plot(qs, ps)\n",
    "decorate_cdf('Inverse evaluation')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These functions provide a simple way to make a Q-Q plot.\n",
    "\n",
    "Here are two samples from the same distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "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": [
    "cdf1 = Cdf.from_seq(np.random.normal(size=100))\n",
    "cdf2 = Cdf.from_seq(np.random.normal(size=100))\n",
    "\n",
    "cdf1.plot()\n",
    "cdf2.plot()\n",
    "decorate_cdf('Two random samples')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's how we compute the Q-Q plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def qq_plot(cdf1, cdf2):\n",
    "    \"\"\"Compute results for a Q-Q plot.\n",
    "    \n",
    "    Evaluates the inverse Cdfs for a \n",
    "    range of cumulative probabilities.\n",
    "    \n",
    "    :param cdf1: Cdf\n",
    "    :param cdf2: Cdf\n",
    "    \n",
    "    :return: tuple of arrays\n",
    "    \"\"\"\n",
    "    ps = np.linspace(0, 1)\n",
    "    q1 = cdf1.quantile(ps)\n",
    "    q2 = cdf2.quantile(ps)\n",
    "    return q1, q2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is near the identity line, which suggests that the samples are from the same distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "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": [
    "q1, q2 = qq_plot(cdf1, cdf2)\n",
    "plt.plot(q1, q2)\n",
    "plt.xlabel('Quantity 1')\n",
    "plt.ylabel('Quantity 2')\n",
    "plt.title('Q-Q plot');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's how we compute a P-P plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pp_plot(cdf1, cdf2):\n",
    "    \"\"\"Compute results for a P-P plot.\n",
    "    \n",
    "    Evaluates the Cdfs for all quantities in either Cdf.\n",
    "    \n",
    "    :param cdf1: Cdf\n",
    "    :param cdf2: Cdf\n",
    "    \n",
    "    :return: tuple of arrays\n",
    "    \"\"\"\n",
    "    qs = cdf1.index.union(cdf2)\n",
    "    p1 = cdf1(qs)\n",
    "    p2 = cdf2(qs)\n",
    "    return p1, p2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here's what it looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAESCAYAAAAVLtXjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deXhV5bn+8W8SEsIU5nlG4AEZFRRQrOKM1eNwtIPW9thatU6tnmr1d86pVVtta6mttrba1trhOKFQERXnOqBUZR4fjAgkzFMSyDzs3x97wwmQhABZe2XvfX+ui6usgex71XDzZg3vSotEIoiISGpJDzuAiIjEn8pfRCQFqfxFRFKQyl9EJAWp/EVEUpDKX0QkBbUIO4BIvJjZAOAzYGmt1WnAr9398Tr2Pw14BXAgEtu3Crjb3V88jM/9EdDF3W88xH6vAZe7+/bGfm2RI6Xyl1RT6u5j9y6YWW9gmZl94u5L6tj/swP2HwPMNbOB7r6tibOd1cRfT6ReKn9Jae6+wcw+BYYCdZX/gfsvNrMSoD+wr/xjP1W8A8wBJhD9KeFGd3+v9p83sxHAb4DORH+amObufzWzP8d2edvMznP3vKM+OJEG6Jy/pDQzmwQMBv7VyP0vAWqAFXVs7ge8E/tJ4Q7gGTPLrPVnWwCzgIfdfTQwFbjPzCa5+1Wx3aao+CUeNPKXVNPKzBbFft8C2A5c0UDhHlNr/0wgD7jQ3Uvq2HeXuz8J4O6vmFk1MLrW9qFAtrvPiO2z0cyeB84FPjyqoxI5TCp/STX7nfOvzcz+CIyPLf4eWMUB5/wPoeqA5XSgutZyBtFTPQfuk4lInOm0j0iMu1/t7mNjv35/BF+iq5mdC2BmFwCV7H9n0SqgMnbqCDPrBfw78HpsezX6h0DiROUv0nTKgCvNbDHwX8BF7r5v5O/ulcBFwHfNbAnwBnCPu78d22U68I6ZjYxzbklBaZrSWeToxe72WebubcPOItIYGvmLiKQgjfxFRFKQRv4iIilI5S8ikoIS4j7/CRMmRHr37h12DBGRhLJ8+fLt7t61rm0JUf69e/dmxowZYccQEUkoZrauvm067SMikoJU/iIiKUjlLyKSglT+IiIpSOUvIpKCVP4iIikosPI3swlm9s861l9gZh+b2Ydm9u2gPl9EROoXSPmb2e3AH4HsA9ZnAg8CZwOnAteYWY8gMoiIJLKamggzF+ZTWFIZyNcPauT/GXBJHeuHA7nuvsvdK4D3gVMCyiAikrAe+WcutzyzmBWbigL5+oGUv7s/T/QtRgfKAQprLe8G2geRQUQkUX342Q5++fpqLhzbi4mDOgXyGfG+4FsEtKu13A4oiHMGEZFma9vucm5+eiEDurThvotHkZaWFsjnxHtun5XAEDPrBOwBvgD8Is4ZRERCVVhSyeylG6moqjlo28tLN7G7rJK/fetE2rQMrqLjUv5mdjnQ1t0fM7NbgVeJ/tTxuLtviEcGEZHm4PUVW/ivmUvZuru8zu0t0tP46b+PZliPnEBzBFb+7r4WmBj7/ZO11r8IvBjU54qINEe7yyr5n38s4x+LNjKsRzsevXIcA7u0OWi/zIz0QEf8eyXElM4iIoksEolw67OLeWvVVr57xhBumDKYrBbhPmOr8hcRCdif3v+c11ds4YfnH8s3Jw8MOw6g6R1ERAI1f90ufvrKKs4d0YOrTh4Qdpx9VP4iIgHZsaecm55cQM8O2fzs0tGB3bZ5JHTaR0QkAG+v2sqdM5ays7iC579zEu1bZYYdaT8qfxGRo1RYUsmi/OjzqpFIhBcXb+L5BfkM7d6WR68cx6g+zW8iA5W/iMhRuunphby7etu+5Yz0NG6cMpibzhhMyxYZISarn8pfROQozF+3k3dXb+PaUwdx9rHRSYq757SkT8fWISdrmMpfROQoPPj6p3Ruk8V3zxhC66zEqVTd7SMicoQ+XruT93O3c+2pgxKq+EHlLyJyxH71xmq6tM3iaxP7hx3lsCXWP1UiIiEqLq9iY0EpAJ9u3cPc3B389xeHJ9yoH1T+IiKN9q2/fMy8NTv3LXdp25IrJiTeqB9U/iIijbJ9Tzn/+nwnlxzXm9OHdwNgWI8cWmU1z1s5D0XlLyLSCG+t2kokAt+cPJCRvZvfQ1uHSxd8RUQa4c2VW+jZPpsRvYJ9yUq8qPxFRA6hrLKa9z7dzunDujWrydmOhspfROQQ5q3ZQUlFNWce2z3sKE1G5S8icghvrtxK66wMJg3qHHaUJqPyFxFpQCQS4c2VW5g8uAvZmYl5Z09dVP4iIg1YsamIjYVlnDk8eU75gMpfRKRBb67cSloaTBnWLewoTUrlLyLSgHdWb2N0nw50bdcy7ChNSuUvItKAwtJK+nRoFXaMJqcnfEUkJVVV13D+w++zITZRW332lFdhPdrFKVX8qPxFJCWVVFazavNuThzQiRG9G35q94IxveKUKn5U/iKSMuYs28wDr66iqKyKSCQCwDkje/CtyQNDThZ/Kn8RSXo7iyu4a9ZyXly8kWE92u27bTMzI42zk+ip3cOh8heRhPXJ2p3c/vwSqqojDe63s7iC8qpq/vOsoVx32jFkZuheF5W/iCSsJfmFrNlWzBdH9SSrRf2F3rJFOv9x8gCG9UiOGTmbgspfRBLK+59u5ycvr6SmJsLOkgoA7rt4FO1bZ4acLLGo/EUkoXz0+Q5Wbiri3BE9GEgbenVoRU4rVdnhCuT/MTNLBx4BxgDlwNXunltr+/eBrwI1wH3uPjOIHCKSHN5YsYXfvJ1LBNhcWEpaGvz+ynFhx0poQV31uAjIdvdJwB3AtL0bzKwDcDMwCTgb+FVAGUQkSbyzehvLNhTSoVUmw3rkcHUK3prZ1IL6WWkyMAfA3eeZ2fha24qBdUCb2K+agDKISAJ7ackm/vrhWgA+315MTqtM/vLNE0PNlEyCGvnnAIW1lqvNrPY/NHnACmAB8FBAGUQkgb2ybBOL8wsAGNilDV8+oW/IiZJLUCP/IqD2ZBjp7l4V+/1UoCew9+e2V81srrt/FFAWEUkQMxfm88KijQAs31hErw6teObaSSGnSk5BjfznAucBmNlEYGmtbbuAUqDc3cuAAqBDQDlEJIE8P38DH32+k13FFfRqn835o5NvTp3mIqiR/0zgLDP7AEgDrjKzW4Fcd59lZmcC88ysBngfeD2gHCLSjJVVVvPYu2tYuakIgJWbihjeM4fnv3NSyMmSXyDl7+41wHUHrF5Va/tdwF1BfLaIJIYF63dx2/TFfLatmGO6tiEjPY3ObbM4PcnemNVc6ckIEYm7P7y7hvtfWUmPnGz+8s0TOXVo17AjpRyVv4jE3RMfrOW4fh154qoTaJetaRnCoPIXkcA8+s5nrN1RctD6XSUVTDqms4o/RCp/EQlEeVU197+yijZZGbRuuX/VtGnZguP66Sa/MKn8ReSoVNdE+M1buRSWVh6wPvrw/vVTBnPDlMFhRJMGqPxF5Kjkbt3Dg2+sJjszncz0/R8d6tA6k2FJ+PLzZKDyF5GjEiH6Fq0HvzSWqaN6hpxGGkvvMhMRSUEqfxGRFKTyFxFJQTrnLyKHrbK6hufm51NcXsXW3eVhx5EjoPIXkcO2KK+AO2f832S9GelpdG+fHWIiOVwqfxE5bFXV0Tt8Hv+P8ZwwoBOZGelkZ2aEnEoOh8pfRI5Yq8wWmqIhQemCr4hIClL5i4ikIJ32EZH9FJdX8d6n26muidS7z+otu+OYSIKg8heR/Tz9cR73zl7RqH07tNb5/kSl8heR/ZRVVgMw+6bJZLWo/8xw66wM+nRsHa9Y0sRU/iJSpyHd29KyhW7fTFYqf5EUtae8iiV5BQetX1/Hm7ck+aj8RVLUA3NW8ZcP19W5LTsznYy0tDgnknhS+YskucLSSj7btueg9et3ltClbRa/vfz4g7Z1z8mmRYbuBE9mKn+RJHfzUwt5Z/W2OrcN7taWCYM6xzmRNAcqf5Ekt6e8imN75nD7uXbQtmO6tg0hkTQHKn+RJFZUVkn+rhJG9mrPadYt7DjSjOiknkiSikQi3PH8ErbvqeC6044JO440Myp/kST11w/X8fLSzdx2jnHCgE5hx5FmRuUvkoQW5xXw45dWcPqwblxzyqCw40gzpPIXSUL3zF5Bl7YtmXbZGNLTdb++HEwXfEWSRGV1DSXl0Xl5duwpZ1z/jnRskxVyKmmuVP4iCS4SiTB7ySbumrWcncUV+9Yf169jiKmkuVP5iySwrbvL+J9/LOPV5VsY06c9N0wZzN6TPKcP062dUr9Ayt/M0oFHgDFAOXC1u+fW2j4VuCu2uAC4wd3rf3OEiNTpy4/OY0NBKXdMHcbVkwdqSgZptKC+Uy4Cst19EnAHMG3vBjNrBzwAnO/uE4G1QJeAcogktbU7ivn2KQO57tRjVPxyWIL6bpkMzAFw93nA+FrbTgKWAtPM7D1gi7vXPfGIiBySZt+UIxFU+ecAhbWWq81s7ymmLsAU4AfAVOB7ZjY0oBwiIlKHoC74FgHtai2nu3tV7Pc7gI/dfTOAmb0LjAVWB5RFJGm8vHQTP3lpJbtKonf1RCKQppG/HIGgyn8ucAHwrJlNJHqaZ6/5wEgz6wIUABOBPwSUQyQpbN9Tzl0vLOelpZsY0SuH80b1ACA9PY1/P75PyOkkEQVV/jOBs8zsAyANuMrMbgVy3X2Wmd0JvBrb91l3XxZQDpGEV1xexRcfeo9dxZXcdo5xzRcGkamLu3KUAil/d68Brjtg9apa258Gng7is0WSzdbd5WwpKue+i0dx+YR+YceRJKHhg0iCaJ2VEXYESSIqfxGRFNTgaR8zOx8oc/c3aq270N1fCDyZSAr7bNsebpu+mMLSSiqr9fC7NL16y9/MHgE6AC3M7BbgEncvB74LqPxFAlJaUc0N/7uAzUVlnDw4+vD7+AEdmagXrUsTamjkP9rdJwOY2U3AM0SnbdBNxSIB+tGs5azavJsnrjpB792VwDR0zr+FmbUEcPeHgU/N7KH4xBJJTTMW5PPMJ3ncMOUYFb8EqqGR/6+BZWZ2UmzunduBx4BT4pJMJAlFIhGmz8/nufn51NQcfC5/2cZCJgzsxC1nasYTCVa9I393fwoYBWyPLUfc/dvACXHKJpJUNhaU8o0/f8ztzy2hsKSSlpnpB/06Y1h3HvrqcZqhUwLX4N0+7l5Wx7qFwcURSU5v+1ZuenIhNZEI91w4gq9N6K9360qo9CYvkYCt31HCzU8tpG+n1jz6tXH069w67Egi9Z/2MbM/x/732vjFEUku5VXV3PDkAtKAx65U8Uvz0dDIf6yZPQBcZmb9a29w9/8XbCyR5HDfSytZuqGQR68cR99OKn5pPhoq/4uJvpHrfMDjE0ckecxZtpm/fLiOqycP5JwRPcKOI7Kfesvf3dcCa83sn+6eH79IIomvsrqGn7y8guE9c/jB1GFhxxE5SEPTO2wCIkBLM2sN5AF9gK3uPiA+8UQS04wF+eTtLOVP3xihufelWWroPv+e7t4LeAUY6u5DgcHAv+IVTiQRVVTV8PBbuYzp057Th+kpXWmeGjMkGeTueQDuvhHQ2yREGjBjQT75u0r53plD9X5dabYac5//CjP7G/ARMAl4L9hIIolr36i/bwdOs65hxxGpV2PK/xpgKjACeMrdXww2kkjz9/aqrcxbs+Og9fkFpWwoKOXHF4/UqF+atUO9zOUa4HF3f8nMioj+AyCS0j76fCdX//UTMtLSSK/jxOlp1pXThmrUL81bQ3f7/AgYCfwdqCJ6t88tZtbN3e+JTzyR5mX7nnJuemoB/Tq1ZtaNJ9MuOzPsSCJHpKELvlOBy9y9BPbd9/9l4II45BJpdmpqItzyzCJ2lVTy28uPV/FLQmvotM8ed99vwnF3rzSz3QFnEmk2Xlu+mTXbiwFYvWU37326nfsvGcWxvXJCTiZydBoq/1IzG+Tua/auMLNBRB/8Ekl6mwpLue7v86n9zpWvntiXr5zQN7xQIk2kofL/AfAPM3sTWEP0/v5zgG/EI5hI2GYs2EBNBF675Qv07RidlK1VVkbIqUSaRkNP+C4n+srGhUAbYAFwsl7mIqkgEonw3Px8ThzQiaHd29EqK0PFL0nlUG/yKgT+GqcsIs3GgvW7+Hx7Md857Ziwo4gEQjNOidRh+if5tMrM4LxRPcOOIhIIlb/IAUorqpm9ZBPnjepJ25Z606kkJ5W/yAHmLN/EnvIqLhvfJ+woIoHRsEaSWnVNhA8/20FJRVWj/8xfP1xH306tOHFApwCTiYRL5S9J7d7ZK3jig7WH/eduO8dIT9fEbJK8VP6StF5euoknPljL1yb24ysnNP41FBnpaQzp1jbAZCLhC6T8zSwdeAQYA5QDV7t7bh37vAS84O6/DyKHpK6124u5/bkljOnbgR+eP4KsFrq8JVJbUH8jLgKy3X0ScAcwrY59fgzopKo0ubLKaq7/3wVkpKfx28uPU/GL1CGovxWTgTkA7j4PGF97o5ldCtQQfT+wSJOaPj+fFZuK+MVlY+gTm5ZBRPYXVPnnAIW1lqvNrAWAmY0ELgd+GNBnS4qbv3Yn3dq15Mzhenm6SH2CuuBbBLSrtZzu7nvvtfs60Bt4CxgAVJjZWnefE1AWSTGL8goY27eDXqMo0oCgyn8u0Ze+PGtmE4Gleze4++17fx97W9hmFb80lV3FFazdUcKXNO2ySIOCKv+ZwFlm9gGQBlxlZrcCue4+K6DPFGFRXgEAx/XtGHISkeYtkPJ39xrgugNWr6pjvx8F8fmSuhbmFZCeBqP7tA87ikizpnvgJKksyitgaPd2tNGEbCINUvlL0ohEIiyOXewVkYap/CVpfL69mMLSSpW/SCOo/CVpLFwfu9jbTxd7RQ5F5S9JY1FeAW2yMhisSdlEDknlL0ljUV4Bo/t0IENTMYsckspfkkJZZTUrNxUxtp/O94s0hspfksLyjYVU1UQ4Thd7RRpF5S8Jr7C0ksfeXQOgkb9II+lJGElob63awp0zlrJtdzm3njWUbu2yw44kkhBU/tKsRSIRfvjCcl5YtOHgbcDusiqGdm/LY1eOZ4xO+Yg0mspfmrW/z1vH3+at45wR3enZvtVB2/t0bMWVk/rTskVGCOlEEpfKX5qtpfmF3Dt7JVOsK7+7YhzpuoVTpMnogq80S0Vlldzw5AI6t81i2pfGqvhFmphG/tLsbCkq45ZnFrGhoJRnr51IpzZZYUcSSToqf2k2IpEIzy/YwD0vLqe8qob7LxnFuP6dwo4lkpRU/tIs1NREuPnphcxesokTBnTk55eOYWCXNmHHEklaKn9pFn73zmfMXrKJW88ayo1TBuscv0jAVP4SunlrdjDtNeeCMb246fTBpKWp+EWCprt9JFTbdpdz81MLGdC5DfdfMkrFLxInGvlLXFVU1XDXrOWs3V4MwIaCUgpLK/nLN0+krd67KxI3GvlLXN338kqe+mg9FdU1VNdE6Nk+m19/ZSzDe+aEHU0kpWioJXHz8tJNPPHBWq46eQB3XTAi7DgiKU0jf4mLdTuK+cFzSxjTtwN3Th0edhyRlKfyl8BtLizjO39fQFoa/Oarx5HVQt92ImHTaR8JTCQSYfr8fO6dvYLK6hp+d8U4+nZqHXYsEUHlLweYt2YHz36S1yRfK29nCR+v3cWEgZ34+aWj6d9ZT+yKNBcqf9mnsrqG259bwo495XRsgsnUsjLSufvfRnDlxP56YlekmVH5yz4zF2xg/c4S/vSN8ZwxvHvYcUQkQLryJkB01P/w258yuk97Th/WLew4IhIwlb8AMGNBPnk7S/nemUM0xYJIClD5CxVVNTz8Vi5j+nZgimnUL5IKdM4/CUQiEZ75OI/8XaVH9OfzdpWQv6uUey8aqVG/SIoIpPzNLB14BBgDlANXu3ture23AF+JLb7s7ncHkSNVPD53LffOXkF6Gkdc3qcM6cJpQ7s2cTIRaa6CGvlfBGS7+yQzmwhMAy4EMLNBwBXABCACvGdmM919SUBZktrC9bu4/+WVnHVsdx67cpxG7iLSKEGd858MzAFw93nA+Frb8oBz3b3a3WuATKAsoBxJraCkghufXEiP9tn84tIxKn4RabSgRv45QGGt5Woza+HuVe5eCWw3szTgAWChu68OKEfCKyqrZNaijZRX1Ry07c2VW9i6u4znrjuJ9q0zQ0gnIokqqPIvAtrVWk5396q9C2aWDTwO7AauDyhDwvunb+XOGUvZVFj3D0bpaXD3hSMZ07dDnJOJSKILqvznAhcAz8bO+S/duyE24n8BeMvdfxbQ5ye0kooq7nphOdPn5zO4W1ueu24SQ7q3O2i/FulptNHbr0TkCATVHDOBs8zsAyANuMrMbgVygQzgVKClmU2N7X+nu38YUJaEEolEuOP5pcxespHrTzuGm88YQnZmRtixRCTJBFL+sQu51x2welWt32cH8bnJ4MmP1jNr8Ua+f/ZQbjx9SNhxRCRJ6QnfZmTZhkLufnEFXxjaletPGxx2HBFJYjphHKLdZZXMzd1BJBIhAvx8zio6tc7iwS+N0RTIIhIolX+Ipr22mic+WLtvOTMjjSe/PZHObVuGF0pEUoLKPyTlVdX8Y9EGzhzene+fMxSAzm1a0rWdil9EgqfyD8mbK7dSUFLJlZP6M6xHTthxRCTF6IJvSJ6bn0+PnGwmD+4SdhQRSUEq/xBsLSrjn76VS47vTYYu7IpICFT+IZi5cAM1Ebh0XJ+wo4hIilL5x1kkEmH6/HzG9e/IoK5tw44jIilKF3yP0u6ySjYUNP4NWp9vKyZ36x5+esmoAFOJiDRM5X8Utu4u44KH32dLUflh/blWmRmcN7pnQKlERA5N5X+EqmsifPepRRSWVvKLy8bQJqvxk6/169yanGzNvy8i4VH5H6Ffv7GaD9fs4IFLR+vCrYgkHF3wPQLvrt7Gw2/ncum4Plw2vm/YcUREDptG/ochEokw/ZN87p29giHd2nLvhSPDjiQickRU/g0oq6ze9+7cncUV3DVrOe+u3saJAzvxyy+NodVhnOcXEWlOVP51qK6J8Oe5n/OL15yyyv97cXrrrAzuuXAEX5vQX1Mui0hCU/kf4LNte7ht+mIWrC/gjGHdOCk29056Gpw5vDt9O7UOOaGIyNFT+cdU10T443trmPb6alplZvCrL4/lwrG9SEvTCF9Eko/KH8jdupvvT1/CorwCzj62Oz++eCTd2uk1wyKSvFK6/Kuqa/jDe5/z4BuraZOVwUNfPY4LRvfUaF9Ekl7Klv/qLbu5bfpiFucXcu6IHtx70Ui9RUtEUkbKlX9VdQ2PvruGX7/xKW2zW/Cby4/ji6M02heR1JJS5b9yUxG3PbeYZRuK+OLontzzbyP0snQRSUkpU/6vLd/MDU8uICc7k0euOJ7zRmlWTRFJXSlR/ut3lPCf0xczvGcOT1x1Ip3aZIUdSUQkVEk/sVtZZTXXPzmfNOC3lx+v4hcRIQVG/j95aSXLNhTxh6+P19O5IiIxST3yn7dmB3+bt45rvjCIs47tHnYcEZFmI6lH/t1zsrn5jCHcdPrgsKOIiDQrSV3+A7u04dazhoYdQ0Sk2Unq0z4iIlK3QEb+ZpYOPAKMAcqBq909t9b2bwPXAlXAj919dhA5RESkbkGN/C8Cst19EnAHMG3vBjPrAdwMnAycA9xvZnrMVkQkjoIq/8nAHAB3nweMr7XtRGCuu5e7eyGQC4wOKIeIiNQhqPLPAQprLVebWYt6tu0G2geUQ0RE6hBU+RcB7Wp/jrtX1bOtHVAQUA4REalDUOU/FzgPwMwmAktrbfsIOMXMss2sPTAcWBZQDhERqUNQ9/nPBM4ysw+ANOAqM7sVyHX3WWb2EPAe0X98/svdywLKISIidUiLRCJhZzgkM9sGrAs7h4hIgunv7l3r2pAQ5S8iIk1LT/iKiKQglb+ISApS+YuIpCCVv4hIClL5i4ikIJW/iEgKSuiXuaTi1NGNOOZbgK/EFl9297vjn7LpHeq4a+3zEvCCu/8+/imbViP+W08F7ootLgBucPeEv3e7Ecf9feCrQA1wn7vPDCVoAMxsAvAzdz/tgPUXAD8k2mWPu/sfjvazEn3kn4pTRzd0zIOAK4CTgEnA2WaWLDOm1nvctfwY6BTXVMFq6L91O+AB4Hx3nwisBbqEETIADR13B6J/rycBZwO/CiVhAMzsduCPQPYB6zOBB4ke76nANbF+OyqJXv6pOHV0Q8ecB5zr7tXuXgNkAskydUZDx42ZXUp0JPhK/KMFpqFjPononFnTzOw9YIu7b4t/xEA0dNzFRJ/2bxP7VRP3dMH5DLikjvXDiU6Ns8vdK4D3gVOO9sMSvfxTceroeo/Z3SvdfbuZpZnZL4CF7r46lJRNr97jNrORwOVEfyxOJg19f3cBpgA/AKYC3zOzZHlhdUPHDdFBzgqip7oeimewILn780BlHZsC6bJEL/9UnDq6oWPGzLKB/43tc32cswWpoeP+OtAbeAv4D+BWMzs3vvEC0dAx7wA+dvfN7r4HeBcYG++AAWnouKcCPYGBQD/gIjM7Mc754i2QLkv08k/FqaPrPWYzSwNeABa7+7XuXh1OxEDUe9zufru7T4hdJHsC+KW7zwkjZBNr6Pt7PjDSzLrERsUTiY6Gk0FDx70LKAXKY7MBFwAd4p4wvlYCQ8ysk5llAV8APjzaL5rQd/uQmlNH13vMQAbRC0ItY3eCANzp7kf9jdIMNPjfOtxogTnU9/edwKuxfZ9192QY3MChj/tMYJ6Z1RA9//16iFkDY2aXA23d/bHY8b9KtMsed/cNR/v1NauniEgKSvTTPiIicgRU/iIiKUjlLyKSglT+IiIpSOUvIpKCEv1WT5EmZ2YjgJ8DrYG2wMvAjw6cNM3MNrt7DzMbSPT2xMXu/o0D9mlN9FbEb7n7qrgcgEgjaOQvUkts4rCnge+5+xSiD0+NIjo7bH1OBt6so/jHE33y9piA4oocMY38RfZ3IfCWu38K4O7VZvZ1oMLMMoDHgBFEJ+FqaWb9gP8GWptZrrv/rtbXaglcDPwtrkcg0gga+YvsrxewpvYKd98Tm01xKtGphicCdwKt3X098FPgyQOKH3ef6+55ccotcr4vaDAAAACUSURBVFg08hfZ3zrg+NorYuf0+xId8X8E4O7rzUzFLglLI3+R/c0GzjWzY2DfizR+CYwEVhF9iQhm1ovoTKIiCUnlL1KLuxcB3wD+YGb/BOYBi4HfufsLQJ6Z/YvoG6S2hxZU5ChpYjcRkRSkkb+ISApS+YuIpCCVv4hIClL5i4ikIJW/iEgKUvmLiKQglb+ISAr6/3x3VkocfTRnAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "p1, p2 = pp_plot(cdf1, cdf2)\n",
    "plt.plot(p1, p2)\n",
    "plt.xlabel('Cdf 1')\n",
    "plt.ylabel('Cdf 2')\n",
    "plt.title('P-P plot');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Statistics\n",
    "\n",
    "For comments or questions about this section, see [this issue](https://github.com/AllenDowney/EmpyricalDistributions/issues/17).\n",
    "\n",
    "`Cdf` overrides the statistics methods to compute `mean`, `median`, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def mean(self):\n",
      "        \"\"\"Expected value.\n",
      "\n",
      "        :return: float\n",
      "        \"\"\"\n",
      "        return self.make_pmf().mean()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf.mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def var(self):\n",
      "        \"\"\"Variance.\n",
      "\n",
      "        :return: float\n",
      "        \"\"\"\n",
      "        return self.make_pmf().var()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf.var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.916666666666667"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def std(self):\n",
      "        \"\"\"Standard deviation.\n",
      "\n",
      "        :return: float\n",
      "        \"\"\"\n",
      "        return self.make_pmf().std()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf.std)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7078251276599332"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sampling\n",
    "\n",
    "For comments or questions about this section, see [this issue](https://github.com/AllenDowney/EmpyricalDistributions/issues/18).\n",
    "\n",
    "`choice` chooses a random values from the Cdf, following the API of `np.random.choice`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def choice(self, *args, **kwargs):\n",
      "        \"\"\"Makes a random sample.\n",
      "\n",
      "        Uses the probabilities as weights unless `p` is provided.\n",
      "\n",
      "        args: same as np.random.choice\n",
      "        options: same as np.random.choice\n",
      "\n",
      "        :return: NumPy array\n",
      "        \"\"\"\n",
      "        # TODO: Make this more efficient by implementing the inverse CDF method.\n",
      "        pmf = self.make_pmf()\n",
      "        return pmf.choice(*args, **kwargs)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf.choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 5, 4, 6, 3, 1, 2, 4, 2, 5])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.choice(size=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sample` chooses a random values from the `Cdf`, following the API of `pd.Series.sample`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def sample(self, *args, **kwargs):\n",
      "        \"\"\"Makes a random sample.\n",
      "\n",
      "        Uses the probabilities as weights unless `weights` is provided.\n",
      "\n",
      "        This function returns an array containing a sample of the quantities in this Pmf,\n",
      "        which is different from Series.sample, which returns a Series with a sample of\n",
      "        the rows in the original Series.\n",
      "\n",
      "        args: same as Series.sample\n",
      "        options: same as Series.sample\n",
      "\n",
      "        :return: NumPy array\n",
      "        \"\"\"\n",
      "        # TODO: Make this more efficient by implementing the inverse CDF method.\n",
      "        pmf = self.make_pmf()\n",
      "        return pmf.sample(*args, **kwargs)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf.sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 6, 4, 4, 5, 2, 2, 2, 4])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.sample(n=10, replace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic\n",
    "\n",
    "For comments or questions about this section, see [this issue](https://github.com/AllenDowney/EmpyricalDistributions/issues/9).\n",
    "\n",
    "`Cdf` provides `add_dist`, which computes the distribution of the sum.\n",
    "\n",
    "The implementation uses outer products to compute the convolution of the two distributions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def add_dist(self, x):\n",
      "        \"\"\"Computes the distribution of the sum of values drawn from self and x.\n",
      "\n",
      "        x: Distribution, scalar, or sequence\n",
      "\n",
      "        :return: new Distribution, same subtype as self\n",
      "        \"\"\"\n",
      "        pmf = self.make_pmf()\n",
      "        res = pmf.add_dist(x)\n",
      "        return self.make_same(res)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf.add_dist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def make_same(self, dist):\n",
      "        \"\"\"Convert the given dist to Cdf\n",
      "\n",
      "        :param dist:\n",
      "        :return: Cdf\n",
      "        \"\"\"\n",
      "        return dist.make_cdf()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "psource(Cdf.make_same)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the distribution of the sum of two dice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.027778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.083333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.166667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.277778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.416667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.583333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.722222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.833333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>0.916667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0.972222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "2     0.027778\n",
       "3     0.083333\n",
       "4     0.166667\n",
       "5     0.277778\n",
       "6     0.416667\n",
       "7     0.583333\n",
       "8     0.722222\n",
       "9     0.833333\n",
       "10    0.916667\n",
       "11    0.972222\n",
       "12    1.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6 = Cdf.from_seq([1,2,3,4,5,6])\n",
    "\n",
    "twice = d6.add_dist(d6)\n",
    "twice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.000000000000002"
      ]
     },
     "execution_count": 65,
     "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": [
    "twice.step()\n",
    "decorate_dice('Two dice')\n",
    "twice.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To add a constant to a distribution, you could construct a deterministic `Pmf`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.166667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.666667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.833333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "2    0.166667\n",
       "3    0.333333\n",
       "4    0.500000\n",
       "5    0.666667\n",
       "6    0.833333\n",
       "7    1.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const = Cdf.from_seq([1])\n",
    "d6.add_dist(const)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But `add_dist` also handles constants as a special case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.166667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.666667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.833333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "2    0.166667\n",
       "3    0.333333\n",
       "4    0.500000\n",
       "5    0.666667\n",
       "6    0.833333\n",
       "7    1.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.add_dist(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other arithmetic operations are also implemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>-3</th>\n",
       "      <td>0.041667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>-2</th>\n",
       "      <td>0.125000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>-1</th>\n",
       "      <td>0.250000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.416667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.583333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.750000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.875000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.958333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "-3    0.041667\n",
       "-2    0.125000\n",
       "-1    0.250000\n",
       " 0    0.416667\n",
       " 1    0.583333\n",
       " 2    0.750000\n",
       " 3    0.875000\n",
       " 4    0.958333\n",
       " 5    1.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4 = Cdf.from_seq([1,2,3,4])\n",
    "d6.sub_dist(d4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0625</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.1875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.3125</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.5000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.6250</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.7500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.8125</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>0.9375</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>1.0000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "1     0.0625\n",
       "2     0.1875\n",
       "3     0.3125\n",
       "4     0.5000\n",
       "6     0.6250\n",
       "8     0.7500\n",
       "9     0.8125\n",
       "12    0.9375\n",
       "16    1.0000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.mul_dist(d4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>probs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0.250000</th>\n",
       "      <td>0.0625</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0.333333</th>\n",
       "      <td>0.1250</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0.500000</th>\n",
       "      <td>0.2500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0.666667</th>\n",
       "      <td>0.3125</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0.750000</th>\n",
       "      <td>0.3750</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1.000000</th>\n",
       "      <td>0.6250</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1.333333</th>\n",
       "      <td>0.6875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1.500000</th>\n",
       "      <td>0.7500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2.000000</th>\n",
       "      <td>0.8750</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3.000000</th>\n",
       "      <td>0.9375</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4.000000</th>\n",
       "      <td>1.0000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "0.250000    0.0625\n",
       "0.333333    0.1250\n",
       "0.500000    0.2500\n",
       "0.666667    0.3125\n",
       "0.750000    0.3750\n",
       "1.000000    0.6250\n",
       "1.333333    0.6875\n",
       "1.500000    0.7500\n",
       "2.000000    0.8750\n",
       "3.000000    0.9375\n",
       "4.000000    1.0000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.div_dist(d4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison operators\n",
    "\n",
    "`Pmf` implements comparison operators that return probabilities.\n",
    "\n",
    "You can compare a `Pmf` to a scalar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3333333333333333"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.lt_dist(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.75"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.ge_dist(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or compare `Pmf` objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.gt_dist(d6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.41666666666666663"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.le_dist(d4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.16666666666666666"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4.eq_dist(d6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interestingly, this way of comparing distributions is [nontransitive]()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = Cdf.from_seq([2, 2, 4, 4, 9, 9])\n",
    "B = Cdf.from_seq([1, 1, 6, 6, 8, 8])\n",
    "C = Cdf.from_seq([3, 3, 5, 5, 7, 7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5555555555555556"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.gt_dist(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5555555555555556"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.gt_dist(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5555555555555556"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.gt_dist(A)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}