Gamma Max, Gamma Neutral, Delta Neutral calculations

[system1system2]

The exact calculation of GM, GN, and DN is one of the jealously guarded secrets in finance communities. The formulas are out there, but you can refine them by accounting for implied volatility. Multiple people have come up with multiple models and they don't share those.

Given how exceptionally important these values are in options trading, open source those models would be a game changer, and make OpenBB Terminal a must-have tool.

It would be great to see both the values and a plot of where GM, GN, and DN sit in the entire options chain.

[jmaslek]

Hey! I have played around slightly with this and can add something.

The biggest issue is that in order to get the historical data, we need snapshots of the full option chain at the end of a given day. As far as I know, this will require a paid subscription to get all the end of day snapshots.

So I can add an implementation for the current snapshot to our backlog and then users can add on with more sophisticated models.

[system1system2]

Being able to automate the daily download of the CBOE data for a given ticker would be a great starting point.

Every morning (before market open), CBOE releases for free the data for the entire options chain for all strikes, for any given ticker.
Let's say AMZN:
https://www.cboe.com/delayed_quotes/amzn/quote_table

By changing the drop-down menu to ALL options range and ALL expirations, you get a CSV file link at the very bottom of the page. Like this:
https://www.cboe.com/014daa2f-31fd-4100-b4a4-f979c8260027

I think there's a json feed for this data, too, but I'm not sure about the syntax.

Some historical options data is available for free here: https://www.cboe.com/us/options/market_statistics/historical_data/
but I'm not sure it's right to perform the GM, GN, DN calculations.

The most articulated methodology to calculate the values can found here:
https://www.reddit.com/r/Superstonk/comments/q42pxl/delta_neutral_holding_steady_price_increase/

I hope this is a good starting point.

(in my understanding, a Bloomberg terminal offers up to 90 days of historical options chain data. So, assuming an automated daily download and appropriate data organization, it's not impossible for a user to build up that kind of data set for one or more tickers).

[jmaslek]

So it looks like that quote table can be hit using:

requests.get("https://cdn.cboe.com/api/global/delayed_quotes/options/AMZN.json").json()["options"]

You could easily just set up a script to run this for tickers you want and dump it to whatever your preferred storage is.

Given that this gives OI and delta, I think I can try spinning up a model that returns some of these. Then a user could automate their data collection for the ticker and then just run the function to get the values. Gimme a few days to look further.

[jmaslek]

Hey @system1system2. I went a little overboard after House of Dragon last night. Here is a VERY SIMPLE script to get delta neutral for a given ticker. If you call this function DeltaNeutral, you can do python DeltaNeutral.py --ticker AMZN

This can be improved I am sure and I can look into GN and GM, but for now I work :D

from datetime import datetime, timedelta
import re
import numpy as np
from scipy.stats import norm
from scipy.optimize import minimize
import pandas as pd
import requests
import click

def prepare_cboe_data(ticker:str)->pd.DataFrame:
    r = requests.get(f"https://cdn.cboe.com/api/global/delayed_quotes/options/{ticker}.json",
                     headers={"User-Agent":"Mozilla/5.0"})
    df = pd.DataFrame(r.json()["data"]["options"])
    current_price = r.json()["data"]["current_price"]
    df["strike"] = df.apply(
        lambda x: int(re.compile(r'^(.+)([0-9]{6})([PC])([0-9]+)').search(x.option)[4]) / 1000, axis=1)

    df["call"] = df.apply(
        lambda x: re.compile(r'^(.+)([0-9]{6})([PC])([0-9]+)').search(x.option)[3], axis=1)

    df["exp_date"] = df.apply(lambda x:
                                                  datetime.strptime(
                                                      "20" +
                                                      re.compile(r'^(.+)([0-9]{6})([PC])([0-9]+)').search(x.option)[2],
                                                      "%Y%m%d")
                                                  , axis=1)

    df["dte"] = df.apply(lambda x:
                                             ((x.exp_date + timedelta(hours=16)) - datetime.now()).total_seconds() / (
                                                         60 * 60 * 24 * 365),
                                             axis=1)
    df = df[df.iv > 0]
    df = df[df.open_interest > 0]
    df = df[df.last_trade_time != None]
    df = df[df.dte > 0]
    return df, current_price


def delta_at_strike(strike:float,
                    underlying_price:float,
                    iv:float,
                    dte:float,
                    option:str="C",
                    rf_rate:float = 0.03):
    if not isinstance(option, str):
        raise ValueError("option must be a string of either 'C' or 'P'")
    if option.upper() not in ["C","P"]:
        raise ValueError("option must be either 'C' or 'P'")
    d1 = (np.log(underlying_price/strike) + (rf_rate + 0.5*iv**2)*dte) / (iv*np.sqrt(dte))
    if option == "C":
        return norm.cdf(d1)
    return norm.cdf(d1)-1

def get_abs_market_delta(underlying_price:float,
                     df,
                     rf_rate=0.03):
    for col in ["iv","dte", "open_interest","strike","call"]:
        if col not in df.columns:
            raise ValueError(f"{col} needs to be in df")
    df["new_delta"] = df.apply(lambda x:
                               delta_at_strike(x.strike,underlying_price,x.iv,x.dte,x.call,rf_rate),
                               axis=1)
    df["md"] = df["new_delta"] * df["open_interest"]
    return np.abs(df["md"].sum())

def gamma_at_strike(strike:float,
                    underlying_price:float,
                    iv:float,
                    dte:float,
                    rf_rate:float = 0.03):

    d1 = (np.log(underlying_price/strike) + (rf_rate + 0.5*iv**2)*dte) / (iv*np.sqrt(dte))
    return norm.pdf(d1)/(underlying_price * iv * np.sqrt(dte))

def get_market_gamma(underlying_price: float,
                     df,
                     abs_mg=True,
                     rf_rate=0.03):
    for col in ["iv", "dte", "open_interest", "strike", "call"]:
        if col not in df.columns:
            raise ValueError(f"{col} needs to be in df")
    df["new_gamma"] = df.apply(lambda x:
                               gamma_at_strike(x.strike, underlying_price, x.iv, x.dte, rf_rate),
                               axis=1)
    df["mg"] = df["new_gamma"] * df["open_interest"]
    df.loc[df.call=="P","mg"] *= -1
    if abs_mg:
        return np.abs(df["mg"].sum())
    return -1*df["mg"].sum()


def get_delta_neutral(ticker:str):
    df, current_price = prepare_cboe_data(ticker)
    delta_neutral_price = minimize(get_abs_market_delta, args=(df), x0=current_price).x[0]

    print(f"Current Price: {current_price}")
    print(f"DN Price:      {round(delta_neutral_price,2)}")


def get_gamma_neutral(ticker:str):
    df, current_price = prepare_cboe_data(ticker)
    gamma_neutral_price = minimize(get_market_gamma, args=(df), x0=current_price).x[0]

    #rint(f"Current Price: {current_price}")
    print(f"GN Price:      {round(gamma_neutral_price,2)}")

def get_gamma_max(ticker:str):
    df, current_price = prepare_cboe_data(ticker)
    gamma_max_price = minimize(get_market_gamma, args=(df,False), x0=current_price).x[0]

    #rint(f"Current Price: {current_price}")
    print(f"GM Price:      {round(gamma_max_price,2)}")

@click.command()
@click.option('--ticker', help='Ticker.')
def both(ticker):
    get_delta_neutral(ticker)
    get_gamma_neutral(ticker)
    get_gamma_max(ticker)

if __name__=="__main__":
    both()

[system1system2]

@jmaslek Outstanding!

@deeleeramone I'm familiar with hardyrekshin website, but I often see DN/GN/GM numbers very different from his. It's one of those situations where the model differs.

That's why I'm advocating for a mechanism that allows the community to swap the model.

[jmaslek]

For reference, here is what I get for SPY 442 PM EST: (also this calculation is soooooo slow)

% python DeltaNeutral.py --ticker SPY
Current Price: 360.36
DN Price:      392.85
GN Price:      2278.6
GM Price:      430.77

[deeleeramone]

@deeleeramone I'm familiar with hardyrekshin website, but I often see DN/GN/GM numbers very different from his. It's one of those situations where the model differs.

This might be because the risk-free rate on hardyrekshin is hard-coded and has not been updated since it rose well above 0%. A variable RFR is definitely a requirement here, it's swinging wider than meme stonks now.

That's why I'm advocating for a mechanism that allows the community to swap the model.

That is a great idea, and then the community can build their own models and add them as well. 😄

[system1system2]

I was hoping this feature would make it in 2.0, but I don't see it anywhere. Shame!

Nonetheless, thank you for this new release. It looks great.

[rdyvptnm]

HI How do i download CSV file. I would like to download the SPX options chain for every 5 minutes