def test_FinCalendar():
setDateFormatType(FinDateFormatTypes.US_LONGEST)
endDate = FinDate(31, 12, 2030)
for calendarType in FinCalendarTypes:
testCases.banner("================================")
testCases.banner("================================")
testCases.header("CALENDAR", "HOLIDAY")
testCases.print("STARTING", calendarType)
cal = FinCalendar(calendarType)
nextDate = FinDate(31, 12, 2020)
while nextDate < endDate:
nextDate = nextDate.addDays(1)
if nextDate._d == 1 and nextDate._m == 1:
testCases.banner("================================")
# print("=========================")
isHolidayDay = cal.isHoliday(nextDate)
if isHolidayDay is True:
testCases.print(cal, nextDate)
def test_CDSDateGeneration():
# This is the 10 year contract at an off market coupon
maturityDate = FinDate(20, 6, 2029)
cdsCoupon = 0.0100
tradeDate = FinDate(2019, 8, 9)
valuationDate = tradeDate.addDays(1)
cdsContract = FinCDS(valuationDate,
maturityDate,
cdsCoupon,
ONE_MILLION,
True,
FinFrequencyTypes.QUARTERLY,
FinDayCountTypes.ACT_360,
FinCalendarTypes.WEEKEND,
FinBusDayAdjustTypes.FOLLOWING,
FinDateGenRuleTypes.BACKWARD)
testCases.header("Flow Date", "AccrualFactor", "Flow")
numFlows = len(cdsContract._adjustedDates)
for n in range(0, numFlows):
testCases.print(str(
cdsContract._adjustedDates[n]), cdsContract._accrualFactors[n],
cdsContract._flows[n])
def test_fullPriceCDSConvergence():
_, issuerCurve = buildFullIssuerCurve1(0.0, 0.0)
# This is the 10 year contract at an off market coupon
maturityDate = FinDate(2029, 6, 20)
cdsCoupon = 0.0150
notional = ONE_MILLION
longProtection = False
tradeDate = FinDate(2019, 8, 9)
valuationDate = tradeDate.addDays(1)
cdsContract = FinCDS(valuationDate,
maturityDate,
cdsCoupon,
notional,
longProtection)
cdsRecovery = 0.40
testCases.header("NumSteps", "Value")
for n in [10, 50, 100, 500, 1000]:
v_full = cdsContract.value(
valuationDate, issuerCurve, cdsRecovery, 0, 1, n)['full_pv']
testCases.print(n, v_full)
def test_fullPriceCDS():
liborCurve, issuerCurve = buildFullIssuerCurve(0.0, 0.0)
# This is the 10 year contract at an off market coupon
maturityDate = FinDate(2029, 6, 20)
cdsCoupon = 0.0150
notional = ONE_MILLION
longProtection = False
tradeDate = FinDate(2019, 8, 9)
valuationDate = tradeDate.addDays(1)
effectiveDate = valuationDate
cdsContract = FinCDS(effectiveDate, maturityDate, cdsCoupon, notional,
longProtection)
cdsRecovery = 0.40
print("LABEL", "VALUE")
spd = cdsContract.parSpread(valuationDate, issuerCurve,
cdsRecovery) * 10000.0
print("PAR_SPREAD", spd)
v = cdsContract.value(valuationDate, issuerCurve, cdsRecovery)
print("FULL_VALUE", v[0])
print("CLEAN_VALUE", v[1])
p = cdsContract.cleanPrice(valuationDate, issuerCurve, cdsRecovery)
print("CLEAN_PRICE", p)
accruedDays = cdsContract.accruedDays()
print("ACCRUED_DAYS", accruedDays)
accruedInterest = cdsContract.accruedInterest()
print("ACCRUED_COUPON", accruedInterest)
protPV = cdsContract.protectionLegPV(valuationDate, issuerCurve,
cdsRecovery)
print("PROTECTION_PV", protPV)
premPV = cdsContract.premiumLegPV(valuationDate, issuerCurve, cdsRecovery)
print("PREMIUM_PV", premPV)
fullRPV01, cleanRPV01 = cdsContract.riskyPV01(valuationDate, issuerCurve)
print("FULL_RPV01", fullRPV01)
print("CLEAN_RPV01", cleanRPV01)
bump = 1.0 / 10000.0 # 1 bp
liborCurve, issuerCurve = buildFullIssuerCurve(bump, 0)
v_bump = cdsContract.value(valuationDate, issuerCurve, cdsRecovery)
dv = v_bump[0] - v[0]
print("CREDIT_DV01", dv)
# Interest Rate Bump
liborCurve, issuerCurve = buildFullIssuerCurve(0, bump)
v_bump = cdsContract.value(valuationDate, issuerCurve, cdsRecovery)
dv = v_bump[0] - v[0]
print("INTEREST_DV01", dv)
def test_valueCDSIndex():
# We treat an index as a CDS contract with a flat CDS curve
tradeDate = FinDate(2006, 2, 7)
liborCurve = buildIborCurve(tradeDate)
issuerCurve = buildIssuerCurve(tradeDate, liborCurve)
stepInDate = tradeDate.addDays(1)
valuationDate = stepInDate
maturityDate = FinDate(2010, 6, 20)
cdsRecovery = 0.40
notional = 10.0 * ONE_MILLION
longProtection = True
indexCoupon = 0.004
cdsIndexContract = FinCDS(stepInDate,
maturityDate,
indexCoupon,
notional,
longProtection)
# cdsIndexContract.print(valuationDate)
testCases.header("LABEL", "VALUE")
spd = cdsIndexContract.parSpread(
valuationDate, issuerCurve, cdsRecovery) * 10000.0
testCases.print("PAR SPREAD", spd)
v = cdsIndexContract.value(valuationDate, issuerCurve, cdsRecovery)
testCases.print("FULL VALUE", v['full_pv'])
testCases.print("CLEAN VALUE", v['clean_pv'])
p = cdsIndexContract.cleanPrice(valuationDate, issuerCurve, cdsRecovery)
testCases.print("CLEAN PRICE", p)
accruedDays = cdsIndexContract.accruedDays()
testCases.print("ACCRUED DAYS", accruedDays)
accruedInterest = cdsIndexContract.accruedInterest()
testCases.print("ACCRUED COUPON", accruedInterest)
protPV = cdsIndexContract.protectionLegPV(
valuationDate, issuerCurve, cdsRecovery)
testCases.print("PROTECTION LEG PV", protPV)
premPV = cdsIndexContract.premiumLegPV(
valuationDate, issuerCurve, cdsRecovery)
testCases.print("PREMIUM LEG PV", premPV)
fullRPV01, cleanRPV01 = cdsIndexContract.riskyPV01(
valuationDate, issuerCurve)
testCases.print("FULL RPV01", fullRPV01)
testCases.print("CLEAN RPV01", cleanRPV01)
def test_LiborSwap():
# I have tried to reproduce the example from the blog by Ioannis Rigopoulos
# https://blog.deriscope.com/index.php/en/excel-interest-rate-swap-price-dual-bootstrapping-curve
startDate = FinDate(2017, 12, 27)
endDate = FinDate(2067, 12, 27)
fixedCoupon = 0.015
fixedFreqType = FinFrequencyTypes.ANNUAL
fixedDayCountType = FinDayCountTypes.THIRTY_E_360
floatSpread = 0.0
floatFreqType = FinFrequencyTypes.SEMI_ANNUAL
floatDayCountType = FinDayCountTypes.ACT_360
firstFixing = -0.00268
swapCalendarType = FinCalendarTypes.WEEKEND
busDayAdjustType = FinBusDayAdjustTypes.FOLLOWING
dateGenRuleType = FinDateGenRuleTypes.BACKWARD
swapType = FinLiborSwapTypes.RECEIVER
notional = 10.0 * ONE_MILLION
swap = FinLiborSwap(startDate,
endDate,
swapType,
fixedCoupon,
fixedFreqType,
fixedDayCountType,
notional,
floatSpread,
floatFreqType,
floatDayCountType,
swapCalendarType,
busDayAdjustType,
dateGenRuleType)
''' Now perform a valuation after the swap has seasoned but with the
same curve being used for discounting and working out the implied
future Libor rates. '''
valuationDate = FinDate(30, 11, 2018)
settlementDate = valuationDate.addDays(2)
liborCurve = buildLiborCurve(valuationDate)
v = swap.value(settlementDate, liborCurve, liborCurve, firstFixing)
v_bbg = 388147.0
testCases.header("LABEL", "VALUE")
testCases.print("SWAP_VALUE USING ONE_CURVE", v)
testCases.print("BLOOMBERG VALUE", v_bbg)
testCases.print("DIFFERENCE VALUE", v_bbg - v)
def test_FinDateRange():
startDate = FinDate(1, 1, 2010)
testCases.header("Tenor", "Dates")
endDate = startDate.addDays(3)
tenor = "Default"
testCases.print(tenor, dateRange(startDate, endDate))
endDate = startDate.addDays(20)
tenor = "1W"
testCases.print(tenor, dateRange(startDate, endDate, tenor))
tenor = "7D"
testCases.print(tenor, dateRange(startDate, endDate, tenor))
testCases.header("Case", "Dates")
case = "Same startDate"
testCases.print(case, dateRange(startDate, startDate))
case = "startDate before endDate"
testCases.print(case, dateRange(endDate, startDate))
def test_FinDate():
startDate = FinDate(1, 1, 2018)
testCases.header("DATE", "MONTHS", "CDS DATE")
for numMonths in range(0, 120):
nextCDSDate = startDate.nextCDSDate(numMonths)
testCases.print(str(startDate), numMonths, str(nextCDSDate))
startDate = FinDate(1, 1, 2018)
testCases.header("STARTDATE", "MONTHS", "CDS DATE")
for numMonths in range(0, 365):
startDate = startDate.addDays(1)
nextIMMDate = startDate.nextIMMDate()
testCases.print(numMonths, str(startDate), str(nextIMMDate))
def test_FinBondExDividend():
issueDate = FinDate(7, 9, 2000)
maturityDate = FinDate(7, 9, 2020)
coupon = 0.05
freqType = FinFrequencyTypes.SEMI_ANNUAL
accrualType = FinDayCountTypes.ACT_ACT_ICMA
face = 100.0
exDivDays = 7
testCases.header("LABEL", "VALUE")
calendarType = FinCalendarTypes.UNITED_KINGDOM
bond = FinBond(issueDate, maturityDate, coupon, freqType, accrualType,
face)
settlementDate = FinDate(7, 9, 2003)
accrued = bond.calcAccruedInterest(settlementDate, exDivDays, calendarType)
testCases.print("SettlementDate:", settlementDate)
testCases.print("Accrued:", accrued)
###########################################################################
testCases.banner("=======================================================")
testCases.header("SETTLEMENT", "ACCRUED")
issueDate = FinDate(7, 9, 2000)
maturityDate = FinDate(7, 9, 2020)
coupon = 0.05
freqType = FinFrequencyTypes.SEMI_ANNUAL
accrualType = FinDayCountTypes.ACT_ACT_ICMA
face = 100.0
exDivDays = 7
calendarType = FinCalendarTypes.UNITED_KINGDOM
bond = FinBond(issueDate, maturityDate, coupon, freqType, accrualType,
face)
settlementDate = FinDate(25, 8, 2010)
for _ in range(0, 13):
settlementDate = settlementDate.addDays(1)
accrued = bond.calcAccruedInterest(settlementDate, exDivDays,
calendarType)
testCases.print(settlementDate, accrued)
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)
from financepy.finutils.FinDate import FinDate
# We can creat a FinDate as follows
dt1 = FinDate(2019, 10, 10)
# To see what this is, print it
print("PRINT DATES")
print(dt1)
# To add two days we can do
print("ADD CALENDAR DAYS")
dt2 = dt1.addDays(2)
print(dt2)
# dt has not changed, we just created a new date
# To add business days we do the following - note this does not know
# about regional or religious holidays - just weekends
print("ADD WORKDAYS")
print(dt1, dt1.addWorkDays(2))
# The weekend has now been skipped
# To add a month do
print("ADD MONTHS")
print(dt1, dt1.addMonths(2))
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_fullPriceCDSwaption():
# This reproduces example on page 38 of Open Gamma note on CDS Option
tradeDate = FinDate(2014, 2, 5)
_, issuerCurve = buildFullIssuerCurve(tradeDate)
stepInDate = tradeDate.addDays(1)
valuationDate = stepInDate
expiryDate = FinDate(2014, 3, 20)
maturityDate = FinDate(2019, 6, 20)
cdsRecovery = 0.40
notional = 100.0
longProtection = False
cdsCoupon = 0.0 # NOT KNOWN
cdsContract = FinCDS(stepInDate,
maturityDate,
cdsCoupon,
notional,
longProtection)
testCases.banner(
"=============================== CDS ===============================")
# cdsContract.print(valuationDate)
testCases.header("LABEL", "VALUE")
spd = cdsContract.parSpread(
valuationDate,
issuerCurve,
cdsRecovery) * 10000.0
testCases.print("PAR SPREAD:", spd)
v = cdsContract.value(valuationDate, issuerCurve, cdsRecovery)
testCases.print("FULL VALUE", v['full_pv'])
testCases.print("CLEAN VALUE", v['clean_pv'])
p = cdsContract.cleanPrice(valuationDate, issuerCurve, cdsRecovery)
testCases.print("CLEAN PRICE", p)
accruedDays = cdsContract.accruedDays()
testCases.print("ACCRUED DAYS", accruedDays)
accruedInterest = cdsContract.accruedInterest()
testCases.print("ACCRUED COUPON", accruedInterest)
protPV = cdsContract.protectionLegPV(
valuationDate, issuerCurve, cdsRecovery)
testCases.print("PROTECTION LEG PV", protPV)
premPV = cdsContract.premiumLegPV(valuationDate, issuerCurve, cdsRecovery)
testCases.print("PREMIUM LEG PV", premPV)
fullRPV01, cleanRPV01 = cdsContract.riskyPV01(valuationDate, issuerCurve)
testCases.print("FULL RPV01", fullRPV01)
testCases.print("CLEAN RPV01", cleanRPV01)
# cdsContract.printFlows(issuerCurve)
testCases.banner(
"=========================== FORWARD CDS ===========================")
cdsContract = FinCDS(expiryDate,
maturityDate,
cdsCoupon,
notional,
longProtection)
# cdsContract.print(valuationDate)
spd = cdsContract.parSpread(
valuationDate,
issuerCurve,
cdsRecovery) * 10000.0
testCases.print("PAR SPREAD", spd)
v = cdsContract.value(valuationDate, issuerCurve, cdsRecovery)
testCases.print("FULL VALUE", v['full_pv'])
testCases.print("CLEAN VALUE", v['clean_pv'])
protPV = cdsContract.protectionLegPV(
valuationDate, issuerCurve, cdsRecovery)
testCases.print("PROTECTION LEG PV", protPV)
premPV = cdsContract.premiumLegPV(valuationDate, issuerCurve, cdsRecovery)
testCases.print("PREMIUM LEG PV", premPV)
fullRPV01, cleanRPV01 = cdsContract.riskyPV01(valuationDate, issuerCurve)
testCases.print("FULL RPV01", fullRPV01)
testCases.print("CLEAN RPV01", cleanRPV01)
# cdsContract.printFlows(issuerCurve)
testCases.banner(
"========================== CDS OPTIONS ============================")
cdsCoupon = 0.01
volatility = 0.3
testCases.print("Expiry Date:", str(expiryDate))
testCases.print("Maturity Date:", str(maturityDate))
testCases.print("CDS Coupon:", cdsCoupon)
testCases.header("STRIKE", "FULL VALUE", "IMPLIED VOL")
for strike in np.linspace(100, 300, 41):
cdsOption = FinCDSOption(expiryDate,
maturityDate,
strike / 10000.0,
notional)
v = cdsOption.value(valuationDate,
issuerCurve,
volatility)
vol = cdsOption.impliedVolatility(valuationDate,
issuerCurve,
v)
testCases.print(strike, v, vol)
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 buildFullIssuerCurve(mktSpreadBump, irBump):
# https://www.markit.com/markit.jsp?jsppage=pv.jsp
# YIELD CURVE 8-AUG-2019 SNAP AT 1600
tradeDate = FinDate(2019, 8, 9)
valuationDate = tradeDate.addDays(1)
dcType = FinDayCountTypes.ACT_360
depos = []
m = 1.0 # 0.00000000000
spotDays = 2
settlementDate = valuationDate.addDays(spotDays)
maturityDate = settlementDate.addMonths(1)
depo1 = FinLiborDeposit(settlementDate, maturityDate, m * 0.022009, dcType)
maturityDate = settlementDate.addMonths(2)
depo2 = FinLiborDeposit(settlementDate, maturityDate, m * 0.022138, dcType)
maturityDate = settlementDate.addMonths(3)
depo3 = FinLiborDeposit(settlementDate, maturityDate, m * 0.021810, dcType)
maturityDate = settlementDate.addMonths(6)
depo4 = FinLiborDeposit(settlementDate, maturityDate, m * 0.020503, dcType)
maturityDate = settlementDate.addMonths(12)
depo5 = FinLiborDeposit(settlementDate, maturityDate, m * 0.019930, dcType)
depos.append(depo1)
depos.append(depo2)
depos.append(depo3)
depos.append(depo4)
depos.append(depo5)
fras = []
swaps = []
dcType = FinDayCountTypes.THIRTY_E_360_ISDA
fixedFreq = FinFrequencyTypes.SEMI_ANNUAL
maturityDate = settlementDate.addMonths(24)
swap1 = FinLiborSwap(settlementDate, maturityDate, m * 0.015910 + irBump,
fixedFreq, dcType)
swaps.append(swap1)
maturityDate = settlementDate.addMonths(36)
swap2 = FinLiborSwap(settlementDate, maturityDate, m * 0.014990 + irBump,
fixedFreq, dcType)
swaps.append(swap2)
maturityDate = settlementDate.addMonths(48)
swap3 = FinLiborSwap(settlementDate, maturityDate, m * 0.014725 + irBump,
fixedFreq, dcType)
swaps.append(swap3)
maturityDate = settlementDate.addMonths(60)
swap4 = FinLiborSwap(settlementDate, maturityDate, m * 0.014640 + irBump,
fixedFreq, dcType)
swaps.append(swap4)
maturityDate = settlementDate.addMonths(72)
swap5 = FinLiborSwap(settlementDate, maturityDate, m * 0.014800 + irBump,
fixedFreq, dcType)
swaps.append(swap5)
maturityDate = settlementDate.addMonths(84)
swap6 = FinLiborSwap(settlementDate, maturityDate, m * 0.014995 + irBump,
fixedFreq, dcType)
swaps.append(swap6)
maturityDate = settlementDate.addMonths(96)
swap7 = FinLiborSwap(settlementDate, maturityDate, m * 0.015180 + irBump,
fixedFreq, dcType)
swaps.append(swap7)
maturityDate = settlementDate.addMonths(108)
swap8 = FinLiborSwap(settlementDate, maturityDate, m * 0.015610 + irBump,
fixedFreq, dcType)
swaps.append(swap8)
maturityDate = settlementDate.addMonths(120)
swap9 = FinLiborSwap(settlementDate, maturityDate, m * 0.015880 + irBump,
fixedFreq, dcType)
swaps.append(swap9)
maturityDate = settlementDate.addMonths(144)
swap10 = FinLiborSwap(settlementDate, maturityDate, m * 0.016430 + irBump,
fixedFreq, dcType)
swaps.append(swap10)
liborCurve = FinLiborOneCurve("USD_LIBOR", settlementDate, depos, fras,
swaps)
cdsMarketContracts = []
cdsCoupon = 0.04 + mktSpreadBump
# maturityDate = valuationDate.nextCDSDate(6)
# cds = FinCDS(valuationDate,maturityDate, cdsCoupon)
# cdsMarketContracts.append(cds)
maturityDate = valuationDate.nextCDSDate(12)
cds = FinCDS(valuationDate, maturityDate, cdsCoupon)
cdsMarketContracts.append(cds)
maturityDate = valuationDate.nextCDSDate(24)
cds = FinCDS(valuationDate, maturityDate, cdsCoupon)
cdsMarketContracts.append(cds)
maturityDate = valuationDate.nextCDSDate(36)
cds = FinCDS(valuationDate, maturityDate, cdsCoupon)
cdsMarketContracts.append(cds)
maturityDate = valuationDate.nextCDSDate(48)
cds = FinCDS(valuationDate, maturityDate, cdsCoupon)
cdsMarketContracts.append(cds)
maturityDate = valuationDate.nextCDSDate(60)
cds = FinCDS(valuationDate, maturityDate, cdsCoupon)
cdsMarketContracts.append(cds)
maturityDate = valuationDate.nextCDSDate(84)
cds = FinCDS(valuationDate, maturityDate, cdsCoupon)
cdsMarketContracts.append(cds)
maturityDate = valuationDate.nextCDSDate(120)
cds = FinCDS(valuationDate, maturityDate, cdsCoupon)
cdsMarketContracts.append(cds)
maturityDate = valuationDate.nextCDSDate(180)
cds = FinCDS(valuationDate, maturityDate, cdsCoupon)
cdsMarketContracts.append(cds)
# for cds in cdsMarketContracts:
# print("CDS Maturity Date",cds._maturityDate)
recoveryRate = 0.40
issuerCurve = FinCDSCurve(valuationDate, cdsMarketContracts, liborCurve,
recoveryRate)
return liborCurve, issuerCurve
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)
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_fullPriceCDS1():
mktSpread = 0.040
testCases.header("Example", "Markit 9 Aug 2019")
liborCurve, issuerCurve = buildFullIssuerCurve1(0.0, 0.0)
# This is the 10 year contract at an off market coupon
maturityDate = FinDate(2029, 6, 20)
cdsCoupon = 0.0150
notional = ONE_MILLION
longProtection = False
tradeDate = FinDate(2019, 8, 9)
valuationDate = tradeDate.addDays(1)
effectiveDate = valuationDate
cdsContract = FinCDS(effectiveDate, maturityDate, cdsCoupon, notional,
longProtection)
cdsRecovery = 0.40
testCases.header("LABEL", "VALUE")
spd = cdsContract.parSpread(valuationDate, issuerCurve,
cdsRecovery) * 10000.0
testCases.print("PAR_SPREAD", spd)
v = cdsContract.value(valuationDate, issuerCurve, cdsRecovery)
testCases.print("FULL_VALUE", v['full_pv'])
testCases.print("CLEAN_VALUE", v['clean_pv'])
p = cdsContract.cleanPrice(valuationDate, issuerCurve, cdsRecovery)
testCases.print("CLEAN_PRICE", p)
accruedDays = cdsContract.accruedDays()
testCases.print("ACCRUED_DAYS", accruedDays)
accruedInterest = cdsContract.accruedInterest()
testCases.print("ACCRUED_COUPON", accruedInterest)
protPV = cdsContract.protectionLegPV(valuationDate, issuerCurve,
cdsRecovery)
testCases.print("PROTECTION_PV", protPV)
premPV = cdsContract.premiumLegPV(valuationDate, issuerCurve, cdsRecovery)
testCases.print("PREMIUM_PV", premPV)
fullRPV01, cleanRPV01 = cdsContract.riskyPV01(valuationDate, issuerCurve)
testCases.print("FULL_RPV01", fullRPV01)
testCases.print("CLEAN_RPV01", cleanRPV01)
# cdsContract.printFlows(issuerCurve)
bump = 1.0 / 10000.0 # 1 bp
liborCurve, issuerCurve = buildFullIssuerCurve1(bump, 0)
v_bump = cdsContract.value(valuationDate, issuerCurve, cdsRecovery)
dv = v_bump['full_pv'] - v['full_pv']
testCases.print("CREDIT_DV01", dv)
# Interest Rate Bump
liborCurve, issuerCurve = buildFullIssuerCurve1(0, bump)
v_bump = cdsContract.value(valuationDate, issuerCurve, cdsRecovery)
dv = v_bump['full_pv'] - v['full_pv']
testCases.print("INTEREST_DV01", dv)
t = (maturityDate - valuationDate) / gDaysInYear
z = liborCurve.df(maturityDate)
r = -np.log(z) / t
v_approx = cdsContract.valueFastApprox(valuationDate, r, mktSpread,
cdsRecovery)
testCases.print("FULL APPROX VALUE", v_approx[0])
testCases.print("CLEAN APPROX VALUE", v_approx[1])
testCases.print("APPROX CREDIT DV01", v_approx[2])
testCases.print("APPROX INTEREST DV01", v_approx[3])
