Bloomberg terminal option data calculation

Question

EDIT

based on the answer provided, I have followed, but still I cant match the bbg data with my calculations, could some advise how to match the bloomberg Price given the data?

import numpy as np
import scipy.stats as ss
def BlackScholes(payoff, S0, K, T, r, sigma, q):
    d1 = (np.log(S0 / K) + (r - q + sigma**2 / 2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
if payoff == "call":
    return S0 * np.exp(-q * T) * ss.norm.cdf(d1) - K * np.exp(-r * T) * ss.norm.cdf(d2)
elif payoff == "put":
    return K * np.exp(-r * T) * ss.norm.cdf(-d2) - S0 * np.exp(-q * T) * ss.norm.cdf(-d1)


d = 92
h = 5
m = 10
y = 365
T = d/y + h/24/y + m/60/24/y
rr =   0.05277
q =0
S0 = 4739.21
K = 4740
sigma = 0.12954
print(BlackScholes(payoff='call', S0=S0, K=K, T=T, r=rr, sigma=sigma, q=q))
155.7605850060304

---

I am trying to reconcile SPY Bloomberg Terminal option data, but for some reason, it doesn't match. I would expect this to match the Mid for the 475 strike, but it doesn't

T = 30/365
q = 0
r = 0.0548
S0 = 474.93
payoff = 'call'
K = 475
F = 477.1
print(BlackScholesWithForwards(payoff='call', F=F, K=K, T=T, r=r, sigma=11.84289027/100, q=q))
8.771200411422967

Option monitor bloomberg data, as of 17 Jan 24:

Expiry	Days to Expiry	Contract Size	Risk-Free Rate	Forward Price
16-Feb-24 (30d)	30	100	5.480000	477.100000

Strike	Ticker	Bid	Ask	Last	IVM	Volm
470	SPY 2/16/24 C470	11.279999	11.329999	11.109999	12.769134	1322
471	SPY 2/16/24 C471	10.550000	10.600000	10.020000	12.529111	1048
472	SPY 2/16/24 C472	9.840000	9.880000	9.859999	12.406106	1355
473	SPY 2/16/24 C473	9.159999	9.189999	9.140000	12.176440	1285
474	SPY 2/16/24 C474	8.489999	8.520000	8.510000	12.000890	3941
475	SPY 2/16/24 C475	7.849999	7.880000	7.880000	11.842890	10970
476	SPY 2/16/24 C476	7.239999	7.260000	7.230000	11.700001	6087
477	SPY 2/16/24 C477	6.650000	6.670000	6.670000	11.542202	4000

import numpy as np
import scipy.stats as ss
def BlackScholesWithForwards(payoff='call', F=1000, K=100, T=None, r=None, sigma=0.35, q=0):
    # Check if T and r are provided; if not, use default values or raise an exception
    if T is None or r is None:
        raise ValueError("Please provide values for T and r")
d1 = (np.log(F / K) + (r - q + sigma**2 / 2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)

if payoff == "call":
    return np.exp(-q * T) * (F * ss.norm.cdf(d1) - K * np.exp(-r * T) * ss.norm.cdf(d2))
elif payoff == "put":
    return np.exp(-r * T) * (K * ss.norm.cdf(-d2) - F * np.exp(-q * T) * ss.norm.cdf(-d1))
else:
    raise ValueError("Invalid value for payoff. Use 'call' or 'put'.")

Answer 1

You can use Bloomberg to get the bulk of work done for you:

• If you load the ticker in OVME L, you load the OTC pricer OVME in listed mode. That will also load the market value of the option and all market data at the secific time it was loaded.
• Within OVME, make sure your setting is set to use exact time to expiry (minutes, not just integer days). You will see the hours to expiry alongside the date.
• In more market data (OVME has a few settings, so the exact look can differ), you can see all rates, the forward and dividends.
• You can start by setting rates and divs to zero. That way its easiest to match
• Once you are done with that look at rates (for calls, European and American will be identical). Black is for continuous rates.
• Afterwards, look at dividends. If the ticker loads with dividends, you can no longer use the simple formula you used (which is in fact incorrect as well). If you see that Bloomberg uses discrete, it uses a PDE solver and discrete dividend payments to compute the American option value.
• SPY options are American options. Therefore, a simple BS pricing tool will not be sufficient.

If you use the forward, you look at Black76. In this case, you no longer have dividends and interest rates in the closed form solution because these are incorporated into the forward price already.

In dummy code, you either use

 BSM(s,k,t,r,d, σ, cp)
        d1 = ( log(s/k) + (r - d+ σ^2/2)*t ) / (σ*sqrt(t))
        d2 = d1 - σ*sqrt(t) 
        opt = exp(-d*t)*cp*s*N(cp*d1) - cp*k*exp(-r*t)*N(cp*d2)

where cp is a put / call flag which is 1 for a call, and -1 for a put and r and d need to be transformed to the continuous analogue of the discrete rate from the market quote.

or

Black76(F,K,t,r,σ, cp)
    d1 = (log(F/K) + 0.5*σ^2*t)/ σ*sqrt(t)
    d2 = d1 - σ*sqrt(t)
    opt = cp*exp(-r*t)*(F*N(cp*d1) - K*N(cp*d2))

What you did was mixing these two formulas together.

EDIT

As mentioned in the comment, you need to look at the exact details of the settings. Interest rates are usually following its own market convention. Also, if you solve for IV you may not get to see the entire precision. To simplify things, enter values manually where you do see all precision (and therefore solve for price as opposed to IV). I do not know your settings, but I will include screenshots of mine, and all values used in pricing.

I priced the following option:

• Interest Rate Settlement in the Market Data tab can be Market Convention or 0 Days. The former is T+2 (hence 2 days less than the option expiry).
• Daycount Convention in the Pricing tab is Act/360 if set to Swap Convention.
• I manually entered "clean" values so that there is no problem with decimal precision that is invisible in the GUI. I also set the day to be exactly a full day, to avoid further complication with hours and minutes to expiry.

Within Python, you can use the following

# packages 
import numpy as np
from scipy.stats import norm
import pandas as pd
# Black Scholes formula
def BSM(S,K,r,d,t, sigma, cp_flag):
    d1 = ((np.log(S/K) + (r - d + 0.5 * sigma **2) * t) / (sigma * np.sqrt (t)))
    d2 = d1 - sigma * np.sqrt(t) 
    opt = cp_flag*S *np.exp(-d*t)* norm.cdf(cp_flag*d1) - cp_flag* K * np.exp(-r*t)  * norm.cdf(cp_flag*d2)
    delta = cp_flag*np.exp(-d*t)*norm.cdf(cp_flag*d1)
    return opt, delta
# inputs 
s, k, t, σ, d  , r , cp_flag= 4860,  4860,  (90+ 0/24)/365, 0.1, 0.0 , 0.05, 1
r = np.log(1+r* (90-2)/360)/t # account for ACT/360 with T+2 and make it continuous
print(r)
#price option 
c = BSM(s,k,r,d, t, σ, cp_flag)
pd.set_option('float_format', '{:.5f}'.format)
pd.DataFrame({"Price (Share)" : [c[0]], 
                            "Delta": [c[1]*100]})

The output matches the call option price and delta from above exactly.

Ultimately, pricing even the simplest vanilla options is quite complicated once you take into account all market conventions and details. That's why replicating options prices from proper pricing tools is difficult, and sometimes impossible with certain tools like quantlib because the functionality simply does not support all details.

Some examples:

• Replicating MATLAB's 30/360 (SIA) in Black-76
• Quantlib vs Bloomberg FX option valuation
• Price and Gamma of TYQ1C 133.00 COMB Comdty OVME where quantlib does not support the price quotation used by the exchange.