def struct_to_dict(s, as_namedtuple=True):
if as_namedtuple:
if s.dtype.names:
nt = namedtuple('db', s.dtype.names)
d = {}
for x in s.dtype.names:
try:
if x in ['Parameters', 'marginalt', 'DCCfit']:
d[x] = struct_to_dict(s[x])
elif isinstance(s[x], np.ndarray):
if x == 'sig2':
d[x] = s[x][0]
else:
d[x] = s[x]
else:
d[x] = np.atleast_1d(s[x]).flatten()[0]
except:
d[x] = None
nt = nt(**d)
return nt
else:
if s.dtype.names:
return {x: np.atleast_1d(s[x]).flatten()[0] for x in s.dtype.names}
i_ = 25 # number of stocks
t_ = 100 # len of time series
j_ = 500 # number of simulated time series for each k-th DGP [low for speed increase for accuracy]
k_ = 5 # number of perturbed DGP's [low for speed]
h = 0 # DGP whose loss is plotted
# -
# ## Upload databases
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_StocksS_P'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_StocksS_P'), squeeze_me=True)
Data = struct_to_dict(db['Data'])
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_VIX'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_VIX'), squeeze_me=True)
VIX = struct_to_dict(db['VIX'], as_namedtuple=False)
# -
# ## Compute the stocks' log-returns
# +
dates_x = Data.Dates
x = Data.Prices
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_PricingScenarioBased'),
squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_PricingScenarioBased'),
squeeze_me=True)
# ## Compute the holdings corresponding to the following portfolio, fully invested in the n_=15 instruments
# ## $50k are invested in the stocks, such that the stocks are equally weighted
# ## The holdings in each bond are h=5000 (i.e. each bond has $5000 notional)
# ## The call options (same expiry, increasing strikes) have respective
# ## holdings equal to [1 -2, 1] (long butterfly strategy)
# +
Stocks = struct_to_dict(db['Stocks'], as_namedtuple=False)
Bonds = struct_to_dict(db['Bonds'], as_namedtuple=False)
Options = struct_to_dict(db['Options'], as_namedtuple=False)
v_tnow = db['v_tnow'].reshape(-1, 1)
Pi = db['Pi']
t_ = db['t_']
v0_stocks = 50000
w_stocks = ones((Stocks['n_'], 1)) / Stocks['n_']
Stocks['h'] = round((w_stocks * v0_stocks) / Stocks['v_tnow'].reshape(-1, 1))
Bonds['h'] = 5000 * ones((Bonds['n_'], 1))
Options['h'] = array([[1], [-2], [1]])
h = r_[Stocks['h'], Bonds['h'], Options['h']] # ## holdings
cash = 0
# -
from autocorrelation import autocorrelation
from TradeQuoteProcessing import TradeQuoteProcessing
from InvarianceTestEllipsoid import InvarianceTestEllipsoid
# -
# ## Upload the database
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_US_10yr_Future_quotes_and_trades'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_US_10yr_Future_quotes_and_trades'), squeeze_me=True)
# ## Process the time series, refining the raw data coming from the database
# +
quotes = struct_to_dict(db['quotes'])
trades = struct_to_dict(db['trades'])
dates_quotes = quotes.time_names #
t = quotes.time # time vector of quotes
p_bid = quotes.bid # bid prices
p_ask = quotes.ask # ask prices
q_bid = quotes.bsiz # bid volumes
q_ask = quotes.asiz # ask volumes
dates_trades = trades.time_names #
t_k = trades.time # time vector of trades
p_last = trades.price # last transaction prices
delta_q = trades.siz # flow of traded contracts' volumes
delta_sgn = trades.aggress # trade sign flow
match = trades.mtch # match events: - the "1" value indicates the "start of a match event" while zeros indicates the "continuation of a match event"
from CONFIG import GLOBAL_DB, TEMPORARY_DB
from ARPM_utils import save_plot, struct_to_dict, date_mtop
from FitStochasticVolatilityModel import FitStochasticVolatilityModel
from FilterStochasticVolatility import FilterStochasticVolatility
from PlotTwoDimEllipsoid import PlotTwoDimEllipsoid
# -
# ## Upload database
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_Stocks'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_Stocks'), squeeze_me=True)
SPX = struct_to_dict(db['SPX'])
# daily prices and log-prices
price = SPX.Price_close
date = SPX.Date
logprice = log(price)
# -
# ## Compute weekly prices, returns and the log-square volatility
# ##pick weekly data
# +
w = arange(0, len(logprice), 5)
date = array([date_mtop(i) for i in SPX.Date[w]])
# prices
plt.style.use('seaborn')
# -
# ## Upload data from db_ImpliedVol_FX
# +
from CONFIG import GLOBAL_DB, TEMPORARY_DB
from ARPM_utils import save_plot, struct_to_dict
from intersect_matlab import intersect
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_ImpliedVol_FX'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_ImpliedVol_Fx'), squeeze_me=True)
db_ImpliedVol_FX = struct_to_dict(db['db_ImpliedVol_FX'])
# implied volatility surface for GBPUSD rate (in percentage format)
tau = db_ImpliedVol_FX.TimesToMaturity
delta = db_ImpliedVol_FX.Delta
sigma_delta = db_ImpliedVol_FX.Sigma
t_ = sigma_delta.shape[2]
n_ = len(delta)
# -
# ## Plot the implied volatility surface and the evolution of implied volatility for the desired values of delta-moneyness and times to maturity
# +
_,tauIndex,_ = intersect(tau,1) # select 1 year of maturity
meanIndex_delta = int(ceil((n_)/2))-1
from ARPM_utils import save_plot, struct_to_dict
from TestKolSmirn import TestKolSmirn
from InvarianceTestKolSmirn import InvarianceTestKolSmirn
# -
# ## Upload the database
# ## Upload daily stock prices from db_Stocks
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_Stocks'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_Stocks'), squeeze_me=True)
StocksSPX = struct_to_dict(db['StocksSPX'])
# -
# ## Compute the dividend adjusted prices of one stock
stock_index = 0
v = StocksSPX.Prices[[stock_index], :]
date = StocksSPX.Date
div = StocksSPX.Dividends[stock_index][0]
# if not div:
# v,_=Price2AdjustedPrice(date,v,div)
# ## Compute the time series for each variable
x = v[[0], 1:] / v[[0], :-1]
y = v[[0], 1:] - v[[0], :-1]
from HistogramFP import HistogramFP
from ColorCodedFP import ColorCodedFP
from IterGenMetMomFP import IterGenMetMomFP
from binningHFseries import binningHFseries
from BlowSpinFP import BlowSpinFP
# -
# ## Upload database
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_US_10yr_Future_quotes_and_trades'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_US_10yr_Future_quotes_and_trades'), squeeze_me=True)
trades = struct_to_dict(db['trades'])
# -
# ## Comupte the invariants: eps= dn = number of trades in 1-second time intervals
# +
flag_dt = '1second'
trade = unique(trades.time) # trade time
dk, k,*_ = binningHFseries(trade, flag_dt)
time = array([date_mtop(i) for i in arange(trade[0], trade[-1], 1.1574e-05)])
# time = cellstr((time))
time = time[1:]
epsi = dk
t_ = epsi.shape[1]
# -
from Delta2MoneynessImplVol import Delta2MoneynessImplVol
from FitVAR1 import FitVAR1
from ExponentialDecayProb import ExponentialDecayProb
from InverseCallTransformation import InverseCallTransformation
# -
# ## Upload databases and match the time series of interest to work with synchronous observations
# +
#load
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_Stocks'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_Stocks'), squeeze_me=True)
StocksSPX = struct_to_dict(db['StocksSPX'], as_namedtuple=False)
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_SwapCurve'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_SwapCurve'), squeeze_me=True)
DF_Rolling = struct_to_dict(db['DF_Rolling'], as_namedtuple=False)
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_ImpliedVol_SPX'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_ImpliedVol_SPX'),
squeeze_me=True)
db_ImpliedVol_SPX = struct_to_dict(db['db_ImpliedVol_SPX'],
squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_SPX_zcb_Invariants'),
squeeze_me=True)
dates = db['dates']
epsi_SPX = db['epsi_SPX']
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_VIX'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_VIX'), squeeze_me=True)
from ARPM_utils import struct_to_dict
VIX = struct_to_dict(db['VIX'])
# -
# ## Recover the time series of realized invariants
# VIX's compounded returns
c_VIX = diff(log(VIX.value))
# ## Compute the time series of the conditioning variable by applying sequentially smoothing and scoring filters to the time series of VIX's compounded returns
# +
t_vix = len(c_VIX)
times = arange(t_vix)
# smoothing
z_vix = zeros((1, t_vix))
from TradeQuoteProcessing import TradeQuoteProcessing
# -
# ## Upload the database
# +
try:
db = loadmat(os.path.join(GLOBAL_DB,
'db_US_10yr_Future_quotes_and_trades'),
squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB,
'db_US_10yr_Future_quotes_and_trades'),
squeeze_me=True)
quotes = struct_to_dict(db['quotes'], as_namedtuple=False)
trades = struct_to_dict(db['trades'], as_namedtuple=False)
# -
# ## Process the time series, refining the raw data coming from the database
# +
dates_quotes = quotes['time_names'] #
t = quotes['time'] # time vector of quotes
p_bid = quotes['bid'] # bid prices
p_ask = quotes['ask'] # ask prices
q_bid = quotes['bsiz'] # bid volumes
q_ask = quotes['asiz'] # ask volumes
dates_trades = trades['time_names'] #
t_k = trades['time'] # time vector of trades
# -
# ## Upload the implied-volatility and the underlying value data from db_ImpliedVol_SPX
# and the realized time series of the rolling values contained in db_SwapCurve.
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_ImpliedVol_SPX'))
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_ImpliedVol_SPX'))
try:
db_swap = loadmat(os.path.join(GLOBAL_DB, 'db_SwapCurve'))
except FileNotFoundError:
db_swap = loadmat(os.path.join(TEMPORARY_DB, 'db_SwapCurve'))
db_ImpliedVol_SPX = struct_to_dict(db['db_ImpliedVol_SPX'])
DF_Rolling = struct_to_dict(db_swap['DF_Rolling'])
# ## run S_PricingCallOptionValue which computes the call option exact pricing
from S_PricingCallOptionValue import *
# call option price at time t=0
d1_0 = (log(S_u[0, 0] / k) / sqrt(expiry / 252) + sqrt(expiry / 252) *
(Y[0, 0] + 0.5 * exp(LogSigma_interp[0, 0])**2)) / exp(
LogSigma_interp[0, 0])
d2_0 = d1_0 - exp(LogSigma_interp[0, 0]) * sqrt(expiry / 252)
Vcall_0 = S_u[0, 0] * (norm.cdf(d1_0) - exp(-(
(log(S_u[0, 0] / k) / sqrt(expiry / 252)) * sqrt(expiry / 252) +
Y[0, 0] * expiry / 252)) * norm.cdf(d2_0))
from FPmeancov import FPmeancov
from intersect_matlab import intersect
from HistogramFP import HistogramFP
from SimulateBrownMot import SimulateBrownMot
# -
# ## Load the historical series of the S&P 500 from StocksS_P
# ## and the historical series of hte daily exchange rate from db_FX.
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_StocksS_P'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_StocksS_P'), squeeze_me=True)
Data = struct_to_dict(db['Data'])
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_FX'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_FX'), squeeze_me=True)
USD_GBP = struct_to_dict(db['USD_GBP'])
# -
# ## Select the daily price of the Priceline.com Inc equity (S&P 500 dataset with n= 279)
# ## and the USD/GBP daily exchange rate (USD_GBP.FX from db_FX), and compute the risk drivers,
# ## that are the log-value for the equity and the log-rate for the spot exchange rate.
# +
t_end = 240
nu = 4 # degrees of freedom of the t copula we want to fit
nu_vec = arange(2, 31)
nu_ = len(nu_vec)
j_ = 2000 # number of scenarios
k_ = 1 # factors for correlation shrinkage
# -
# ## Upload databases
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_Stocks'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_Stocks'), squeeze_me=True)
SPX = struct_to_dict(db['SPX'])
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_CorporateBonds'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_CorporateBonds'),
squeeze_me=True)
GE = struct_to_dict(db['GE'])
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_VIX'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_VIX'), squeeze_me=True)
VIX = struct_to_dict(db['VIX'])
from ARPM_utils import save_plot, struct_to_dict
from autocorrelation import autocorrelation
from FitFractionalIntegration import FitFractionalIntegration
from InvarianceTestEllipsoid import InvarianceTestEllipsoid
# -
# ## Upload database
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_StocksHighFreq'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_StocksHighFreq'),
squeeze_me=True)
MSFT = struct_to_dict(db['MSFT'])
price = MSFT.trade_price
ask = MSFT.ask
bid = MSFT.bid
# -
# ## Compute the realizations of the variable "sign" (dz_k: difference in cumulative trade sign in tick time)
# ##take data with (ask > bid) and (price = bid or price = ask) and (bid different form ask)
scale = 5
index = ((bid != ask) & (price == bid)) | ((price == ask) & (ask > bid))
frac = (price[index] - bid[index]) / (ask[index] - bid[index])
dz_k = erf(scale * (2 * frac - 1))
# ## Fit the fractional integration process
plt.style.use('seaborn')
from CONFIG import GLOBAL_DB, TEMPORARY_DB
from ARPM_utils import save_plot, struct_to_dict, date_mtop
from intersect_matlab import intersect
# -
# ## Upload database
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_Stocks'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_Stocks'), squeeze_me=True)
SPX = struct_to_dict(db['SPX'])
KOSPI = struct_to_dict(db['KOSPI'])
# -
# ## Compute the log-prices and log-returns of the two indexes
# +
# S&P 500 (US)
NSprice = SPX.Price_close
x1 = log(NSprice)
NSdate = SPX.Date
# KOSPI (Korea)
KSprice = KOSPI.Price_close
x2 = log(KSprice)
KSdate = KOSPI.Date
par_start.theta1 = 0.05 # starting values
par_start.theta2 = 0.05
par_start.theta3 = 0.05
par_start.theta4_squared = 0.05
tau = array([0.0833, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30]) # select time to maturities
# -
# ## Upload the rolling values from db_SwapCurve and compute the corresponding yields to maturity using function RollPrices2YieldToMat
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_SwapCurve'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_SwapCurve'), squeeze_me=True)
DF_Rolling = struct_to_dict(db['DF_Rolling'])
# reference yields from rolling prices
y_ref,_ = RollPrices2YieldToMat(DF_Rolling.TimeToMat, DF_Rolling.Prices)
# -
# ## Upload JPM bond prices from db_CorporateBonds and restrict the yields to available dates
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_CorporateBonds'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_CorporateBonds'), squeeze_me=True)
JPM = struct_to_dict(db['JPM'])
# ##Load the transition matrix
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_FitCreditTransitions'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_FitCreditTransitions'), squeeze_me=True)
p_EP = db['p_EP']
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_Ratings'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_Ratings'), squeeze_me=True)
db_Ratings = struct_to_dict(db['db_Ratings'])
Transitions = namedtuple('Transition', 'p ratings p_tau_step p_default')
Transitions.p = p_EP
Transitions.ratings = db_Ratings.ratings
# Inject the transition matrix
Transitions.p_tau_step = ProjectTransitionMatrix(Transitions.p, 1 / 252)
Transitions.p_default = Transitions.p_tau_step[:,-1]
# Compute threshold matrix
u_tau = r_['-1', zeros((Transitions.p_tau_step.shape[0], 1)), cumsum(Transitions.p_tau_step, 1)]
# -
# ## Compute the log-returns (invariants) of the 5 obligor's stocks
# inputs
j_ = 1000 # number of simulations
nb = round(5 * log(j_))
nu = 3 # degree of freedom
r = 0.95 # panic correlation
c = 0.07 # threshold
# Load daily observations of the stocks in S&P 500
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_StocksS_P'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_StocksS_P'), squeeze_me=True)
Data = struct_to_dict(db['Data'])
V = Data.Prices
pair = [0, 1] # stocks to spot
# Set the calm correlation matrix as sample correlation matrix of compounded returns
C = diff(log(V), 1, 1)
C = C[pair, :]
varrho2 = corrcoef(C)
# Compute panic distribution
X, p_ = PanicTDistribution(varrho2, r, c, nu, j_)
# Extract the simulations of the panic copula
x, u, U = CopMargSep(X, p_)
# -
from CONFIG import GLOBAL_DB, TEMPORARY_DB
from ARPM_utils import save_plot, struct_to_dict
from intersect_matlab import intersect
from PlotTwoDimEllipsoid import PlotTwoDimEllipsoid
from RollPrices2YieldToMat import RollPrices2YieldToMat
# -
# ## Upload the database
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_SwapCurve'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_SwapCurve'), squeeze_me=True)
DF_Rolling = struct_to_dict(db['DF_Rolling'])
# -
# ## Compute yields, select observations and compute increments
# +
tau = [1, 5, 21]
nu = array([[2],[10]]) # times to maturity of interest (years)
y = {}
_, index, *_ = intersect(DF_Rolling.TimeToMat,nu)
# yields from rolling prices
y[0],_= RollPrices2YieldToMat(DF_Rolling.TimeToMat[index], DF_Rolling.Prices[index,:]) # yield daily observations
# extract weekly and monthly observations
for k in range(len(tau)):
y[k] = y[0][:, ::tau[k]] # computing increments
from VAR1toMVOU import VAR1toMVOU
from FitVAR1 import FitVAR1
from ShiftedVGMoments import ShiftedVGMoments
from FitCIR_FP import FitCIR_FP
from InverseCallTransformation import InverseCallTransformation
# -
# ## Upload the databases and match the time series of interest to work with synchronous observations
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_Stocks'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_Stocks'), squeeze_me=True)
SPX = struct_to_dict(db['SPX'], as_namedtuple=False)
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_SwapCurve'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_SwapCurve'), squeeze_me=True)
DF_Rolling = struct_to_dict(db['DF_Rolling'], as_namedtuple=False)
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_OptionStrategy'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_OptionStrategy'),
squeeze_me=True)
OptionStrategy = struct_to_dict(db['OptionStrategy'], as_namedtuple=False)
from SortBySector import SortBySector
from HomCl import HomCl
# inputs
index = [96, 97, 128, 132, 138] # entries of interest
# -
# ## Upload database
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_StocksS_P'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_StocksS_P'), squeeze_me=True)
Data = struct_to_dict(db['Data'])
# -
# ## Compute the correlation matrix from the log-returns
# +
prices = Data.Prices
i_ = prices.shape[0]
t_ = prices.shape[1]
epsi = log(prices[:, 1:t_] / prices[:, :t_ - 1])
c2 = corrcoef(epsi) # sample correlation matrix
# -
# ## Sort the correlation matrix by sectors
# parameters
tau = 6 # projection horizon
# -
# ## Upload databases db_ImpliedVol_SPX, db_SwapCurve and db_VIX, and where the common daily observations
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_ImpliedVol_SPX'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(
os.path.join(TEMPORARY_DB, 'db_ImpliedVol_SPX'), squeeze_me=True
) # underlying values and implied volatility surface for S&P 500
db_ImpliedVol_SPX = struct_to_dict(db['db_ImpliedVol_SPX'], False)
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_SwapCurve'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(
os.path.join(TEMPORARY_DB, 'db_SwapCurve'),
squeeze_me=True) # rolling values used to computed the short rate
DF_Rolling = struct_to_dict(db['DF_Rolling'], False)
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_VIX'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_VIX'),
squeeze_me=True) # Vix index values
from RollPrices2YieldToMat import RollPrices2YieldToMat
from EffectiveScenarios import EffectiveScenarios
from ConditionalFP import ConditionalFP
from Stats import Stats
from ColorCodedFP import ColorCodedFP
# -
# ## Upload data
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_Stocks'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_Stocks'), squeeze_me=True)
SPX = struct_to_dict(db['SPX'])
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_VIX'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_VIX'), squeeze_me=True)
VIX = struct_to_dict(db['VIX'])
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_SwapCurve'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_SwapCurve'), squeeze_me=True)
DF_Rolling = struct_to_dict(db['DF_Rolling'])
# -
from CONFIG import GLOBAL_DB, TEMPORARY_DB
from ARPM_utils import save_plot, struct_to_dict, date_mtop
from FPmeancov import FPmeancov
from PlotTwoDimEllipsoid import PlotTwoDimEllipsoid
# -
# ## Upload data from db_ImpliedVol_SPX
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_ImpliedVol_SPX'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_ImpliedVol_SPX'),
squeeze_me=True) # implied volatility surface for SP500
db_ImpliedVol_SPX = struct_to_dict(db['db_ImpliedVol_SPX'])
tau = db_ImpliedVol_SPX.TimeToMaturity
delta = db_ImpliedVol_SPX.Delta # delta-moneyness
sigma_delta = db_ImpliedVol_SPX.Sigma
implied_vol = sigma_delta[0, delta == 0.5,
1:] # at the money option expiring in tau[0] years
prices = db_ImpliedVol_SPX.Underlying
logrets = diff(log(prices))
dates = db_ImpliedVol_SPX.Dates[1:]
dates = array([date_mtop(i) for i in dates])
t_ = len(dates)
lam = log(2) / 90 # exp decay probs, half life 3 months
from MMFP import MMFP
from VGpdf import VGpdf
from ParamChangeVG import ParamChangeVG
from ShiftedVGMoments import ShiftedVGMoments
from VG import VG
# -
# ## Upload databases
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_OptionStrategy'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_OptionStrategy'), squeeze_me=True)
OptionStrategy = struct_to_dict(db['OptionStrategy'])
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_VIX'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_VIX'), squeeze_me=True)
VIX = struct_to_dict(db['VIX'])
# invariants (daily P&L)
pnl = OptionStrategy.cumPL
epsi = diff(pnl)
dates_x = array([datenum(i) for i in OptionStrategy.Dates])
dates_x = dates_x[1:]
# conditioning variable (VIX)
plt.style.use('seaborn')
from CONFIG import GLOBAL_DB, TEMPORARY_DB
from ARPM_utils import save_plot, struct_to_dict
from ProjDFFT import ProjDFFT
# -
# ## Upload databases db_Uniform
# +
try:
db = loadmat(os.path.join(GLOBAL_DB, 'db_Uniform'), squeeze_me=True)
except FileNotFoundError:
db = loadmat(os.path.join(TEMPORARY_DB, 'db_Uniform'), squeeze_me=True)
UniformStrategy = struct_to_dict(db['UniformStrategy'])
# -
# ## Select the time series of cumulative P&L and set an horizon tau = 20
# +
x = UniformStrategy.cumPL
t_ = 4 #
tau = 20 # investment horizon expressed in days
k_ = 2**11 # coarseness level for projection
# -
# ## Set the parameters of the one-step uniform distribution
mu = 1 / 2 # mean
