cdf.ipynb

{
 "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 Cdf.\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:\n",
      "            super().__init__(*args, **kwargs)\n",
      "        else:\n",
      "            underride(kwargs, dtype=np.float64)\n",
      "            super().__init__([], **kwargs)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from empyrical_dist 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",
      "        :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": "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\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",
      "        :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": "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\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": "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\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 all range of cumulative probabilities.\n",
    "\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": "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\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, 1, 3, 2, 4, 1, 4, 1, 1, 6])"
      ]
     },
     "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([3, 1, 2, 5, 4, 6, 2, 2, 4, 2])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6.sample(n=10, replace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}