Implicit_FDM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2.72795265]\n",
      " [ 0.99875007]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from numpy import linalg as la\n",
    "#####################################################################################\n",
    "#################Implicit Finite Differences Method on S=exp(x)######################\n",
    "#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#\n",
    "#########################===========!The Function!==========#########################\n",
    "#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#\n",
    "#This function will return the FairValue of a Vanilla European Call/Put\n",
    "# S_max: is a high Stock Price, that cannot be reached\n",
    "# T:     is the maturity\n",
    "# r:     is the risk free rate\n",
    "# q:     is the dividend yield\n",
    "# sigma: is the volatility of the stock\n",
    "# N:     is the time discretization number\n",
    "# M:     is the stock discretization parameter\n",
    "# isCall:is the derivative type call or put\n",
    "# isAmerican: Trivial\n",
    "def VanillaOption(S_0,\n",
    "                  T,\n",
    "                  K,\n",
    "                  r,\n",
    "                  q,\n",
    "                  sigma,\n",
    "                  N,\n",
    "                  M,\n",
    "                  isCall,\n",
    "                  isAmerican):\n",
    "    outVector = np.zeros((2,1),dtype = float)\n",
    "    S_max = 2.0*K\n",
    "    S_min = 0.0\n",
    "    #Discretization of the Stock and the Time\n",
    "    dS=(S_max-S_min)/float(M)  \n",
    "    dt=T/float(N)\n",
    "    \n",
    "    j=np.arange(0,M,dtype=np.float)   \n",
    "    \n",
    "    #'Transition Probabilities'\n",
    "    a=(0.5*(r-q)*j*dt-0.5*sigma**2*j**2*dt)\n",
    "    b=(1.0+sigma**2*j**2*dt+r*dt)\n",
    "    c=(-0.5*(r-q)*j*dt-0.5*sigma**2*j**2*dt)\n",
    "    #The matrix from the transition probabilities\n",
    "    A=np.diag(b)+np.diag(a[1:],k=-1)+np.diag(c[0:M-1],k=1)\n",
    "    B=la.inv(A)\n",
    "    infinityNormOfB = la.norm(B,np.inf)\n",
    "    outVector[1] = infinityNormOfB\n",
    "    #The matrix for the option price\n",
    "    #N+1: Time Steps\n",
    "    #M+1: Stock Steps\n",
    "    FV=np.zeros((N+1,M+1))\n",
    "    \n",
    "    #Set up the boundary conditions//Contract dependent :-(   \n",
    "    #FV[:,M]=[S_max * np.exp(-r*( N - j)*dt) for j in range(N+1)]\n",
    "    if(bool(isCall)):\n",
    "        FV[:,0]=S_min\n",
    "        FV[:,M]=S_max\n",
    "        FV[N,:]=np.maximum(np.arange(S_min,S_max+dS/2.0,dS,dtype=np.float)-K,0)\n",
    "    else:\n",
    "        FV[:,0]=K\n",
    "        FV[:,M]=0\n",
    "        FV[N,:]=np.maximum(K-np.arange(S_min,S_max+dS/2.0,dS,dtype=np.float),0)\n",
    "    \n",
    "    FV=np.matrix(np.array(FV))\n",
    "    #Start the Backward Iteration\n",
    "    for i in range(N-1,-1,-1):\n",
    "        k_i=np.zeros((M,1))\n",
    "        #Inserts the first and the last element\n",
    "        k_i[0]=-a[0]*FV[i+1,0] \n",
    "        k_i[M-1]=-c[M-1]*FV[i+1,M]\n",
    "        \n",
    "        FV[i,0:M]=np.dot(FV[i+1,0:M]+np.matrix(np.array(k_i)).transpose(),B)\n",
    "        \n",
    "        if(bool(isAmerican)):\n",
    "            if(bool(isCall)):\n",
    "                FV[i,:] = np.maximum(np.arange(0,S_max+dS/2,dS,dtype=float)-K,FV[i,:]) \n",
    "            else:\n",
    "                FV[i,:] = np.maximum(K-np.arange(0,S_max+dS/2,dS,dtype=float),FV[i,:])\n",
    "        outVector[0] = FV[0,(FV.shape[1]+1)/2]\n",
    "    return outVector\n",
    "#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#\n",
    "#########################========End Of The Function========#########################\n",
    "#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#--#\n",
    "S_0 = 50.0\n",
    "T=1.0\n",
    "K=50.0\n",
    "r=0.1\n",
    "q=0.00\n",
    "sigma = 0.25\n",
    "N=50\n",
    "M=30\n",
    "isCall = 0\n",
    "isAmerican = 0\n",
    "print VanillaOption(S_0,\n",
    "                    T,\n",
    "                    K,\n",
    "                    r,\n",
    "                    q,\n",
    "                    sigma,\n",
    "                    N,\n",
    "                    M,\n",
    "                    isCall,\n",
    "                    isAmerican)        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}