solutions/option_pricing_comparison.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Original Asian version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math # This is the standard Python math module. Not the numpy one\n",
    "import random # This is the standard Python random module.  Not the numpy one\n",
    "\n",
    "def Asian_original(so,k,r,v,t,m,n):\n",
    "    \"\"\"\n",
    "    I have not identified what the arguments mean since the original MATLAB code didn't either. \n",
    "    This doc-string will be updated once I learn what they are!\n",
    "    \"\"\"\n",
    "    dt = t/m\n",
    "    AsianPayoffSum = 0\n",
    "    for i in range(1,n+1):\n",
    "        s = so\n",
    "        stSum = so\n",
    "        at = so\n",
    "        for j in range(1,m+1):\n",
    "            st = s * math.exp(((r-v**2/2)*dt) + (v*random.normalvariate(0,1)*math.sqrt(dt)))\n",
    "            stSum = stSum + st \n",
    "            at = stSum/(j+1)\n",
    "            s = st\n",
    "        AsianPayoff = max(at-k,0);\n",
    "        AsianPayoffSum = AsianPayoffSum + AsianPayoff;\n",
    "    AsianCall = math.exp(-r*t)*(AsianPayoffSum/n)\n",
    "    return(AsianCall)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18.420053075801047"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test it\n",
    "random.seed(10)\n",
    "Asian_original(100,90,0.15,0.45,1,100,200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35.5 s ± 3.03 s per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "original_time = %timeit -o Asian_original(100,90,0.15,0.45,1,100,200000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cython version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext Cython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "import math \n",
    "import random \n",
    "def Asian_cython(float so, float k, float r, float v, float t, int m, int n):\n",
    "    \"\"\"\n",
    "    I have not identified what the arguments mean since the original MATLAB code didn't either. \n",
    "    This doc-string will be updated once I learn what they are!\n",
    "    \"\"\"\n",
    "    cdef int i, j\n",
    "    cdef float dt, s, stSum, at, st\n",
    "    cdef float AsianPayoff, AsianPayoffSum, AsianCall\n",
    "    \n",
    "    dt = t/m\n",
    "    AsianPayoffSum = 0\n",
    "    for i in range(1,n+1):\n",
    "        s = so\n",
    "        stSum = so\n",
    "        at = so\n",
    "        for j in range(1,m+1):\n",
    "            st = s * math.exp(((r-v**2/2)*dt) + (v*random.normalvariate(0,1)*math.sqrt(dt)))\n",
    "            stSum = stSum + st \n",
    "            at = stSum/(j+1)\n",
    "            s = st\n",
    "        AsianPayoff = max(at-k,0);\n",
    "        AsianPayoffSum = AsianPayoffSum + AsianPayoff;\n",
    "    AsianCall = math.exp(-r*t)*(AsianPayoffSum/n)\n",
    "    return(AsianCall)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18.420015335083008"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test it\n",
    "random.seed(10)\n",
    "Asian_cython(100,90,0.15,0.45,1,100,200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26.4 s ± 2.18 s per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "cython_time = %timeit -o Asian_cython(100,90,0.15,0.45,1,100,200000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numba JIT version "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numba import jit\n",
    "@jit\n",
    "def Asian_jit(so,k,r,v,t,m,n):\n",
    "    \"\"\"\n",
    "    I have not identified what the arguments mean since the original MATLAB code didn't either. \n",
    "    This doc-string will be updated once I learn what they are!\n",
    "    \"\"\"\n",
    "    dt = t/m\n",
    "    AsianPayoffSum = 0\n",
    "    for i in range(1,n+1):\n",
    "        s = so\n",
    "        stSum = so\n",
    "        at = so\n",
    "        for j in range(1,m+1):\n",
    "            st = s * math.exp(((r-v**2/2)*dt) + (v*random.normalvariate(0,1)*math.sqrt(dt)))\n",
    "            stSum = stSum + st \n",
    "            at = stSum/(j+1)\n",
    "            s = st\n",
    "        AsianPayoff = max(at-k,0);\n",
    "        AsianPayoffSum = AsianPayoffSum + AsianPayoff;\n",
    "    AsianCall = math.exp(-r*t)*(AsianPayoffSum/n)\n",
    "    return(AsianCall)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18.538404674216714"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test it\n",
    "random.seed(10)\n",
    "Asian_jit(100,90,0.15,0.45,1,100,200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "739 ms ± 47.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "jit_time = %timeit -o Asian_jit(100,90,0.15,0.45,1,100,200000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parallel Numba JIT Version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math # This is the standard Pyton math module. Not the numpy one\n",
    "import random # This is the standard Python random module.  Not the numpy one\n",
    "import numpy as np\n",
    "from numba import jit,prange\n",
    "\n",
    "@jit(nopython=True)\n",
    "def inner_loop(m,so,k,r,v,t):\n",
    "    dt = t/m\n",
    "    s = so\n",
    "    stSum = so\n",
    "    at = so\n",
    "    for j in range(1,m+1):\n",
    "        st = s * math.exp(((r-v**2/2)*dt) + (v*random.normalvariate(0,1)*math.sqrt(dt)))\n",
    "        stSum = stSum + st \n",
    "        at = stSum/(j+1)\n",
    "        s = st\n",
    "    return(max(at-k,0))\n",
    "\n",
    "@jit(nopython=True,parallel=True)\n",
    "def numba_Asian_parallel(so,k,r,v,t,m,n):\n",
    "    \"\"\"\n",
    "    I have not identified what the arguments mean since the original MATLAB code didn't either. \n",
    "    This doc-string will be updated once I learn what they are!\n",
    "    \"\"\"\n",
    "    AsianPayoff= np.zeros(n)\n",
    "    for i in prange(n):\n",
    "        AsianPayoff[i] = inner_loop(m,so,k,r,v,t)\n",
    "    AsianPayoffSum = np.sum(AsianPayoff);\n",
    "    AsianCall = math.exp(-r*t)*(AsianPayoffSum/n)\n",
    "    return(AsianCall)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "197 ms ± 6.42 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "parallel_jit_time = %timeit -o numba_Asian_parallel(100,90,0.15,0.45,1,100,200000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy version with one loop vectorised"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Solution 1 - Removing the first loop by using vectors\n",
    "import numpy as np\n",
    "\n",
    "def Asian_numpy1(so,k,r,v,t,m,n):\n",
    "    dt = t/m\n",
    "    AsianPayoffSum = 0\n",
    "    for i in range(n):\n",
    "        st = np.cumprod(np.hstack((so,np.exp(((r-v**2/2)*dt) + (v*np.random.normal(0,1,m)*np.sqrt(dt))))))\n",
    "        at = np.mean(st)\n",
    "        AsianPayoff = max(at-k,0);\n",
    "        AsianPayoffSum = AsianPayoffSum + AsianPayoff;\n",
    "    AsianCall = np.exp(-r*t)*(AsianPayoffSum/n)\n",
    "    return(AsianCall)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.03 s ± 48.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "numpy1_time = %timeit -o Asian_numpy1(100,90,0.15,0.45,1,100,200000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy version with two loops vectorised"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution 2 - remove both loops by using matrices\n",
    "import numpy as np\n",
    "from numpy import sqrt,exp\n",
    "from numpy.random import normal\n",
    "\n",
    "def Asian_numpy2(so,k,r,v,t,m,n):\n",
    "    dt = t/m\n",
    "    AsianPayoffSum = 0\n",
    "    sqrt_dt = sqrt(dt)\n",
    "    st = np.cumprod( np.hstack((so*np.ones((n,1)),exp( ((r-v**2/2)*dt) + (v*normal(0,1,(n,m)) * sqrt_dt)) )) ,axis=1)\n",
    "    at = np.mean(st,axis=1)\n",
    "    AsianPayoff = np.maximum(at-k,0)\n",
    "    AsianPayoffMean = AsianPayoff.mean()\n",
    "    AsianCall = np.exp(-r*t)*AsianPayoffMean\n",
    "    return(AsianCall)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.25 s ± 26.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "numpy2_time = %timeit -o Asian_numpy2(100,90,0.15,0.45,1,100,200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original code took 35.5 s ± 3.03 s per loop (mean ± std. dev. of 7 runs, 1 loop each) seconds\n",
      "Cython was  1.3x faster\n",
      "Numpy with one vectorised loop was  5.0x faster\n",
      "Numpy with two vectorised loop was  28.4x faster\n",
      "Serial numba was  48.1x faster\n",
      "Parallel numba was  180.2x faster\n"
     ]
    }
   ],
   "source": [
    "print(f\"Original code took {original_time} seconds\")\n",
    "cythonx = original_time.average/cython_time.average\n",
    "print(f\"Cython was  {cythonx:.1f}x faster\")\n",
    "numpy1x = original_time.average/numpy1_time.average\n",
    "print(f\"Numpy with one vectorised loop was  {numpy1x:.1f}x faster\")\n",
    "numpy2x = original_time.average/numpy2_time.average\n",
    "print(f\"Numpy with two vectorised loop was  {numpy2x:.1f}x faster\")\n",
    "parallel_jit_x= original_time.average/parallel_jit_time.average\n",
    "jit_x = original_time.average/jit_time.average \n",
    "print(f\"Serial numba was  {jit_x:.1f}x faster\")\n",
    "print(f\"Parallel numba was  {parallel_jit_x:.1f}x faster\")"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}