def test_CreditHybridModel(self):
# Rates-FX
eurRates = HullWhiteModel(YieldCurve(0.015),0.03,np.array([10.0]),np.array([0.0050]))
usdRates = HullWhiteModel(YieldCurve(0.015),0.03,np.array([10.0]),np.array([0.0050]))
usdFx = AssetModel(1.25,0.15)
hybModel = HybridModel('EUR',eurRates,['USD'],[usdFx],[usdRates],np.eye(3))
# Credit
spreadLevel = 0.05
spreadCurve = YieldCurve(spreadLevel) # use 5% instantanous default probablility
mean = 0.0001 # 1bp
sigma = 0.0100 # 100bp
skew = 0.5*sigma/spreadLevel
#
spreadModel = QuasiGaussianModel(spreadCurve,1,np.array([10.0]),np.array([[sigma]]),
np.array([[skew]]),np.array([[-skew]]),np.array([0.01]),np.array([mean]),np.identity(1))
corr = np.eye(4)
corr[1,3] = -0.85 # credit-FX
corr[3,1] = -0.85
creditModel = CreditModel(hybModel,['CP'],[spreadModel],corr)
# print(creditModel.factorAliases())
#
obsTimes = np.linspace(0.0,10.0,3)
nPaths = 2
seed = 314159265359
mcSim = McSimulation(creditModel,obsTimes,nPaths,seed,True,False)
def test_FxSwap(self):
today = ql.Settings.instance().getEvaluationDate()
startDate = ql.WeekendsOnly().advance(today,ql.Period('5d'))
endDate = ql.WeekendsOnly().advance(today,ql.Period('1y'))
eurLeg = ql.Leg([
ql.SimpleCashFlow(1.0,startDate),
ql.SimpleCashFlow(-1.0,endDate)
])
usdLeg = ql.Leg([
ql.SimpleCashFlow(1.25,startDate),
ql.SimpleCashFlow(-1.25,endDate)
])
swap = Swap([eurLeg,usdLeg],[1.0,-1.0],discYtsHs=None,currencyAliases=['EUR','USD'])
obsTimes = np.array([0.0, 0.5, 1.1])
timeLine = swap.timeLine(obsTimes)
#
print('')
for t in timeLine:
print('ObsTime: %.2f' % t)
for p in timeLine[t]:
print(p)
#
# we set up a very simplistic hybrid model
eurModel = HWModel()
usdModel = HWModel()
fxModel = AssetModel(1.25,0.15)
hybModel = HybridModel('EUR',eurModel,['USD'],[fxModel],[usdModel],np.eye(3))
mcSim = McSimulation(hybModel,obsTimes,2,123,True)
V = swap.scenarios(obsTimes,mcSim)
print(V)
def setUp(self):
domAlias = 'EUR'
domModel = HWModel(0.01, 0.0050, 0.03)
forAliases = ['USD', 'GBP', 'JPY']
spotS0 = [1.0, 1.0, 1.0]
spotVol = [0.3, 0.3, 0.3]
rates = [0.01, 0.01, 0.01]
ratesVols = [0.006, 0.007, 0.008]
mean = [0.01, 0.01, 0.01]
#
forAssetModels = [
AssetModel(S0, vol) for S0, vol in zip(spotS0, spotVol)
]
forRatesModels = [
HWModel(r, v, m) for r, v, m in zip(rates, ratesVols, mean)
]
#
corr = np.identity(2 * len(forAliases) + 1)
corr[1, 2] = 0.6 # USD quanto
corr[2, 1] = 0.6
corr[3, 4] = 0.8 # GBP quanto
corr[4, 3] = 0.8
corr[5, 6] = -0.7 # JPY quanto
corr[6, 5] = -0.7
#
self.model = HybridModel(domAlias, domModel, forAliases,
forAssetModels, forRatesModels, corr)
def test_HybridModelWithDeterministicRates(self):
curve0 = YieldCurve(0.03)
dcfModel0 = DcfModel(curve0)
#
times = np.array([0.0, 1.0])
nPaths = 1
seed = 314159265359
# hybrid adjuster
hybAdjTimes = np.array([0.0, 1.0, 2.0])
# simulate deterministic model only
mcSim = McSimulation(dcfModel0,times,nPaths,seed,False)
self.assertEqual(mcSim.path(0).zeroBond(1.0,10.0,None),curve0.discount(10.0)/curve0.discount(1.0))
# simulate deterministic domestic model
hwModel = HWModel(0.01,0.0050,0.03)
asModel = AssetModel(1.0,0.30)
corr = np.identity(2)
model = HybridModel('EUR',dcfModel0,['USD'],[asModel],[hwModel],corr)
model.recalculateHybridVolAdjuster(hybAdjTimes)
mcSim = McSimulation(model,times,nPaths,seed,False)
dcfModel0.domAlias = 'EUR'
p = mcSim.path(0)
self.assertEqual(p.asset(0.0,'USD'),self.model.forAssetModels[0].X0)
self.assertEqual(p.zeroBond(0.0,5.0,'EUR'),curve0.discount(5.0))
self.assertEqual(p.zeroBond(0.0,5.0,'USD'),model.forRatesModels[0].yieldCurve.discount(5.0))
# simulate deterministic foreign model
model = HybridModel('EUR',hwModel,['USD'],[asModel],[dcfModel0],corr)
model.recalculateHybridVolAdjuster(hybAdjTimes)
mcSim = McSimulation(model,times,nPaths,seed,False)
dcfModel0.domAlias = 'USD'
p = mcSim.path(0)
self.assertEqual(p.asset(0.0,'USD'),self.model.forAssetModels[0].X0)
self.assertEqual(p.zeroBond(0.0,5.0,'EUR'),model.domRatesModel.yieldCurve.discount(5.0))
self.assertEqual(p.zeroBond(0.0,5.0,'USD'),curve0.discount(5.0))
# simulate deterministic domestic and foreign curve
curve1 = YieldCurve(0.05)
dcfModel1 = DcfModel(curve1)
corr = np.identity(1)
model = HybridModel('EUR',dcfModel0,['USD'],[asModel],[dcfModel1],corr)
model.recalculateHybridVolAdjuster(hybAdjTimes)
mcSim = McSimulation(model,times,nPaths,seed,False)
dcfModel0.domAlias = 'EUR'
dcfModel1.domAlias = 'USD'
p = mcSim.path(0)
self.assertEqual(p.asset(0.0,'USD'),self.model.forAssetModels[0].X0)
self.assertEqual(p.zeroBond(0.0,5.0,'EUR'),curve0.discount(5.0))
self.assertEqual(p.zeroBond(0.0,5.0,'USD'),curve1.discount(5.0))
def setUp(self):
### full smile/skew model
# domestic rates
domAlias = 'EUR'
eurCurve = YieldCurve(0.03)
d = 2
times = np.array([10.0])
sigma = np.array([[0.0060], [0.0040]])
slope = np.array([[0.10], [0.15]])
curve = np.array([[0.05], [0.10]])
delta = np.array([1.0, 10.0])
chi = np.array([0.01, 0.15])
Gamma = np.array([[1.0, 0.6], [0.6, 1.0]])
eurRatesModel = QuasiGaussianModel(eurCurve, d, times, sigma, slope,
curve, delta, chi, Gamma)
# assets
forAliases = ['USD', 'GBP']
spotS0 = [1.0, 2.0]
spotVol = [0.3, 0.2]
forAssetModels = [
AssetModel(S0, vol) for S0, vol in zip(spotS0, spotVol)
]
# USD rates
usdCurve = YieldCurve(0.02)
d = 3
times = np.array([10.0])
sigma = np.array([[0.0060], [0.0050], [0.0040]])
slope = np.array([[0.10], [0.20], [0.30]])
curve = np.array([[0.05], [0.10], [0.20]])
delta = np.array([1.0, 5.0, 20.0])
chi = np.array([0.01, 0.05, 0.15])
Gamma = np.array([[1.0, 0.8, 0.6], [0.8, 1.0, 0.8], [0.6, 0.8, 1.0]])
usdRatesModel = QuasiGaussianModel(usdCurve, d, times, sigma, slope,
curve, delta, chi, Gamma)
#
gbpRatesModel = HWModel()
#
# 'EUR_x_0', 'EUR_x_1', 'USD_logS', 'USD_x_0', 'USD_x_1', 'USD_x_2', 'GBP_logS', 'GBP_x'
corr = np.array([
[1.0, 0.0, 0.5, -0.5, 0.0, 0.0, -0.5, -0.5], # EUR_x_0
[0.0, 1.0, 0.0, 0.0, -0.5, 0.0, -0.5, 0.0], # EUR_x_1
[0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 0.0], # USD_logS
[-0.5, 0.0, -0.5, 1.0, 0.0, 0.0, 0.0, 0.0], # USD_x_0
[0.0, -0.5, -0.5, 0.0, 1.0, 0.0, 0.0, 0.0], # USD_x_1
[0.0, 0.0, -0.5, 0.0, 0.0, 1.0, 0.0, 0.0], # USD_x_2
[-0.5, -0.5, 0.0, 0.0, 0.0, 0.0, 1.0, 0.5], # GBP_logS
[-0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 1.0], # GBP_x
])
#
# corr = np.identity(2 + 1 + 3 + 1 + 1 ) # overwrite
#
self.model = HybridModel(domAlias, eurRatesModel, forAliases,
forAssetModels,
[usdRatesModel, gbpRatesModel], corr)
### Gaussian model
# domestic rates
domAlias = 'EUR'
eurCurve = YieldCurve(0.03)
d = 2
times = np.array([10.0])
sigma = np.array([[0.0060], [0.0040]])
slope = np.array([[0.00], [0.00]])
curve = np.array([[0.00], [0.00]])
delta = np.array([1.0, 10.0])
chi = np.array([0.01, 0.15])
Gamma = np.array([[1.0, 0.6], [0.6, 1.0]])
eurRatesModel = QuasiGaussianModel(eurCurve, d, times, sigma, slope,
curve, delta, chi, Gamma)
# assets
forAliases = ['USD', 'GBP']
spotS0 = [1.0, 2.0]
spotVol = [0.3, 0.2]
forAssetModels = [
AssetModel(S0, vol) for S0, vol in zip(spotS0, spotVol)
]
# USD rates
usdCurve = YieldCurve(0.02)
d = 3
times = np.array([10.0])
sigma = np.array([[0.0060], [0.0050], [0.0040]])
slope = np.array([[0.10], [0.20], [0.30]])
curve = np.array([[0.05], [0.10], [0.20]])
delta = np.array([1.0, 5.0, 20.0])
chi = np.array([0.01, 0.05, 0.15])
Gamma = np.array([[1.0, 0.8, 0.6], [0.8, 1.0, 0.8], [0.6, 0.8, 1.0]])
self.gaussianModel = HybridModel(domAlias, eurRatesModel, forAliases,
forAssetModels,
[usdRatesModel, gbpRatesModel], corr)
def test_HybridVolAdjusterCalculation(self):
# we set up a hybrid model consistent to QuantLib
domAlias = 'EUR'
domModel = HWModel(0.01, 0.0050, 0.01)
forAliases = ['USD', 'GBP']
forAssetModels = [AssetModel(1.0, 0.30), AssetModel(2.0, 0.15)]
forRatesModels = [
HWModel(0.02, 0.0060, 0.02),
HWModel(0.02, 0.0070, 0.03)
]
corr = np.identity(2 * len(forAliases) + 1)
# [ EUR, USD-EUR, USD, GBP-EUR, GBP ]
# 0 1 2 3 4
# USD-EUR - EUR
corr[0, 1] = 0.5
corr[1, 0] = 0.5
# USD-EUR - USD
corr[1, 2] = -0.5
corr[2, 1] = -0.5
# EUR - USD
corr[0, 2] = -0.5
corr[2, 0] = -0.5
# GBP-EUR - EUR
corr[0, 3] = -0.5
corr[3, 0] = -0.5
# GBP-EUR - GBP
corr[3, 4] = 0.5
corr[4, 3] = 0.5
# EUR - GBP
corr[0, 4] = -0.8
corr[4, 0] = -0.8
# USD - GBP
corr[2, 4] = 0.0
corr[4, 2] = 0.0
# overwrtite
# corr = np.identity(2 * len(forAliases) + 1)
# print(corr-corr.transpose())
model = HybridModel(domAlias, domModel, forAliases, forAssetModels,
forRatesModels, corr)
hybVolAdjTimes = np.linspace(0.0, 20.0, 21)
model.recalculateHybridVolAdjuster(hybVolAdjTimes)
#plt.plot(model.hybAdjTimes,model.hybVolAdj[0], 'r*')
#plt.plot(model.hybAdjTimes,model.hybVolAdj[1], 'b*')
#
#times = np.linspace(0.0,20.0,101)
#plt.plot(times,[ model.hybridVolAdjuster(0,t) for t in times ] , 'r-')
#plt.plot(times,[ model.hybridVolAdjuster(1,t) for t in times ] , 'b-')
# plt.show()
#
times = np.linspace(0.0, 10.0, 11)
nPaths = 2**13
seed = 314159265359
# risk-neutral simulation
print('')
mcSim = McSimulation(model, times, nPaths, seed, False)
#
T = 10.0
for k, alias in enumerate(model.forAliases):
# ATM forward
xT = model.forAssetModels[k].X0 * \
model.forRatesModels[k].yieldCurve.discount(T) / \
model.domRatesModel.yieldCurve.discount(T)
K = Fixed(xT)
Z = Fixed(0.0)
C = Pay(Max(Asset(T, alias) - K, Z), T)
fw, err = fwd(mcSim, C)
vol = BlackImpliedVol(fw, xT, xT, T, 1.0)
vega = BlackVega(xT, xT, vol, T)
err /= vega
volRef = model.forAssetModels[k].sigma
print('C_%s @ %4.1lfy %8.6lf vs %8.6lf (curve) - mc_err = %8.6lf' %
(alias, T, vol, volRef, err))
P = Pay(Max(K - Asset(T, alias), Z), T)
fw, err = fwd(mcSim, P)
vol = BlackImpliedVol(fw, xT, xT, T, -1.0)
vega = BlackVega(xT, xT, vol, T)
err /= vega
volRef = model.forAssetModels[k].sigma
print('P_%s @ %4.1lfy %8.6lf vs %8.6lf (curve) - mc_err = %8.6lf' %
(alias, T, vol, volRef, err))