binomial-code.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Binomial():\n",
    "    \"\"\" Binomial distribution class for calculating and \n",
    "    visualizing a Binomial distribution.\n",
    "    \n",
    "    Attributes:\n",
    "        mean (float) the mean value\n",
    "        stdev (float) the standard deviation\n",
    "        data_list (list of floats) a list of floats extracted from the data file\n",
    "        p (float) the probability of an event occurring\n",
    "        n (int) number of trials\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, prob = 0.5, size = 20):\n",
    "        \n",
    "        self.n = size\n",
    "        self.p = prob\n",
    "        self.mean = self.calculate_mean()\n",
    "        self.stdev = self.calculate_stdev()\n",
    "        self.data = []\n",
    "    \n",
    "    def calculate_mean(self):\n",
    "        \"\"\" Function to calculate the mean from p and n\n",
    "        \n",
    "        Args: \n",
    "            None\n",
    "        \n",
    "        Returns: \n",
    "            float: mean of the data set\n",
    "        \"\"\"\n",
    "        \n",
    "        self.mean = self.p*self.n\n",
    "        \n",
    "        return self.mean\n",
    "    \n",
    "    def calculate_stdev(self):\n",
    "        \"\"\" Function to calculate the standard deviation from p and n.\n",
    "        \n",
    "        Args: \n",
    "            None\n",
    "        \n",
    "        Returns: \n",
    "            float: standard deviation of the data set\n",
    "        \"\"\"\n",
    "        \n",
    "        self.stdev = math.sqrt(self.n*self.p*(1-self.p))\n",
    "        \n",
    "        return self.stdev\n",
    "    \n",
    "    def replace_stats_with_data(self):\n",
    "        \"\"\"Function to calculate p and n from the data set\n",
    "        \n",
    "        Args: \n",
    "            None\n",
    "        \n",
    "        Returns: \n",
    "            float: the p value\n",
    "            float: the n value\n",
    "        \"\"\"\n",
    "        \n",
    "        self.n = len(self.data)\n",
    "        self.p = 1.0*sum(self.data)/len(self.data)\n",
    "        self.mean = self.calculate_mean()\n",
    "        self.stdev = self.calculate_stdev()\n",
    "        \n",
    "        return self.p, self.n\n",
    "    \n",
    "    def read_data_file(self, file_name, sample = True):\n",
    "        \"\"\" Function to read in data from a txt file. The txt file should have\n",
    "        one number per line. The number are stored in the data attribute. \n",
    "\n",
    "        Args:\n",
    "            file_name (string): name of a file to read from\n",
    "\n",
    "        Returns: \n",
    "            None    \n",
    "        \"\"\"\n",
    "        \n",
    "        with open(file_name) as file:\n",
    "            data_list = []\n",
    "            line = file.readline()\n",
    "            while line:\n",
    "                data_list.append(int(line))\n",
    "                line = file.readline()\n",
    "        file.close()\n",
    "        \n",
    "        self.data = data_list\n",
    "        self.replace_stats_with_data()\n",
    "        \n",
    "    def plot_bar(self):\n",
    "        \"\"\" Function to output a histogram of the instance variable data using \n",
    "        matplotlib pyplot library.\n",
    "        \n",
    "        Args:\n",
    "            None\n",
    "            \n",
    "        Returns:\n",
    "            None\n",
    "        \"\"\"\n",
    "                \n",
    "        plt.bar(x = ['0','1'], height = [(1-self.p)*self.n,self.p*self.n])\n",
    "        plt.title('Bar Chart of Data')\n",
    "        plt.xlabel('outcome')\n",
    "        plt.ylabel('count')\n",
    "        \n",
    "    def pdf(self, k):\n",
    "        \"\"\" Probability density function calculator for the binomial distribution.\n",
    "        \n",
    "        Args:\n",
    "            x (float): point for calculating the probability density function\n",
    "        \n",
    "        Returns:\n",
    "            float: probability density function output\n",
    "        \"\"\"\n",
    "        \n",
    "        a = math.factorial(self.n)/(math.factorial(k)*(math.factorial(self.n-k)))\n",
    "        b = (self.p**k)*(1-self.p)**(self.n-k)\n",
    "        \n",
    "        return a*b\n",
    "    \n",
    "    def plot_bar_pdf(self):\n",
    "        \"\"\" Function to plot the pdf of the binomial distribution\n",
    "        \n",
    "        Args:\n",
    "            None\n",
    "        \n",
    "        Returns:\n",
    "            list: x values for the pdf plot\n",
    "            list: y values for the pdf plot    \n",
    "        \"\"\"\n",
    "        \n",
    "        x = []\n",
    "        y = []\n",
    "        \n",
    "        # calculate the x values to visualize\n",
    "        for i in range(self.n+1):\n",
    "            x.append(i)\n",
    "            y.append(self.pdf(i))\n",
    "\n",
    "        # make the plots\n",
    "        plt.bar(x, y)\n",
    "        plt.title('Distribution of Outcomes')\n",
    "        plt.ylabel('Probability')\n",
    "        plt.xlabel('Outcome')\n",
    "\n",
    "        plt.show()\n",
    "\n",
    "        return x, y\n",
    "    \n",
    "    def __add__(self, other):        \n",
    "        \"\"\" Function to add together two Binomial distributions with equal p\n",
    "        \n",
    "        Args:\n",
    "            other (Binomial): Binomial instance\n",
    "            \n",
    "        Returns:\n",
    "            Binomial: Binomial distribution \n",
    "        \"\"\"\n",
    "        \n",
    "        try:\n",
    "            assert self.p == other.p, 'p values are not equal'\n",
    "        except AssertionError as error:\n",
    "            raise\n",
    "        \n",
    "        result = Binomial()\n",
    "        result.n = self.n +other.n\n",
    "        result.p = self.p\n",
    "        result.calculate_mean()\n",
    "        result.calculate_stdev()\n",
    "        \n",
    "        return result\n",
    "    \n",
    "    def __repr__(self): \n",
    "        \"\"\" Function to output the characteristics of the Binomial instance\n",
    "        \n",
    "        Args:\n",
    "            None\n",
    "        \n",
    "        Returns:\n",
    "            string: characteristics of the Gaussian \n",
    "        \"\"\"\n",
    "        \n",
    "        return \"mean: {}, standard deviation: {}, p: {}, n: {}\".format(self.mean, self.stdev, self.p, self.n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "binomial_one = Binomial()\n",
    "binomial_one.read_data_file('numbers_binomial.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mean: 8.0, standard deviation: 1.7541160386140584, p: 0.6153846153846154, n: 13"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial_one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "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": [
    "binomial_one.plot_bar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "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"
    },
    {
     "data": {
      "text/plain": [
       "([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],\n",
       " [4.030384466833637e-06,\n",
       "  8.383199691013968e-05,\n",
       "  0.0008047871703373409,\n",
       "  0.0047214180659790675,\n",
       "  0.01888567226391627,\n",
       "  0.054390736120078866,\n",
       "  0.11603357038950161,\n",
       "  0.1856537126232026,\n",
       "  0.22278445514784312,\n",
       "  0.19803062679808284,\n",
       "  0.12673960115077304,\n",
       "  0.05530455322942824,\n",
       "  0.014747880861180866,\n",
       "  0.0018151237982991838])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial_one.plot_bar_pdf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mean: 32.0, standard deviation: 4.381780460041329, p: 0.4, n: 80"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial_one = Binomial(.4, 20)\n",
    "binomial_two = Binomial(.4, 60)\n",
    "\n",
    "binomial_sum = binomial_one + binomial_two\n",
    "\n",
    "binomial_sum"
   ]
  },
  {
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}