def test_CDSIndexPortfolio():
tradeDate = FinDate(1, 8, 2007)
stepInDate = tradeDate.addDays(1)
valuationDate = stepInDate
liborCurve = buildIborCurve(tradeDate)
maturity3Y = tradeDate.nextCDSDate(36)
maturity5Y = tradeDate.nextCDSDate(60)
maturity7Y = tradeDate.nextCDSDate(84)
maturity10Y = tradeDate.nextCDSDate(120)
path = os.path.join(os.path.dirname(__file__),
'.//data//CDX_NA_IG_S7_SPREADS.csv')
f = open(path, 'r')
data = f.readlines()
f.close()
issuerCurves = []
for row in data[1:]:
splitRow = row.split(",")
spd3Y = float(splitRow[1]) / 10000.0
spd5Y = float(splitRow[2]) / 10000.0
spd7Y = float(splitRow[3]) / 10000.0
spd10Y = float(splitRow[4]) / 10000.0
recoveryRate = float(splitRow[5])
cds3Y = FinCDS(stepInDate, maturity3Y, spd3Y)
cds5Y = FinCDS(stepInDate, maturity5Y, spd5Y)
cds7Y = FinCDS(stepInDate, maturity7Y, spd7Y)
cds10Y = FinCDS(stepInDate, maturity10Y, spd10Y)
cdsContracts = [cds3Y, cds5Y, cds7Y, cds10Y]
issuerCurve = FinCDSCurve(valuationDate, cdsContracts, liborCurve,
recoveryRate)
issuerCurves.append(issuerCurve)
##########################################################################
# Now determine the average spread of the index
##########################################################################
cdsIndex = FinCDSIndexPortfolio()
averageSpd3Y = cdsIndex.averageSpread(valuationDate, stepInDate,
maturity3Y, issuerCurves) * 10000.0
averageSpd5Y = cdsIndex.averageSpread(valuationDate, stepInDate,
maturity5Y, issuerCurves) * 10000.0
averageSpd7Y = cdsIndex.averageSpread(valuationDate, stepInDate,
maturity7Y, issuerCurves) * 10000.0
averageSpd10Y = cdsIndex.averageSpread(valuationDate, stepInDate,
maturity10Y, issuerCurves) * 10000.0
testCases.header("LABEL", "VALUE")
testCases.print("AVERAGE SPD 3Y", averageSpd3Y)
testCases.print("AVERAGE SPD 5Y", averageSpd5Y)
testCases.print("AVERAGE SPD 7Y", averageSpd7Y)
testCases.print("AVERAGE SPD 10Y", averageSpd10Y)
##########################################################################
# Now determine the intrinsic spread of the index to the same maturity
# dates. As the single name CDS contracts
##########################################################################
cdsIndex = FinCDSIndexPortfolio()
intrinsicSpd3Y = cdsIndex.intrinsicSpread(
valuationDate, stepInDate, maturity3Y, issuerCurves) * 10000.0
intrinsicSpd5Y = cdsIndex.intrinsicSpread(
valuationDate, stepInDate, maturity5Y, issuerCurves) * 10000.0
intrinsicSpd7Y = cdsIndex.intrinsicSpread(
valuationDate, stepInDate, maturity7Y, issuerCurves) * 10000.0
intrinsicSpd10Y = cdsIndex.intrinsicSpread(
valuationDate, stepInDate, maturity10Y, issuerCurves) * 10000.0
##########################################################################
##########################################################################
testCases.header("LABEL", "VALUE")
testCases.print("INTRINSIC SPD 3Y", intrinsicSpd3Y)
testCases.print("INTRINSIC SPD 5Y", intrinsicSpd5Y)
testCases.print("INTRINSIC SPD 7Y", intrinsicSpd7Y)
testCases.print("INTRINSIC SPD 10Y", intrinsicSpd10Y)
def test_performCDSIndexHazardRateAdjustment():
tradeDate = FinDate(2007, 8, 1)
stepInDate = tradeDate.addDays(1)
valuationDate = stepInDate
liborCurve = buildLiborCurve(tradeDate)
maturity3Y = tradeDate.nextCDSDate(36)
maturity5Y = tradeDate.nextCDSDate(60)
maturity7Y = tradeDate.nextCDSDate(84)
maturity10Y = tradeDate.nextCDSDate(120)
path = dirname(__file__)
filename = "CDX_NA_IG_S7_SPREADS.csv"
full_filename_path = join(path, "data", filename)
f = open(full_filename_path, 'r')
data = f.readlines()
issuerCurves = []
for row in data[1:]:
splitRow = row.split(",")
spd3Y = float(splitRow[1]) / 10000.0
spd5Y = float(splitRow[2]) / 10000.0
spd7Y = float(splitRow[3]) / 10000.0
spd10Y = float(splitRow[4]) / 10000.0
recoveryRate = float(splitRow[5])
cds3Y = FinCDS(stepInDate, maturity3Y, spd3Y)
cds5Y = FinCDS(stepInDate, maturity5Y, spd5Y)
cds7Y = FinCDS(stepInDate, maturity7Y, spd7Y)
cds10Y = FinCDS(stepInDate, maturity10Y, spd10Y)
cdsContracts = [cds3Y, cds5Y, cds7Y, cds10Y]
issuerCurve = FinCDSCurve(valuationDate, cdsContracts, liborCurve,
recoveryRate)
issuerCurves.append(issuerCurve)
##########################################################################
# Now determine the average spread of the index
##########################################################################
cdsIndex = FinCDSIndexPortfolio()
averageSpd3Y = cdsIndex.averageSpread(valuationDate, stepInDate,
maturity3Y, issuerCurves) * 10000.0
averageSpd5Y = cdsIndex.averageSpread(valuationDate, stepInDate,
maturity5Y, issuerCurves) * 10000.0
averageSpd7Y = cdsIndex.averageSpread(valuationDate, stepInDate,
maturity7Y, issuerCurves) * 10000.0
averageSpd10Y = cdsIndex.averageSpread(valuationDate, stepInDate,
maturity10Y, issuerCurves) * 10000.0
testCases.header("LABEL", "VALUE")
testCases.print("AVERAGE SPD 3Y", averageSpd3Y)
testCases.print("AVERAGE SPD 5Y", averageSpd5Y)
testCases.print("AVERAGE SPD 7Y", averageSpd7Y)
testCases.print("AVERAGE SPD 10Y", averageSpd10Y)
testCases.banner(
"===================================================================")
##########################################################################
# Now determine the intrinsic spread of the index to the same maturity dates
# As the single name CDS contracts
##########################################################################
cdsIndex = FinCDSIndexPortfolio()
intrinsicSpd3Y = cdsIndex.intrinsicSpread(
valuationDate, stepInDate, maturity3Y, issuerCurves) * 10000.0
intrinsicSpd5Y = cdsIndex.intrinsicSpread(
valuationDate, stepInDate, maturity5Y, issuerCurves) * 10000.0
intrinsicSpd7Y = cdsIndex.intrinsicSpread(
valuationDate, stepInDate, maturity7Y, issuerCurves) * 10000.0
intrinsicSpd10Y = cdsIndex.intrinsicSpread(
valuationDate, stepInDate, maturity10Y, issuerCurves) * 10000.0
##########################################################################
##########################################################################
testCases.header("LABEL", "VALUE")
testCases.print("INTRINSIC SPD 3Y", intrinsicSpd3Y)
testCases.print("INTRINSIC SPD 5Y", intrinsicSpd5Y)
testCases.print("INTRINSIC SPD 7Y", intrinsicSpd7Y)
testCases.print("INTRINSIC SPD 10Y", intrinsicSpd10Y)
testCases.banner(
"===================================================================")
##########################################################################
##########################################################################
indexCoupons = [0.002, 0.0037, 0.0050, 0.0063]
indexUpfronts = [0.0, 0.0, 0.0, 0.0]
indexMaturityDates = [
FinDate(2009, 12, 20),
FinDate(2011, 12, 20),
FinDate(2013, 12, 20),
FinDate(2016, 12, 20)
]
indexRecoveryRate = 0.40
tolerance = 1e-6
import time
start = time.time()
adjustedIssuerCurves = FinCDSIndexPortfolio.hazardRateAdjustIntrinsic(
valuationDate, issuerCurves, indexCoupons, indexUpfronts,
indexMaturityDates, indexRecoveryRate, tolerance)
end = time.time()
testCases.header("TIME")
testCases.print(end - start)
# numCredits = len(issuerCurves)
# testCases.print("#","MATURITY","CDS_UNADJ","CDS_ADJ")
# for m in range(0,numCredits):
# for cds in cdsContracts:
# unadjustedSpread = cds.parSpread(valuationDate,issuerCurves[m])
# adjustedSpread = cds.parSpread(valuationDate,adjustedIssuerCurves[m])
# testCases.print(m,str(cds._maturityDate),"%10.3f"%(unadjustedSpread*10000),"%10.3f" %(adjustedSpread*10000))
cdsIndex = FinCDSIndexPortfolio()
intrinsicSpd3Y = cdsIndex.intrinsicSpread(valuationDate, stepInDate,
indexMaturityDates[0],
adjustedIssuerCurves) * 10000.0
intrinsicSpd5Y = cdsIndex.intrinsicSpread(valuationDate, stepInDate,
indexMaturityDates[1],
adjustedIssuerCurves) * 10000.0
intrinsicSpd7Y = cdsIndex.intrinsicSpread(valuationDate, stepInDate,
indexMaturityDates[2],
adjustedIssuerCurves) * 10000.0
intrinsicSpd10Y = cdsIndex.intrinsicSpread(valuationDate, stepInDate,
indexMaturityDates[3],
adjustedIssuerCurves) * 10000.0
# If the adjustment works then this should equal the index spreads
testCases.header("LABEL", "VALUE")
testCases.print("ADJUSTED INTRINSIC SPD 3Y", intrinsicSpd3Y)
testCases.print("ADJUSTED INTRINSIC SPD 5Y", intrinsicSpd5Y)
testCases.print("ADJUSTED INTRINSIC SPD 7Y", intrinsicSpd7Y)
testCases.print("ADJUSTED INTRINSIC SPD 10Y", intrinsicSpd10Y)
def test_fullPriceCDSIndexOption():
tradeDate = FinDate(1, 8, 2007)
stepInDate = tradeDate.addDays(1)
valuationDate = stepInDate
liborCurve = buildIborCurve(tradeDate)
maturity3Y = tradeDate.nextCDSDate(36)
maturity5Y = tradeDate.nextCDSDate(60)
maturity7Y = tradeDate.nextCDSDate(84)
maturity10Y = tradeDate.nextCDSDate(120)
path = os.path.join(os.path.dirname(__file__),
'.//data//CDX_NA_IG_S7_SPREADS.csv')
f = open(path, 'r')
data = f.readlines()
f.close()
issuerCurves = []
for row in data[1:]:
splitRow = row.split(",")
creditName = splitRow[0]
spd3Y = float(splitRow[1]) / 10000.0
spd5Y = float(splitRow[2]) / 10000.0
spd7Y = float(splitRow[3]) / 10000.0
spd10Y = float(splitRow[4]) / 10000.0
recoveryRate = float(splitRow[5])
cds3Y = FinCDS(stepInDate, maturity3Y, spd3Y)
cds5Y = FinCDS(stepInDate, maturity5Y, spd5Y)
cds7Y = FinCDS(stepInDate, maturity7Y, spd7Y)
cds10Y = FinCDS(stepInDate, maturity10Y, spd10Y)
cdsContracts = [cds3Y, cds5Y, cds7Y, cds10Y]
issuerCurve = FinCDSCurve(valuationDate, cdsContracts, liborCurve,
recoveryRate)
issuerCurves.append(issuerCurve)
##########################################################################
##########################################################################
indexUpfronts = [0.0, 0.0, 0.0, 0.0]
indexMaturityDates = [
FinDate(20, 12, 2009),
FinDate(20, 12, 2011),
FinDate(20, 12, 2013),
FinDate(20, 12, 2016)
]
indexRecovery = 0.40
testCases.banner(
"======================= CDS INDEX OPTION ==========================")
indexCoupon = 0.004
volatility = 0.50
expiryDate = FinDate(1, 2, 2008)
maturityDate = FinDate(20, 12, 2011)
notional = 10000.0
tolerance = 1e-6
testCases.header("TIME", "STRIKE", "INDEX", "PAY", "RECEIVER", "G(K)", "X",
"EXPH", "ABPAY", "ABREC")
for index in np.linspace(20, 60, 10):
#######################################################################
cdsContracts = []
for dt in indexMaturityDates:
cds = FinCDS(valuationDate, dt, index / 10000.0)
cdsContracts.append(cds)
indexCurve = FinCDSCurve(valuationDate, cdsContracts, liborCurve,
indexRecovery)
if 1 == 1:
indexSpreads = [index / 10000.0] * 4
indexPortfolio = FinCDSIndexPortfolio()
adjustedIssuerCurves = indexPortfolio.hazardRateAdjustIntrinsic(
valuationDate, issuerCurves, indexSpreads, indexUpfronts,
indexMaturityDates, indexRecovery, tolerance)
else:
indexSpread = index / 10000.0
issuerCurve = buildFlatIssuerCurve(tradeDate, liborCurve,
indexSpread, indexRecovery)
adjustedIssuerCurves = []
for iCredit in range(0, 125):
adjustedIssuerCurves.append(issuerCurve)
#######################################################################
for strike in np.linspace(20, 60, 20):
start = time.time()
option = FinCDSIndexOption(expiryDate, maturityDate, indexCoupon,
strike / 10000.0, notional)
v_pay_1, v_rec_1, strikeValue, mu, expH = option.valueAnderson(
valuationDate, adjustedIssuerCurves, indexRecovery, volatility)
end = time.time()
elapsed = end - start
end = time.time()
v_pay_2, v_rec_2 = option.valueAdjustedBlack(
valuationDate, indexCurve, indexRecovery, liborCurve,
volatility)
elapsed = end - start
testCases.print(elapsed, strike, index, v_pay_1, v_rec_1,
strikeValue, mu, expH, v_pay_2, v_rec_2)
def test_FinCDSBasket():
tradeDate = FinDate(2007, 3, 1)
stepInDate = tradeDate.addDays(1)
valuationDate = tradeDate.addDays(1)
liborCurve = buildLiborCurve(tradeDate)
basketMaturity = FinDate(2011, 12, 20)
cdsIndex = FinCDSIndexPortfolio()
##########################################################################
testCases.banner(
"===================================================================")
testCases.banner(
"====================== INHOMOGENEOUS CURVE =========================="
)
testCases.banner(
"===================================================================")
numCredits = 5
spd3Y = 0.0012
spd5Y = 0.0025
spd7Y = 0.0034
spd10Y = 0.0046
testCases.header("LABELS", "VALUE")
if 1 == 0:
issuerCurves = loadHomogeneousSpreadCurves(valuationDate, liborCurve,
spd3Y, spd5Y, spd7Y, spd10Y,
numCredits)
else:
issuerCurves = loadHeterogeneousSpreadCurves(valuationDate, liborCurve)
issuerCurves = issuerCurves[0:numCredits]
intrinsicSpd = cdsIndex.intrinsicSpread(
valuationDate, stepInDate, basketMaturity, issuerCurves) * 10000.0
testCases.print("INTRINSIC SPD BASKET MATURITY", intrinsicSpd)
totalSpd = cdsIndex.totalSpread(valuationDate, stepInDate, basketMaturity,
issuerCurves) * 10000.0
testCases.print("SUMMED UP SPD BASKET MATURITY", totalSpd)
minSpd = cdsIndex.minSpread(valuationDate, stepInDate, basketMaturity,
issuerCurves) * 10000.0
testCases.print("MINIMUM SPD BASKET MATURITY", minSpd)
maxSpd = cdsIndex.maxSpread(valuationDate, stepInDate, basketMaturity,
issuerCurves) * 10000.0
testCases.print("MAXIMUM SPD BASKET MATURITY", maxSpd)
seed = 1967
basket = FinCDSBasket(valuationDate, basketMaturity)
testCases.banner(
"===================================================================")
testCases.banner(
"======================= GAUSSIAN COPULA ===========================")
testCases.banner(
"===================================================================")
testCases.header("TIME", "Trials", "RHO", "NTD", "SPRD", "SPRD_HOMO")
for ntd in range(1, numCredits + 1):
for beta in [0.0, 0.5]:
rho = beta * beta
betaVector = np.ones(numCredits) * beta
corrMatrix = corrMatrixGenerator(rho, numCredits)
for numTrials in [1000]: # [1000,5000,10000,20000,50000,100000]:
start = time.time()
v1 = basket.valueGaussian_MC(valuationDate, ntd, issuerCurves,
corrMatrix, liborCurve, numTrials,
seed)
v2 = basket.value1FGaussian_Homo(valuationDate, ntd,
issuerCurves, betaVector,
liborCurve)
end = time.time()
period = (end - start)
testCases.print(period, numTrials, rho, ntd, v1[2] * 10000,
v2[3] * 10000)
testCases.banner(
"===================================================================")
testCases.banner(
"==================== STUDENT'S-T CONVERGENCE ======================")
testCases.banner(
"===================================================================")
testCases.header("TIME", "TRIALS", "RHO", "DOF", "NTD", "SPRD")
for beta in [0.0, 0.5]:
rho = beta**2
corrMatrix = corrMatrixGenerator(rho, numCredits)
for ntd in range(1, numCredits + 1):
for doF in [3, 10]:
start = time.time()
v = basket.valueStudentT_MC(valuationDate, ntd, issuerCurves,
corrMatrix, doF, liborCurve,
numTrials, seed)
end = time.time()
period = (end - start)
testCases.print(period, numTrials, rho, doF, ntd, v[2] * 10000)
start = time.time()
v = basket.valueGaussian_MC(valuationDate, ntd, issuerCurves,
corrMatrix, liborCurve, numTrials,
seed)
end = time.time()
period = (end - start)
testCases.print(period, numTrials, rho, "GC", ntd, v[2] * 10000)
testCases.banner(
"===================================================================")
testCases.banner(
"=================== STUDENT'S T WITH DOF = 5 ======================")
testCases.banner(
"===================================================================")
doF = 5
testCases.header("TIME", "NUMTRIALS", "RHO", "NTD", "SPD")
for beta in [0.0, 0.5]:
rho = beta**2
corrMatrix = corrMatrixGenerator(rho, numCredits)
for ntd in range(1, numCredits + 1):
for numTrials in [1000]:
start = time.time()
v = basket.valueStudentT_MC(valuationDate, ntd, issuerCurves,
corrMatrix, doF, liborCurve,
numTrials, seed)
end = time.time()
period = (end - start)
testCases.print(period, numTrials, rho, ntd, v[2] * 10000)
def test_FinCDSTranche():
tradeDate = FinDate(2007, 3, 1)
stepInDate = tradeDate.addDays(1)
valuationDate = tradeDate.addDays(1)
testCases.header("DATE")
testCases.print(str((tradeDate)))
testCases.print(str((stepInDate)))
testCases.print(str((valuationDate)))
liborCurve = buildIborCurve(tradeDate)
trancheMaturity = FinDate(2011, 12, 20)
tranche1 = FinCDSTranche(valuationDate, trancheMaturity, 0.00, 0.03)
tranche2 = FinCDSTranche(valuationDate, trancheMaturity, 0.03, 0.06)
tranche3 = FinCDSTranche(valuationDate, trancheMaturity, 0.06, 0.09)
tranche4 = FinCDSTranche(valuationDate, trancheMaturity, 0.09, 0.12)
tranche5 = FinCDSTranche(valuationDate, trancheMaturity, 0.12, 0.22)
tranche6 = FinCDSTranche(valuationDate, trancheMaturity, 0.22, 0.60)
tranche7 = FinCDSTranche(valuationDate, trancheMaturity, 0.00, 0.60)
tranches = [
tranche1, tranche2, tranche3, tranche4, tranche5, tranche6, tranche7
]
corr1 = 0.30
corr2 = 0.35
upfront = 0.0
spd = 0.0
cdsIndex = FinCDSIndexPortfolio()
##########################################################################
testCases.banner(
"===================================================================")
testCases.banner(
"====================== HOMOGENEOUS CURVE ==========================")
testCases.banner(
"===================================================================")
numCredits = 125
spd3Y = 0.0012
spd5Y = 0.0025
spd7Y = 0.0034
spd10Y = 0.0046
issuerCurves = loadHomogeneousCDSCurves(valuationDate, liborCurve, spd3Y,
spd5Y, spd7Y, spd10Y, numCredits)
intrinsicSpd = cdsIndex.intrinsicSpread(
valuationDate, stepInDate, trancheMaturity, issuerCurves) * 10000.0
testCases.header("LABEL", "VALUE")
testCases.print("INTRINSIC SPD TRANCHE MATURITY", intrinsicSpd)
adjustedSpd = intrinsicSpd / 0.6
testCases.print("ADJUSTED SPD TRANCHE MATURITY", adjustedSpd)
testCases.header("METHOD", "TIME", "NumPoints", "K1", "K2", "Sprd")
for method in FinLossDistributionBuilder:
for tranche in tranches:
for numPoints in [40]:
start = time.time()
v = tranche.valueBC(valuationDate, issuerCurves, upfront, spd,
corr1, corr2, numPoints, method)
end = time.time()
period = (end - start)
testCases.print(method, period, numPoints, tranche._k1,
tranche._k2, v[3] * 10000)
##########################################################################
testCases.banner(
"===================================================================")
testCases.banner(
"=================== HETEROGENEOUS CURVES ==========================")
testCases.banner(
"===================================================================")
issuerCurves = loadHeterogeneousSpreadCurves(valuationDate, liborCurve)
intrinsicSpd = cdsIndex.intrinsicSpread(
valuationDate, stepInDate, trancheMaturity, issuerCurves) * 10000.0
testCases.header("LABEL", "VALUE")
testCases.print("INTRINSIC SPD TRANCHE MATURITY", intrinsicSpd)
adjustedSpd = intrinsicSpd / 0.6
testCases.print("ADJUSTED SPD TRANCHE MATURITY", adjustedSpd)
testCases.header("METHOD", "TIME", "NumPoints", "K1", "K2", "Sprd")
for method in FinLossDistributionBuilder:
for tranche in tranches:
for numPoints in [40]:
start = time.time()
v = tranche.valueBC(valuationDate, issuerCurves, upfront, spd,
corr1, corr2, numPoints, method)
end = time.time()
period = (end - start)
testCases.print(method, period, numPoints, tranche._k1,
tranche._k2, v[3] * 10000)
testCases.banner(
"===================================================================")
def test_CDSIndexAdjustSpreads():
tradeDate = FinDate(1, 8, 2007)
stepInDate = tradeDate.addDays(1)
valuationDate = tradeDate
liborCurve = buildIborCurve(tradeDate)
maturity3Y = tradeDate.nextCDSDate(36)
maturity5Y = tradeDate.nextCDSDate(60)
maturity7Y = tradeDate.nextCDSDate(84)
maturity10Y = tradeDate.nextCDSDate(120)
path = dirname(__file__)
filename = "CDX_NA_IG_S7_SPREADS.csv"
full_filename_path = join(path, "data", filename)
f = open(full_filename_path, 'r')
data = f.readlines()
issuerCurves = []
for row in data[1:]:
splitRow = row.split(",")
spd3Y = float(splitRow[1]) / 10000.0
spd5Y = float(splitRow[2]) / 10000.0
spd7Y = float(splitRow[3]) / 10000.0
spd10Y = float(splitRow[4]) / 10000.0
recoveryRate = float(splitRow[5])
cds3Y = FinCDS(stepInDate, maturity3Y, spd3Y)
cds5Y = FinCDS(stepInDate, maturity5Y, spd5Y)
cds7Y = FinCDS(stepInDate, maturity7Y, spd7Y)
cds10Y = FinCDS(stepInDate, maturity10Y, spd10Y)
cdsContracts = [cds3Y, cds5Y, cds7Y, cds10Y]
issuerCurve = FinCDSCurve(valuationDate,
cdsContracts,
liborCurve,
recoveryRate)
issuerCurves.append(issuerCurve)
##########################################################################
# Now determine the average spread of the index
##########################################################################
cdsIndex = FinCDSIndexPortfolio()
averageSpd3Y = cdsIndex.averageSpread(valuationDate,
stepInDate,
maturity3Y,
issuerCurves) * 10000.0
averageSpd5Y = cdsIndex.averageSpread(valuationDate,
stepInDate,
maturity5Y,
issuerCurves) * 10000.0
averageSpd7Y = cdsIndex.averageSpread(valuationDate,
stepInDate,
maturity7Y,
issuerCurves) * 10000.0
averageSpd10Y = cdsIndex.averageSpread(valuationDate,
stepInDate,
maturity10Y,
issuerCurves) * 10000.0
testCases.header("LABEL", "VALUE")
testCases.print("AVERAGE SPD 3Y", averageSpd3Y)
testCases.print("AVERAGE SPD 5Y", averageSpd5Y)
testCases.print("AVERAGE SPD 7Y", averageSpd7Y)
testCases.print("AVERAGE SPD 10Y", averageSpd10Y)
##########################################################################
# Now determine the intrinsic spread of the index to the same maturity dates
# As the single name CDS contracts
##########################################################################
cdsIndex = FinCDSIndexPortfolio()
intrinsicSpd3Y = cdsIndex.intrinsicSpread(valuationDate,
stepInDate,
maturity3Y,
issuerCurves) * 10000.0
intrinsicSpd5Y = cdsIndex.intrinsicSpread(valuationDate,
stepInDate,
maturity5Y,
issuerCurves) * 10000.0
intrinsicSpd7Y = cdsIndex.intrinsicSpread(valuationDate,
stepInDate,
maturity7Y,
issuerCurves) * 10000.0
intrinsicSpd10Y = cdsIndex.intrinsicSpread(valuationDate,
stepInDate,
maturity10Y,
issuerCurves) * 10000.0
##########################################################################
##########################################################################
testCases.header("LABEL", "VALUE")
testCases.print("INTRINSIC SPD 3Y", intrinsicSpd3Y)
testCases.print("INTRINSIC SPD 5Y", intrinsicSpd5Y)
testCases.print("INTRINSIC SPD 7Y", intrinsicSpd7Y)
testCases.print("INTRINSIC SPD 10Y", intrinsicSpd10Y)
##########################################################################
##########################################################################
indexCoupons = [0.002, 0.0037, 0.0050, 0.0063]
indexUpfronts = [0.0, 0.0, 0.0, 0.0]
indexMaturityDates = [FinDate(20, 12, 2009),
FinDate(20, 12, 2011),
FinDate(20, 12, 2013),
FinDate(20, 12, 2016)]
indexRecoveryRate = 0.40
tolerance = 1e-7
import time
start = time.time()
indexPortfolio = FinCDSIndexPortfolio()
adjustedIssuerCurves = indexPortfolio.spreadAdjustIntrinsic(
valuationDate,
issuerCurves,
indexCoupons,
indexUpfronts,
indexMaturityDates,
indexRecoveryRate,
tolerance)
end = time.time()
testCases.header("TIME")
testCases.print(end - start)
cdsIndex = FinCDSIndexPortfolio()
intrinsicSpd3Y = cdsIndex.intrinsicSpread(valuationDate,
stepInDate,
indexMaturityDates[0],
adjustedIssuerCurves) * 10000.0
intrinsicSpd5Y = cdsIndex.intrinsicSpread(valuationDate,
stepInDate,
indexMaturityDates[1],
adjustedIssuerCurves) * 10000.0
intrinsicSpd7Y = cdsIndex.intrinsicSpread(valuationDate,
stepInDate,
indexMaturityDates[2],
adjustedIssuerCurves) * 10000.0
intrinsicSpd10Y = cdsIndex.intrinsicSpread(valuationDate,
stepInDate,
indexMaturityDates[3],
adjustedIssuerCurves) * 10000.0
# If the adjustment works then this should equal the index spreads
testCases.header("LABEL", "VALUE")
testCases.print("ADJUSTED INTRINSIC SPD 3Y:", intrinsicSpd3Y)
testCases.print("ADJUSTED INTRINSIC SPD 5Y:", intrinsicSpd5Y)
testCases.print("ADJUSTED INTRINSIC SPD 7Y", intrinsicSpd7Y)
testCases.print("ADJUSTED INTRINSIC SPD 10Y", intrinsicSpd10Y)
