Options Calculator with Black Scholes model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Options Calculator with Black Scholes model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to know more information about a stock option, this options calculator with Black-Scholes Model, the first widely used model for option pricing, can provide the call/put option price, d1, d2, and Greek letters. It can assist investors in establishing an option trading strategy. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Certain assumptions must be made due to this calculator is modeled by Black-Scholes model. \n",
    "  * It works on European options that can only be exercised at expiration.\n",
    "  * No dividends are paid out during the option’s life.\n",
    "  * Stock markets are efficient. \n",
    "  * There are no transaction and commissions costs in buying the option.\n",
    "  * The risk-free rate and volatility of the underlying are known and constant.\n",
    "  * The returns on the underlying are normally distributed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Input variables:\n",
    "  * Underlying price (per share): S; \n",
    "  * Strike price of the option (per share): K;\n",
    "  * Time to maturity (years): T;\n",
    "  * Continuously compounding risk-free interest rate: r;\n",
    "  * Volatility: sigma;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Output Variables:\n",
    "The cumulative density function of normal distribution N(.)\n",
    "- N(d2) is the risk-adjusted probability that the option will be exercised.\n",
    "- N(d1) is the probability of receiving the stock at expiration of the option.\n",
    "\n",
    "The Greek letters\n",
    "- Delta: The rate of change of the option price respected to the rate of the change of underlying asset price. \n",
    "- Gamma: The rate of change of delta respected to the rate of change of underlying asset price.\n",
    "- Vega: The rate of change of the option price respected to the volatility of the underlying asset. \n",
    "- Rho: The rate of the option price respected to the interest rate. \n",
    "- Theta: The rate of change of the option price respected to the passage of time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## import certain packages\n",
    "from math import log, sqrt, pi, exp\n",
    "from scipy.stats import norm\n",
    "from datetime import datetime, date\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pandas import DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Underlying price (per share): S; \n",
    "# Strike price of the option (per share): K;\n",
    "# Time to maturity (years): T;\n",
    "# Continuously compounding risk-free interest rate: r;\n",
    "# Volatility: sigma;\n",
    "\n",
    "## define two functions, d1 and d2 in Black-Scholes model\n",
    "def d1(S,K,T,r,sigma):\n",
    "    return(log(S/K)+(r+sigma**2/2.)*T)/sigma*sqrt(T)\n",
    "def d2(S,K,T,r,sigma):\n",
    "    return d1(S,K,T,r,sigma)-sigma*sqrt(T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## define the call options price function\n",
    "def bs_call(S,K,T,r,sigma):\n",
    "    return S*norm.cdf(d1(S,K,T,r,sigma))-K*exp(-r*T)*norm.cdf(d2(S,K,T,r,sigma))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## define the put options price function\n",
    "def bs_put(S,K,T,r,sigma):\n",
    "    return K*exp(-r*T)-S+bs_call(S,K,T,r,sigma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "## define the Call_Greeks of an option\n",
    "def call_delta(S,K,T,r,sigma):\n",
    "    return norm.cdf(d1(S,K,T,r,sigma))\n",
    "def call_gamma(S,K,T,r,sigma):\n",
    "    return norm.pdf(d1(S,K,T,r,sigma))/(S*sigma*sqrt(T))\n",
    "def call_vega(S,K,T,r,sigma):\n",
    "    return 0.01*(S*norm.pdf(d1(S,K,T,r,sigma))*sqrt(T))\n",
    "def call_theta(S,K,T,r,sigma):\n",
    "    return 0.01*(-(S*norm.pdf(d1(S,K,T,r,sigma))*sigma)/(2*sqrt(T)) - r*K*exp(-r*T)*norm.cdf(d2(S,K,T,r,sigma)))\n",
    "def call_rho(S,K,T,r,sigma):\n",
    "    return 0.01*(K*T*exp(-r*T)*norm.cdf(d2(S,K,T,r,sigma)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "## define the Put_Greeks of an option\n",
    "def put_delta(S,K,T,r,sigma):\n",
    "    return -norm.cdf(-d1(S,K,T,r,sigma))\n",
    "def put_gamma(S,K,T,r,sigma):\n",
    "    return norm.pdf(d1(S,K,T,r,sigma))/(S*sigma*sqrt(T))\n",
    "def put_vega(S,K,T,r,sigma):\n",
    "    return 0.01*(S*norm.pdf(d1(S,K,T,r,sigma))*sqrt(T))\n",
    "def put_theta(S,K,T,r,sigma):\n",
    "    return 0.01*(-(S*norm.pdf(d1(S,K,T,r,sigma))*sigma)/(2*sqrt(T)) + r*K*exp(-r*T)*norm.cdf(-d2(S,K,T,r,sigma)))\n",
    "def put_rho(S,K,T,r,sigma):\n",
    "    return 0.01*(-K*T*exp(-r*T)*norm.cdf(-d2(S,K,T,r,sigma)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Input "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is the current stock price? 100\n",
      "What is the strike price? 100\n",
      "What is the expiration date of the options? (mm-dd-yyyy) 02-03-2019\n",
      "What is the continuously compounding risk-free interest rate in percentage(%)? 20\n",
      "What is the volatility in percentage(%)? 20\n"
     ]
    }
   ],
   "source": [
    "## input the current stock price and check if it is a number.\n",
    "S = input(\"What is the current stock price? \");\n",
    "while True:\n",
    "    try:\n",
    "        S = float(S)\n",
    "        break\n",
    "    except:\n",
    "        print(\"The current stock price has to be a NUMBER.\")\n",
    "        S = input(\"What is the current stock price? \")\n",
    "\n",
    "## input the strike price and check if it is a number.\n",
    "K = input(\"What is the strike price? \");\n",
    "while True:\n",
    "    try:\n",
    "        K = float(K)\n",
    "        break\n",
    "    except:\n",
    "        print(\"The the strike price has to be a NUMBER.\")\n",
    "        K = input(\"What is the strike price? \")\n",
    "\n",
    "\n",
    "## input the expiration_date and calculate the days between today and the expiration date.\n",
    "while True:\n",
    "    expiration_date = input(\"What is the expiration date of the options? (mm-dd-yyyy) \")\n",
    "    try:\n",
    "        expiration_date = datetime.strptime(expiration_date, \"%m-%d-%Y\")\n",
    "    except ValueError as e:\n",
    "        print(\"error: %s\\nTry again.\" % (e,))\n",
    "    else:\n",
    "        break\n",
    "T = (expiration_date - datetime.utcnow()).days / 365\n",
    "\n",
    "\n",
    "## input the continuously compounding risk-free interest rate and check if it is a number.\n",
    "r = input(\"What is the continuously compounding risk-free interest rate in percentage(%)? \");\n",
    "while True:\n",
    "    try:\n",
    "        r = float(r)\n",
    "        break\n",
    "    except:\n",
    "        print(\"The continuously compounding risk-free interest rate has to be a NUMBER.\")\n",
    "        r = input(\"What is the continuously compounding risk-free interest rate in percentage(%)? \")\n",
    "        \n",
    "\n",
    "## input the volatility and check if it is a number.\n",
    "sigma = input(\"What is the volatility in percentage(%)? \"); \n",
    "while True:\n",
    "    try:\n",
    "        sigma = float(sigma)\n",
    "        if sigma > 100 or sigma < 0:\n",
    "            print ( \"The range of sigma has to be in [0,100].\")\n",
    "            sigma = input(\"What is the volatility in percentage(%)? \")\n",
    "        break\n",
    "    except:\n",
    "        print(\"The volatility has to be a NUMBER.\")\n",
    "        sigma = input(\"What is the volatility in percentage(%)? \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Symbol</th>\n",
       "      <th>Input</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Underlying price</th>\n",
       "      <td>S</td>\n",
       "      <td>100.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Strike price</th>\n",
       "      <td>K</td>\n",
       "      <td>100.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Time to maturity</th>\n",
       "      <td>T</td>\n",
       "      <td>0.128767</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Risk-free interest rate</th>\n",
       "      <td>r</td>\n",
       "      <td>20.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Volatility</th>\n",
       "      <td>sigma</td>\n",
       "      <td>20.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        Symbol       Input\n",
       "Underlying price             S  100.000000\n",
       "Strike price                 K  100.000000\n",
       "Time to maturity             T    0.128767\n",
       "Risk-free interest rate      r   20.000000\n",
       "Volatility               sigma   20.000000"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## make a DataFrame of these inputs\n",
    "\n",
    "data = {'Symbol': ['S', 'K', 'T', 'r', 'sigma'],\n",
    "        'Input': [S, K, T , r , sigma]}\n",
    "input_frame = DataFrame(data, columns=['Symbol', 'Input'], \n",
    "                   index=['Underlying price', 'Strike price', 'Time to maturity', 'Risk-free interest rate', 'Volatility'])\n",
    "input_frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Call</th>\n",
       "      <th>Put</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Price</th>\n",
       "      <td>4.112199</td>\n",
       "      <td>1.569736</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>delta</th>\n",
       "      <td>0.520269</td>\n",
       "      <td>-0.479731</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>gamma</th>\n",
       "      <td>0.055516</td>\n",
       "      <td>0.055516</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>vega</th>\n",
       "      <td>0.142972</td>\n",
       "      <td>0.142972</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>rho</th>\n",
       "      <td>0.061698</td>\n",
       "      <td>-0.063795</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>theta</th>\n",
       "      <td>-0.206861</td>\n",
       "      <td>-0.011946</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           Call       Put\n",
       "Price  4.112199  1.569736\n",
       "delta  0.520269 -0.479731\n",
       "gamma  0.055516  0.055516\n",
       "vega   0.142972  0.142972\n",
       "rho    0.061698 -0.063795\n",
       "theta -0.206861 -0.011946"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## calculate the call / put option price and the greeks of the call / put option\n",
    "r = r/100; sigma = sigma/100;\n",
    "price_and_greeks = {'Call' : [bs_call(S,K,T,r,sigma), call_delta(S,K,T,r,sigma), call_gamma(S,K,T,r,sigma),call_vega(S,K,T,r,sigma), call_rho(S,K,T,r,sigma), call_theta(S,K,T,r,sigma)],\n",
    "                    'Put' : [bs_put(S,K,T,r,sigma), put_delta(S,K,T,r,sigma), put_gamma(S,K,T,r,sigma),put_vega(S,K,T,r,sigma), put_rho(S,K,T,r,sigma), put_theta(S,K,T,r,sigma)]}\n",
    "price_and_greeks_frame = DataFrame(price_and_greeks, columns=['Call','Put'], index=['Price', 'delta', 'gamma','vega','rho','theta'])\n",
    "price_and_greeks_frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Implied volatility"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implied volatility (IV) is “implying” the volatility of the stock will be in the future, based on price changes in an option. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Put or Call option? (P/C)  P\n",
      "What is the option price? 8\n"
     ]
    }
   ],
   "source": [
    "## input a put or call option price\n",
    "\n",
    "option = input (\"Put or Call option? (P/C)  \")\n",
    "while option != 'P' and option !='C' :\n",
    "    print (\"error: this option does not match the format (P/C) \\nTry again.\")\n",
    "    option = input (\"Put or Call option? (P/C)  \")\n",
    "\n",
    "Price = input(\"What is the option price? \");\n",
    "while True:\n",
    "    try:\n",
    "        Price = float(Price)\n",
    "        break\n",
    "    except:\n",
    "        print(\"The the option price has to be a NUMBER.\")\n",
    "        Price = input(\"What is the option price? \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Price' 'S' 'K' 'T' 'r']\n",
      " ['8.0' '100.0' '100.0' '0.12876712328767123' '0.2']]\n",
      "The implied volatility is 66.70000000000005 %.\n"
     ]
    }
   ],
   "source": [
    "## to calculate the volatility of a put/call option\n",
    "\n",
    "def implied_volatility(Price,S,K,T,r):\n",
    "    sigma = 0.001\n",
    "    print (np.array([['Price', 'S', 'K', 'T', 'r'], [Price, S, K, T, r]]))\n",
    "    if option == 'C':\n",
    "        while sigma < 1:\n",
    "            Price_implied = S*norm.cdf(d1(S,K,T,r,sigma))-K*exp(-r*T)*norm.cdf(d2(S,K,T,r,sigma))\n",
    "            if Price-(Price_implied) < 0.001:\n",
    "                return sigma\n",
    "            sigma += 0.001\n",
    "        return \"It could not find the right volatility of the call option.\"\n",
    "    else:\n",
    "        while sigma < 1:\n",
    "            Price_implied = K*exp(-r*T)-S+bs_call(S,K,T,r,sigma)\n",
    "            if Price-(Price_implied) < 0.001:\n",
    "                return sigma\n",
    "            sigma += 0.001\n",
    "        return \"It could not find the right volatility of the put option.\"\n",
    "    return\n",
    "\n",
    "print (\"The implied volatility is \" + str (100* implied_volatility(Price,S,K,T,r)) + \" %.\")"
   ]
  },
  {
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}