{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://raw.githubusercontent.com/israeldi/quantlab/master/assets/images/Program-Logo.png\" width=\"400px\" align=\"right\">\n",
    "\n",
    "# Binomial Pricing Model\n",
    "### [(Go to Quant Lab)](https://israeldi.github.io/quantlab/)\n",
    "\n",
    "#### Source: Numerical Methods in Finance with C++\n",
    "\n",
    "&copy; Maciej J. Capinski, Tomasz Zastawniak\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/israeldi/quantlab/master/assets/images/Numerical_Methods.jpg\" width=\"200px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "1. [Random Numbers](#1.-Random-Numbers)\n",
    "2. [Plotting Random Samples](#2.-Plotting-Random-Samples)\n",
    "3. [Simulation](#3.-Simulation)\n",
    "    - 3.1 [Random Variables](#3.1-Random-Variables)\n",
    "    - 3.2 [Stochastic Processes](#3.2-Stochastic-Processes)\n",
    "        - 3.2.1 [Geometric Brownian Motion](#3.2.1-Geometric-Brownian-Motion)\n",
    "        - 3.2.2 [Square-Root Diffusion](#3.2.2-Square-Root-Diffusion)\n",
    "        - 3.2.3 [Stochastic Processes](#3.2-Stochastic-Processes)\n",
    "        - 3.2.4 [Stochastic Processes](#3.2-Stochastic-Processes)\n",
    "    - 3.3 [Variance Reduction](#3.3-Variance-Reduction)\n",
    "4. [Valuation](#4.-Valuation)\n",
    "    - 4.1 [European Options](#4.1-European-Options)\n",
    "    - 4.2 [American Options](#4.2-American-Options)\n",
    "5. [Risk Measures](#5.-Risk-Measures)\n",
    "    - 5.1 [Value-at-Risk](#5.1-Value-at-Risk)\n",
    "    - 5.2 [Credit Value Adjustments](#5.2-Credit-Value-Adjustments)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initially import all the modules we will be using for our notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import numpy.random as npr  \n",
    "import sys\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Creating Main Program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi there\n",
      "Provide a character: 1\n"
     ]
    }
   ],
   "source": [
    "if __name__== \"__main__\":\n",
    "    print(\"Hi there\")\n",
    "    input(\"Provide a character: \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Entering Data\n",
    "#### ([Back to Top](#Table-of-Contents))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter S_0: 1\n",
      "Enter U: 2\n",
      "Enter D: -0.5\n",
      "Enter R: 0\n",
      "Input data checked\n",
      "There is no arbitrage\n",
      "\n",
      "q =  0.2\n",
      "n =  3\n",
      "i =  2\n",
      "S(n,i) =  4.5\n"
     ]
    }
   ],
   "source": [
    "if __name__== \"__main__\":\n",
    "    # Get input parameters S0, U, D, R\n",
    "    # YOUR CODE....\n",
    "\n",
    "    # make sure that 0< S0, -1 < D < U, -1 < R\n",
    "    # YOUR CODE....\n",
    "    \n",
    "    # checking arbitrage condition\n",
    "    # YOUR CODE....\n",
    "\n",
    "    print(\"Input data checked\")\n",
    "    print(\"There is no arbitrage\\n\")\n",
    "    \n",
    "    # compute risk-neutral probability\n",
    "    # YOUR CODE....\n",
    "    \n",
    "    # compute stock price at node n=3,i=2\n",
    "    n = 3; i = 2\n",
    "    print(\"n = \", n)\n",
    "    print(\"i = \", i)\n",
    "    print(\"S(n,i) = \", \"YOUR CODE\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Functions\n",
    "#### ([Back to Top](#Table-of-Contents))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "uuid": "4618b170-6bd3-4500-905a-0fe402f198c1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q =  0.13043478260869565\n",
      "Enter S0: 3\n",
      "Enter U: 2\n",
      "Enter D: -0.2\n",
      "Enter R: 0\n",
      "Input data checked\n",
      "There is no arbitrage\n",
      "\n",
      "n =  3\n",
      "i =  2\n",
      "S(n,i) =  21.6\n"
     ]
    }
   ],
   "source": [
    "# computing risk-neutral probability\n",
    "def RiskNeutProb(U, D, R):\n",
    "    # YOUR CODE....\n",
    "\n",
    "# computing the stock price at node n,i\n",
    "def S(S0, U, D, n, i):\n",
    "    '''\n",
    "    Returns the stock price at S(n, i)\n",
    "    '''\n",
    "    \n",
    "    # YOUR CODE....\n",
    "\n",
    "def isValidInput(S0, U, D, R):\n",
    "    '''\n",
    "    Returns: This function should return zero if any condition is violated, returns 1 otherwise\n",
    "    '''\n",
    "    \n",
    "    # making sure that 0<S0, -1<D<U, -1<R\n",
    "    # YOUR CODE....\n",
    "    \n",
    "    # checking for arbitrage\n",
    "    # YOUR CODE....\n",
    "\n",
    "# inputting, displaying and checking model data\n",
    "def GetInputData():\n",
    "    '''\n",
    "    This function accepts user input and updates the variables on your computer locally\n",
    "    '''\n",
    "    #entering data\n",
    "    params = (\"S0\", \"U\", \"D\", \"R\")\n",
    "    S0, U, D, R = [float(input(\"Enter %s: \" % (var))) for var in params]\n",
    "    \n",
    "    if not isValidInput(S0, U, D, R):\n",
    "        return 0\n",
    "    \n",
    "    print(\"Input data checked\")\n",
    "    print(\"There is no arbitrage\\n\")\n",
    "    d = locals().copy()\n",
    "    return d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**If your functions above are correct, then run this program**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If your functions above are correct, then run this program\n",
    "if __name__== \"__main__\":\n",
    "    # compute risk-neutral probability\n",
    "    print(\"q = \", RiskNeutProb(U, D, R))\n",
    "    \n",
    "    output = GetInputData()\n",
    "    if output == 0:\n",
    "        sys.exit()\n",
    "    \n",
    "    # Update our parameters\n",
    "    locals().update(output)\n",
    "    \n",
    "    # compute stock price at node n=3,i=2\n",
    "    n = 3; i = 2\n",
    "    print(\"n = \", n)\n",
    "    print(\"i = \", i)\n",
    "    print(\"S(n,i) = \", S(S0,U,D,n,i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 Option Pricing Definitions\n",
    "#### ([Back to Top](#Table-of-Contents))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def PriceByCRR(self, Model, N=3):\n",
    "    '''\n",
    "    Implement European style option pricing\n",
    "    '''\n",
    "    \n",
    "def PriceBySnell(self, Model, N=3):\n",
    "    '''\n",
    "    Implement American style option pricing\n",
    "    '''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.0 Object Oriented European and American\n",
    "#### ([Back to Top](#Table-of-Contents))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4482083442210392"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Binomial Model (Parent class) ---------------------------------------------------\n",
    "class BinModel:\n",
    "    '''\n",
    "    Parent class for a generic binomial model which holds the model parameters\n",
    "    '''\n",
    "        \n",
    "    \n",
    "# European Option class ------------------------------------------------------------------\n",
    "class EurOption():\n",
    "    \n",
    "    def PriceByCRR(self, Model, N=3):\n",
    "        '''\n",
    "        Returns the option price at time 0 if the option is European style\n",
    "        '''\n",
    "    \n",
    "# American Option class\n",
    "class AmOption():\n",
    "    def PriceBySnell(self, Model, N=3):\n",
    "        '''\n",
    "        Returns the option price at time 0 if the option is American style\n",
    "        '''\n",
    "\n",
    "# Payoff Classes ---------------------------------------------------------------------------- \n",
    "class Call(EurOption, AmOption):\n",
    "    '''\n",
    "    Class for Call option payoff\n",
    "    '''\n",
    "\n",
    "class Put(EurOption, AmOption):\n",
    "    '''\n",
    "    Class for Put option payoff\n",
    "    '''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Testing with parameters\n",
    "model = BinModel(S0=10, U=0.2, D=-0.1, R=0.1)\n",
    "Option1 = Call(K=22)\n",
    "Option1.PriceByCRR(model, N=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises:\n",
    "\n",
    "1. Modify the `PriceByCRR()` function in `EurOption` Class to compute the time $0$ price of a European option using the **Cox–Ross–Rubinstein (CRR)** formula:\n",
    "$$H(0)=\\frac{1}{(1+R)^{N}}\\sum_{i=0}^{N}\\frac{N!}{i!(N-i)!}q^{i}(1-q)^{N-i}h(S(N,I))$$\n",
    "\n",
    "\n",
    "2. The payoff of a **digital call** with strike price $K$ is:\n",
    "$$h^{digit\\thinspace call}(z)=\\begin{cases}\n",
    "1 & \\textrm{if }K<z,\\\\\n",
    "0 & \\textrm{otherwise.}\n",
    "\\end{cases}$$\n",
    "Include the ability to price digital calls in the program developed in the present section by adding the new payoff Class `DigitCall` just as was done for calls and puts.\n",
    "\n",
    "\n",
    "3. Add the ability to price bull spreads and bear spreads by introducing new subclasses `BullSpread` and `BearSpread` of the `EurOption` and `AmOption` classes defined in our current program. The payoffs of a bull spread and a bear spread, which depend on two parameters $K1 < K2$, are given by:\n",
    "$$h^{bull}(z)=\\begin{cases}\n",
    "0 & \\textrm{if }z\\leq K_{1},\\\\\n",
    "z-K_{1} & \\textrm{if }K_{1}<z<K_{2}\\\\\n",
    "K_{2}-K_{1} & \\textrm{if }K_{2}\\leq z,\n",
    "\\end{cases}$$ and\n",
    "$$h^{bear}(z)=\\begin{cases}\n",
    "K_{2}-K_{1} & \\textrm{if }z\\leq K_{1},\\\\\n",
    "K_{2}-z & \\textrm{if }K_{1}<z<K_{2}\\\\\n",
    "0 & \\textrm{if }K_{2}<z,\n",
    "\\end{cases}$$\n",
    "\n",
    "\n",
    "4. Consider the **fixed-strike** Asian call option with process,\n",
    "$$A_{N}=\\frac{1}{N}\\sum_{k=0}^{N-1}S(k)$$ and payoff, $$C(N)=max\\{A_{N},0\\}$$\n",
    "Add a new Class `AsianOption` to price an Asian style Call Option. "
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}