py/BlackScholes_FunctionVsClass.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementation of the Black-Scholes option price"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Under the Black-Scholes (BS) model, the call option price is given by\n",
    "\n",
    "$$ C(K, S_0, \\sigma, T) = e^{-rT}\\big(F_0 N(d_1) - K N(d_2) \\big)$$\n",
    "\n",
    "where $r$ is the interest rate, $q$ is the continuous dividend rate, $F_0$ is the forward price,\n",
    "\n",
    "$$ F_0 = e^{(r-q)T}S_0, $$\n",
    "and\n",
    "$$ d_{1,2} = \\frac{\\log(F_0/K)}{\\sigma\\sqrt{T}} \\pm \\sigma\\sqrt{T}\n",
    "$$\n",
    "\n",
    "We are going to implement the formula using function vs class approaches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.stats as spst\n",
    "import datetime as dt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Function approach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.301568584255463\n"
     ]
    }
   ],
   "source": [
    "texp=2\n",
    "vol=0.4\n",
    "spot=120\n",
    "intr=0\n",
    "divr=0\n",
    "strike=150\n",
    "cp=1\n",
    "\n",
    "vol_std = vol * np.sqrt(texp)\n",
    "div_fac = np.exp(-texp*divr)\n",
    "disc_fac = np.exp(-texp*intr)\n",
    "forward = spot / disc_fac * div_fac\n",
    "d1 = np.log(forward/strike)/vol_std + 0.5*vol_std\n",
    "d2 = d1 - vol_std\n",
    "\n",
    "price = cp * disc_fac \\\n",
    "    * ( forward * spst.norm.cdf(cp*d1) - strike * spst.norm.cdf(cp*d2) )\n",
    "print(price)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Black-Scholes option price\n",
    "\n",
    "def bsm_option_price(strike, spot, vol, texp, intr=0.0, divr=0.0, cp=1):\n",
    "    \"\"\"\n",
    "    Black-Scholes option price\n",
    "    \n",
    "    A function version by Prof. Choi.\n",
    "    \n",
    "    Parameters:\n",
    "        strike: strike price\n",
    "        spot: spot price\n",
    "        vol: volatility\n",
    "    \n",
    "    Return: price    \n",
    "    \"\"\"\n",
    "    vol_std = vol * np.sqrt(texp)\n",
    "    div_fac = np.exp(-texp*divr)\n",
    "    disc_fac = np.exp(-texp*intr)\n",
    "    forward = spot / disc_fac * div_fac\n",
    "    d1 = np.log(forward/strike)/vol_std + 0.5*vol_std\n",
    "    d2 = d1 - vol_std\n",
    "\n",
    "    price = cp * disc_fac \\\n",
    "        * ( forward * spst.norm.cdf(cp*d1) - strike * spst.norm.cdf(cp*d2) )\n",
    "    return price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.255566362164977"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bsm_option_price(110, 100, 0.2, 7, 0, 0, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18.891474766003526"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bsm_option_price(90, 100, 0.2, 10, 0, 0, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Different ways of using function arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.064019137898846, 2.064019137898846, 2.064019137898846)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### full arguments\n",
    "c1 = bsm_option_price(105, 100, 0.2, 0.25, 0, 0, 1)\n",
    "\n",
    "### omit arguments with default vaules\n",
    "c2 = bsm_option_price(105, 100, 0.2, 0.25)\n",
    "\n",
    "### you need to pass all required arguments\n",
    "#c2 = bsm_option_price(105, 100, 0.2)\n",
    "\n",
    "### use argument names\n",
    "c3 = bsm_option_price(105, 100, texp=0.25, vol=0.2)\n",
    "\n",
    "### always put the named args at the end\n",
    "c3 = bsm_option_price(105, texp=0.25, spot=100, vol=0.2)\n",
    "\n",
    "c1, c2, c3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "source": [
    "## Disadvantage of function approach:\n",
    "* The computation in the function has to be repeated every time.\n",
    "* Some part doesn't have to be repeated: for example, __vol, texp, intr, divr__ don't change often. So   __vol_std, disc_fac, div_fac__ don't have to be computed.\n",
    "* You feel some needs to organize by binding some data + function(method)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Class approach\n",
    "We're going to bind __vol, intr, intd__ into a class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BSM_Ver1:\n",
    "    \"\"\"\n",
    "    BSM Class version 1\n",
    "    \n",
    "    \"\"\"\n",
    "    vol, texp, intr, divr = None, None, None, None\n",
    "    \n",
    "    def __init__(self, vol, texp, intr=0.0, divr=0.0): # Constructor\n",
    "        self.vol, self.texp, self.intr, self.divr = vol, texp, intr, divr\n",
    "    \n",
    "    def price(self, strike, spot, cp=1):\n",
    "        # cp = 1 for call, -1 for put\n",
    "        vol_std = self.vol * np.sqrt(self.texp)\n",
    "        div_fac = np.exp(-self.texp*self.divr)\n",
    "        disc_fac = np.exp(-self.texp*self.intr)\n",
    "        forward = spot / disc_fac * div_fac\n",
    "        d1 = np.log(forward/strike)/vol_std + 0.5*vol_std\n",
    "        d2 = d1 - vol_std\n",
    "\n",
    "        price = cp * disc_fac \\\n",
    "            * ( forward * spst.norm.cdf(cp*d1) - strike * spst.norm.cdf(cp*d2) )\n",
    "        return price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'vol': 0.2, 'texp': 1, 'intr': 0.0, 'divr': 0.0}\n"
     ]
    }
   ],
   "source": [
    "### define a bsm model with spot, vol and expiry.\n",
    "bsm1 = BSM_Ver1(vol=0.2, texp=1, intr=0.0)\n",
    "print( bsm1.__dict__ )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7.084494247829895, 9.83051012618256)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### price options with strike\n",
    "bsm1.price(102, 100), bsm1.price(strike=102, spot=105)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15.029816377425, 17.029816377425)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Lets change vol/expiry\n",
    "bsm1.vol = 0.4\n",
    "\n",
    "### option price changes\n",
    "bsm1.price(102, 100), bsm1.price(strike=102, spot=100, cp=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BSM_Ver2:\n",
    "    vol, texp, intr, divr = None, None, None, None\n",
    "\n",
    "    def __init__(self, vol, texp, intr=0.0, divr=0.0): # Constructor for this class.\n",
    "        self.vol, self.texp, self.intr, self.divr = vol, texp, intr, divr\n",
    "        \n",
    "        self.vol_std = vol * np.sqrt(texp)\n",
    "        self.div_fac = np.exp(-texp*divr)\n",
    "        self.disc_fac = np.exp(-texp*intr)\n",
    "    \n",
    "    def price(self, strike, spot, cp=1):\n",
    "        forward = spot / self.disc_fac * self.div_fac\n",
    "        d1 = np.log(forward/strike)/self.vol_std + 0.5*self.vol_std\n",
    "        d2 = d1 - self.vol_std\n",
    "        price = cp * self.disc_fac \\\n",
    "            * ( forward * spst.norm.cdf(cp*d1) - strike * spst.norm.cdf(cp*d2) )\n",
    "        return price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'vol': 0.2, 'texp': 1, 'intr': 0.0, 'divr': 0.0, 'vol_std': 0.2, 'div_fac': 1.0, 'disc_fac': 1.0}\n"
     ]
    }
   ],
   "source": [
    "bsm2 = BSM_Ver2(vol=0.2, texp=1)\n",
    "print(bsm2.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7.084494247829895, 9.08449424782988)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bsm2.price(102, 100), bsm2.price(102, 100, cp=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7.084494247829895, 9.08449424782988)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### But... now things are not that simple\n",
    "bsm2.vol = 0.4\n",
    "### option prices are price same after volatility change !@#$\n",
    "bsm2.price(102, 100), bsm2.price(102, 100, cp=-1)\n",
    "#print( bsm2.__dict__ )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'vol': 0.4, 'texp': 1, 'intr': 0.0, 'divr': 0.0, 'vol_std': 0.2, 'div_fac': 1.0, 'disc_fac': 1.0}\n"
     ]
    }
   ],
   "source": [
    "print(bsm2.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BSM_Ver3:\n",
    "    vol, texp, intr, divr = None, None, None, None\n",
    "\n",
    "    def __init__(self, vol, texp, intr=0.0, divr=0.0): # Constructor\n",
    "        #self.vol, self.texp, self.intr, self.divr = vol, texp, intr, divr\n",
    "        self.setparams(vol, texp, intr, divr)\n",
    "\n",
    "    def setparams(self, vol=None, texp=None, intr=None, divr=None):\n",
    "        self.vol = vol if(vol != None) else self.vol\n",
    "        self.texp = texp if(texp != None) else self.texp\n",
    "        self.intr = intr if(intr != None) else self.intr\n",
    "        self.divr = divr if(divr != None) else self.divr\n",
    "        \n",
    "        self.vol_std = self.vol * np.sqrt(self.texp)\n",
    "        self.div_fac = np.exp(-self.texp*self.divr)\n",
    "        self.disc_fac = np.exp(-self.texp*self.intr)\n",
    "    \n",
    "    def price(self, strike, spot, cp=1):\n",
    "        forward = spot / self.disc_fac * self.div_fac\n",
    "        d1 = np.log(forward/strike)/self.vol_std + 0.5*self.vol_std\n",
    "        d2 = d1 - self.vol_std\n",
    "        price = cp * self.disc_fac \\\n",
    "            * ( forward * spst.norm.cdf(cp*d1) - strike * spst.norm.cdf(cp*d2) )\n",
    "        return price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7.084494247829895, 9.08449424782988)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bsm3 = BSM_Ver3(vol=0.2, texp=1.0)\n",
    "\n",
    "bsm3.price(102, 100, 1), bsm3.price(102, 100, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15.029816377425, 17.029816377425)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### not let's try setparams method\n",
    "bsm3.setparams(vol=0.4)\n",
    "### option prices are price same after volatility change !@#$\n",
    "bsm3.price(102, 100, 1), bsm3.price(102, 100, -1)\n",
    "\n",
    "#print( bsm2.__dict__ )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BSM_Ver4:\n",
    "    _vol, texp, intr, divr = None, None, None, None\n",
    "\n",
    "    def __init__(self, vol, texp, intr=0.0, divr=0.0): # Constructor\n",
    "        self._vol, self._texp, self.intr, self.divr = vol, texp, intr, divr\n",
    "        \n",
    "        self.vol_std = vol * np.sqrt(texp)\n",
    "        self.div_fac = np.exp(-texp*divr)\n",
    "        self.disc_fac = np.exp(-texp*intr)\n",
    "\n",
    "    @property  ## Getter\n",
    "    def vol(self):\n",
    "        return self._vol\n",
    "\n",
    "    @vol.setter  ## Setter\n",
    "    def vol(self, vol):\n",
    "        self._vol = vol\n",
    "        self.vol_std = vol * np.sqrt(self.texp)\n",
    "\n",
    "    @property  ## Getter\n",
    "    def texp(self):\n",
    "        return self._texp\n",
    "\n",
    "    @texp.setter  ## Setter\n",
    "    def texp(self, texp):\n",
    "        self.vol_std = self._vol * np.sqrt(texp)\n",
    "        self.div_fac = np.exp(-texp*self.divr)\n",
    "        self.disc_fac = np.exp(-texp*self.intr)\n",
    "    \n",
    "    def price(self, strike, spot, cp=1):\n",
    "        forward = spot / self.disc_fac * self.div_fac\n",
    "        d1 = np.log(forward/strike)/self.vol_std + 0.5*self.vol_std\n",
    "        d2 = d1 - self.vol_std\n",
    "        price = cp * self.disc_fac \\\n",
    "            * ( forward * spst.norm.cdf(cp*d1) - strike * spst.norm.cdf(cp*d2) )\n",
    "        return price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(7.084494247829895, 9.08449424782988)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bsm4 = BSM_Ver4(vol=0.2, texp=1.0)\n",
    "print(bsm4.vol_std)\n",
    "bsm4.price(102, 100, 1), bsm4.price(102, 100, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(15.029816377425, 17.029816377425)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### But... now things are not that simple\n",
    "bsm4.vol = 0.4\n",
    "print(bsm4.vol_std)\n",
    "### option prices are price same after volatility change !@#$\n",
    "bsm4.price(102, 100), bsm4.price(102, 100, cp=-1)\n",
    "#print( bsm2.__dict__ )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5656854249492381\n"
     ]
    }
   ],
   "source": [
    "bsm4.texp = 2\n",
    "print(bsm4.vol_std)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. The class for option contracts \n",
    "* This is to be used with the Black-Scholes __model class__ implemented above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OptionContract:\n",
    "    def __init__(self, undl, opt_type, strike, dexp):\n",
    "        ''' Constructor for this class. '''\n",
    "        self.undl, self.strike, self.dexp = undl, strike, dexp\n",
    "        self.opt_type = opt_type\n",
    "        self.cp = 1 if (opt_type == 'call') else -1\n",
    "\n",
    "    def toString(self):\n",
    "        return('{:s} option on {:s} struck at {:0.1f} maturing on {:s}'\\\n",
    "              .format(self.opt_type, self.undl, self.strike, self.dexp.strftime('%Y.%m.%d')))\n",
    "\n",
    "    def price(self, spot, model):\n",
    "        return model.priceFromContract(spot, self)\n",
    "    \n",
    "class BSM_Model(BSM_Ver4): #Class Inheritance\n",
    "    def priceFromContract(self, spot, contract):\n",
    "        texp = (contract.dexp - dt.date.today()).days/365.25\n",
    "        if(abs(texp - self.texp)>1e-12):\n",
    "            print('Resetting texp of model to {:0.3f}'.format(texp))\n",
    "            self.texp = texp\n",
    "        return self.price(contract.strike, spot, contract.cp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "call option on Tencent struck at 105.0 maturing on 2024.12.25\n",
      "put option on Tencent struck at 95.0 maturing on 2024.12.25\n"
     ]
    }
   ],
   "source": [
    "tc_c105_dec = OptionContract('Tencent', 'call', 105, dexp=dt.date(2024, 12, 25))\n",
    "tc_p95_dec = OptionContract('Tencent', 'put', 95, dexp=dt.date(2024, 12, 25))\n",
    "\n",
    "print(tc_c105_dec.toString())\n",
    "print(tc_p95_dec.toString())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'_vol': 0.2, '_texp': 1, 'intr': 0.0, 'divr': 0.0, 'vol_std': 0.2, 'div_fac': 1.0, 'disc_fac': 1.0}\n"
     ]
    }
   ],
   "source": [
    "bsm_model = BSM_Model(vol=0.2, texp=1)\n",
    "print(bsm_model.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resetting texp of model to 0.819\n",
      "Resetting texp of model to 0.819\n",
      "17.713916986156278 0.8940504602153698\n",
      "Resetting texp of model to 0.819\n",
      "Resetting texp of model to 0.819\n",
      "17.713916986156278 0.8940504602153698\n"
     ]
    }
   ],
   "source": [
    "tc_spot = 120\n",
    "price1 = tc_c105_dec.price(tc_spot, model=bsm_model)\n",
    "price2 = tc_p95_dec.price(tc_spot, model=bsm_model)\n",
    "print( price1, price2 )\n",
    "\n",
    "### Similarly....\n",
    "price3 = bsm_model.priceFromContract(tc_spot, tc_c105_dec)\n",
    "price4 = bsm_model.priceFromContract(tc_spot, tc_p95_dec)\n",
    "print( price3, price4 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "class Choi_Model:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    def priceFromContract(self, spot, contract):\n",
    "        return( (spot-contract.strike) + random.random()*10  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.5585616160445772 9.516961173653664\n"
     ]
    }
   ],
   "source": [
    "tc_spot = 100\n",
    "choi_model = Choi_Model()\n",
    "price1 = tc_c105_dec.price(tc_spot, model=choi_model)\n",
    "price2 = tc_p95_dec.price(tc_spot, model=choi_model)\n",
    "print( price1, price2 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Implementations in PyFENG package\n",
    "\n",
    "* PYPI package: https://pypi.org/project/pyfeng/\n",
    "\n",
    "* Code: https://github.com/PyFE/PyFENG/\n",
    "\n",
    "* Documentation: https://pyfeng.readthedocs.io/en/latest/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyfeng as pf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = pf.Bsm(sigma=0.2, intr=0.0, divr=0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.084494247829895"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.price(102, 100, texp=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 80,  90, 100, 110, 120])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(80, 121, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21.18592951, 13.58910812,  7.96556746,  4.29201094,  2.14729881])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# vectorize\n",
    "m.price(strike=np.arange(80, 121, 10), spot=100, texp=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.2],\n",
       "       [0.5]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sigma = np.array([0.2, 0.5])\n",
    "sigma = sigma[:, None]\n",
    "sigma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.75927238,  7.38869609,  5.52948546],\n",
       "       [16.812035  , 18.83878533, 17.10541288]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = pf.Bsm(sigma, intr=0.05, divr=0.1) # sigma in axis=0\n",
    "m.price(strike=[90, 95, 100], spot=100, texp=1.2, cp=[-1,1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}