ConvertibleBond_Goldman1994_Derman.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "from ipywidgets import interact, interactive, fixed, interact_manual\n",
    "import ipywidgets as widgets\n",
    "from IPython.display import display\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Cox-Ross-Rubinstein Binomial Tree for American Call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def AmCall(S0, K, r, dyield, sigma, T, N=2000):\n",
    "    dT = float(T) / N\n",
    "    \n",
    "    # up and down factor will be constant for the tree so we calculate outside the loop\n",
    "    u = np.exp(sigma * np.sqrt(dT))\n",
    "    d = 1.0 / u\n",
    " \n",
    "    #investor holds option, initialization of vector H \n",
    "    H =  np.asarray([0.0 for i in range(N + 1)])\n",
    "        \n",
    "    #we need the stock tree for calculations of expiration values\n",
    "    S = np.asarray([(S0 * u**j * d**(N - j)) for j in range(N + 1)])\n",
    "    \n",
    "    #we vectorize the strikes as well so the expiration check will be faster\n",
    "    K = np.asarray( [float(K) for i in range(N + 1)])\n",
    "    \n",
    " \n",
    "    #rates are fixed so the probability of up and down are fixed.\n",
    "    #this is used to make sure the drift is the risk free rate\n",
    "    \n",
    "    #note that dividend yield appears in computing p but not in discounting\n",
    "    \n",
    "    a = np.exp((r-dyield) * dT)\n",
    "    p = (a - d)/ (u - d)\n",
    " \n",
    "    # Compute the leaves\n",
    "    H[:] = np.maximum(S-K, 0.0)\n",
    "   \n",
    "    #calculate backward the option prices\n",
    "    for i in range(N-1, -1, -1):\n",
    "        H[:-1]=np.exp(-r * dT) * (p * H[1:] + (1-p) * H[:-1])\n",
    "        S[:]=S[:]*u\n",
    "        \n",
    "        H[:]=np.maximum(H[:],S[:]-K[:])\n",
    "    return H[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5254447719914137"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AmCall(47, 47, 0.08, 0.08, 0.2, 1, N=20000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Convertible Bond model Goldman 1994 (by E. Derman)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def round_down(num, divisor):\n",
    "    return num - (num%divisor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def Goldman(F=100, c={1: 0.1}, T=5.0, ratio=1.0, calls={2:115, 3:110, 4:105, 5:100}, puts={3: 120}, \n",
    "            S0=100, dyield=0.0, sigma=0.1, r=0.05, mu=0.05, dd=500, N=200):\n",
    "    dT = float(T) / N\n",
    "\n",
    "    # Coupons\n",
    "    freq = list(c.keys())[0]\n",
    "    Tc   = 1/freq\n",
    "    \n",
    "    # up and down factor will be constant for the tree so we calculate outside the loop\n",
    "    u = np.exp((mu-dyield-0.5*sigma**2)*dT+sigma*np.sqrt(dT))\n",
    "    d = np.exp((mu-dyield-0.5*sigma**2)*dT-sigma*np.sqrt(dT))\n",
    "\n",
    "    #investor holds convertible, initialization of vector H, V, p and y\n",
    "    H = np.asarray([0.0 for i in range(N + 1)])\n",
    "    V = np.asarray([0.0 for i in range(N + 1)])\n",
    "    p = np.asarray([0.0 for i in range(N + 1)])\n",
    "    y = np.asarray([0.0 for i in range(N + 1)])\n",
    "    \n",
    "    #we need the stock tree for calculations of expiration values\n",
    "    S = np.asarray([(S0 * u**j * d**(N - j)) for j in range(N + 1)])\n",
    "        \n",
    "    # Compute the leaves\n",
    "    B = F+F*c[freq]*(T-round_down(T-1e-5, Tc))\n",
    "    V = np.maximum(ratio*S, B)\n",
    "    p[V>B] = 1.0\n",
    "    y = p*r + (1-p)*(r+dd/1e4)\n",
    "    \n",
    "    #calculate backward the tree the convertible bond value\n",
    "    for i in range(N-1, -1, -1):\n",
    "        t = i*dT\n",
    "        p = 0.5*(p[1:]+p[:-1])   # = 0.5*(p_u + p_d)\n",
    "        H = 0.5*(np.exp(-y[1:]*dT)*V[1:] + np.exp(-y[:-1]*dT)*V[:-1])\n",
    "        S = S[:-1] * u/np.exp((mu-dyield-0.5*sigma**2)*dT)\n",
    "        \n",
    "        # Put, Call, readjustment of probabilities and discount factors \n",
    "        a = F*c[freq]*(t-round_down(t-1e-5, Tc))        \n",
    "        \n",
    "        for key, value in calls.items():\n",
    "            if key == round_down(t-1e-5,1):\n",
    "                C = value + a\n",
    "            else:\n",
    "                C = 1e5\n",
    "        \n",
    "        for key, value in puts.items():\n",
    "            if key == round_down(t-1e-5,1):\n",
    "                P = value + a\n",
    "            else:\n",
    "                P = 0.0\n",
    "        \n",
    "        temp = np.minimum(H, C)\n",
    "        temp = np.maximum(temp, P)\n",
    "        V    = np.maximum(temp, ratio*S)\n",
    "        p[V==C] = 0.0\n",
    "        p[V==P] = 0.0\n",
    "\n",
    "        y = p*r + (1-p)*(r+dd/1e4)\n",
    "\n",
    "    return V[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125.23227161918943"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Goldman()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81.413603667922303"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Goldman(F=100, c={1: 0.05}, T=1.95, ratio=1000.0, calls={1:1e5}, puts={2: 0.0}, \n",
    "            S0=0.075, dyield=0.0, sigma=0.45, r=0.0188, mu=0.123062, dd=3312, N=2000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Animated plots of the behaviour of Convertible Bonds "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, '4', {5: 5}]\n"
     ]
    }
   ],
   "source": [
    "li=[[1,[[2]],[[[3]]]],[['4'],{5:5}]]\n",
    "flatten=lambda l: sum(map(flatten,l),[]) if isinstance(l,list) else [l]\n",
    "print(flatten(li))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}