def test_create_swap_rate_helper_from_index(self):
calendar = UnitedStates()
settlement_days = 2
currency = USDCurrency()
fixed_leg_tenor = Period(12, Months)
fixed_leg_convention = ModifiedFollowing
fixed_leg_daycounter = Actual360()
family_name = currency.name + 'index'
ibor_index = Libor(
"USDLibor", Period(3,Months), settlement_days, USDCurrency(),
UnitedStates(), Actual360()
)
rate = SimpleQuote(0.005681)
tenor = Period(1, Years)
index = SwapIndex (
family_name, tenor, settlement_days, currency, calendar,
fixed_leg_tenor, fixed_leg_convention,
fixed_leg_daycounter, ibor_index)
helper_from_quote = SwapRateHelper.from_index(rate, index)
helper_from_float = SwapRateHelper.from_index(0.005681, index)
#self.fail(
# 'Make this pass: create and ask for the .quote property'
# ' Test the from_index and from_tenor methods'
#)
self.assertIsNotNone(helper_from_quote, helper_from_float)
self.assertAlmostEqual(rate.value, helper_from_quote.quote.value)
self.assertAlmostEqual(helper_from_float.quote.value, helper_from_quote.quote.value)
with self.assertRaises(RuntimeError):
self.assertAlmostEqual(rate.value, helper_from_quote.implied_quote)
def test_create_swap_index(self):
settings = Settings.instance()
# Market information
calendar = TARGET()
# must be a business day
eval_date = calendar.adjust(today())
settings.evaluation_date = eval_date
settlement_days = 2
settlement_date = calendar.advance(eval_date, settlement_days, Days)
# must be a business day
settlement_date = calendar.adjust(settlement_date)
term_structure = YieldTermStructure(relinkable=True)
term_structure.link_to(
FlatForward(settlement_date, 0.05, Actual365Fixed()))
ibor_index = Libor('USD Libor', Period(6, Months), settlement_days,
USDCurrency(), calendar, Actual360(),
term_structure)
index = SwapIndex('family name', Period(3, Months), 10, USDCurrency(),
TARGET(), Period(12, Months), Following, Actual360(),
ibor_index)
self.assertIsNotNone(index)
def test_create_swap_index(self):
settings = Settings.instance()
# Market information
calendar = TARGET()
# must be a business day
eval_date = calendar.adjust(today())
settings.evaluation_date = eval_date
settlement_days = 2
settlement_date = calendar.advance(eval_date, settlement_days, Days)
# must be a business day
settlement_date = calendar.adjust(settlement_date);
ibor_index = Libor('USD Libor', Period(6, Months), settlement_days,
USDCurrency(), calendar, Actual360())
index = SwapIndex(
'family name', Period(3, Months), 10, USDCurrency(), TARGET(),
Period(12, Months), Following, Actual360(), ibor_index)
self.assertIsNotNone(index)
def test_create_swap_rate_helper_from_index(self):
from quantlib.currency import USDCurrency
from quantlib.indexes.swap_index import SwapIndex
from quantlib.indexes.libor import Libor
from quantlib.time.api import Years, UnitedStates, Actual360
calendar = UnitedStates()
settlement_days = 2
currency = USDCurrency()
fixed_leg_tenor = Period(12, Months)
fixed_leg_convention = ModifiedFollowing
fixed_leg_daycounter = Actual360()
family_name = currency.name + 'index'
ibor_index = Libor(
"USDLibor", Period(3,Months), settlement_days, USDCurrency(),
UnitedStates(), Actual360()
)
rate = 0.005681
tenor = Period(1, Years)
index = SwapIndex (
family_name, tenor, settlement_days, currency, calendar,
fixed_leg_tenor, fixed_leg_convention,
fixed_leg_daycounter, ibor_index)
helper = SwapRateHelper.from_index(rate, index)
#self.fail(
# 'Make this pass: create and ask for the .quote property'
# ' Test the from_index and from_tenor methods'
#)
self.assertIsNotNone(helper)
self.assertAlmostEquals(rate, helper.quote)
with self.assertRaises(RuntimeError):
self.assertAlmostEquals(rate, helper.implied_quote)
def dividendOption():
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++ General Parameter for all the computation +++++++++++++++++++++++
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# declaration of the today's date (date where the records are done)
todaysDate = Date(24, Jan, 2012) # INPUT
Settings.instance(
).evaluation_date = todaysDate #!\ IMPORTANT COMMAND REQUIRED FOR ALL VALUATIONS
calendar = UnitedStates() # INPUT
settlement_days = 2 # INPUT
# Calcul of the settlement date : need to add a period of 2 days to the todays date
settlementDate = calendar.advance(todaysDate,
period=Period(settlement_days, Days))
dayCounter = Actual360() # INPUT
currency = USDCurrency() # INPUT
print("Date of the evaluation: ", todaysDate)
print("Calendar used: ", calendar.name)
print("Number of settlement Days: ", settlement_days)
print("Date of settlement: ", settlementDate)
print("Convention of day counter: ", dayCounter.name())
print("Currency of the actual context:\t\t", currency.name)
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++ Description of the underlying +++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
underlying_name = "IBM"
underlying_price = 191.75 # INPUT
underlying_vol = 0.2094 # INPUT
print("**********************************")
print("Name of the underlying: ", underlying_name)
print("Price of the underlying at t0: ", underlying_price)
print("Volatility of the underlying: ", underlying_vol)
# For a great managing of price and vol objects --> Handle
underlying_priceH = SimpleQuote(underlying_price)
# We suppose the vol constant : his term structure is flat --> BlackConstantVol object
flatVolTS = BlackConstantVol(settlementDate, calendar, underlying_vol,
dayCounter)
# ++++++++++++++++++++ Description of Yield Term Structure
# Libor data record
print("**********************************")
print("Description of the Libor used for the Yield Curve construction")
Libor_dayCounter = Actual360()
liborRates = []
liborRatesTenor = []
# INPUT : all the following data are input : the rate and the corresponding tenor
# You could make the choice of more or less data
# --> However you have tho choice the instruments with different maturities
liborRates = [
0.002763, 0.004082, 0.005601, 0.006390, 0.007125, 0.007928, 0.009446,
0.01110
]
liborRatesTenor = [
Period(tenor, Months) for tenor in [1, 2, 3, 4, 5, 6, 9, 12]
]
for tenor, rate in zip(liborRatesTenor, liborRates):
print(tenor, "\t\t\t", rate)
# Swap data record
# description of the fixed leg of the swap
Swap_fixedLegTenor = Period(12, Months) # INPUT
Swap_fixedLegConvention = ModifiedFollowing # INPUT
Swap_fixedLegDayCounter = Actual360() # INPUT
# description of the float leg of the swap
Swap_iborIndex = Libor("USDLibor", Period(3, Months), settlement_days,
USDCurrency(), UnitedStates(), Actual360())
print("Description of the Swap used for the Yield Curve construction")
print("Tenor of the fixed leg: ", Swap_fixedLegTenor)
print("Index of the floated leg: ", Swap_iborIndex.name)
print("Maturity Rate ")
swapRates = []
swapRatesTenor = []
# INPUT : all the following data are input : the rate and the corresponding tenor
# You could make the choice of more or less data
# --> However you have tho choice the instruments with different maturities
swapRates = [
0.005681, 0.006970, 0.009310, 0.012010, 0.014628, 0.016881, 0.018745,
0.020260, 0.021545
]
swapRatesTenor = [Period(i, Years) for i in range(2, 11)]
for tenor, rate in zip(swapRatesTenor, swapRates):
print(tenor, "\t\t\t", rate)
# ++++++++++++++++++++ Creation of the vector of RateHelper (need for the Yield Curve construction)
# ++++++++++++++++++++ Libor
LiborFamilyName = currency.name + "Libor"
instruments = []
for rate, tenor in zip(liborRates, liborRatesTenor):
# Index description ___ creation of a Libor index
liborIndex = Libor(LiborFamilyName, tenor, settlement_days, currency,
calendar, Libor_dayCounter)
# Initialize rate helper ___ the DepositRateHelper link the recording rate with the Libor index
instruments.append(DepositRateHelper(rate, index=liborIndex))
# +++++++++++++++++++++ Swap
SwapFamilyName = currency.name + "swapIndex"
for tenor, rate in zip(swapRatesTenor, swapRates):
# swap description ___ creation of a swap index. The floating leg is described in the index 'Swap_iborIndex'
swapIndex = SwapIndex(SwapFamilyName, tenor, settlement_days, currency,
calendar, Swap_fixedLegTenor,
Swap_fixedLegConvention, Swap_fixedLegDayCounter,
Swap_iborIndex)
# Initialize rate helper __ the SwapRateHelper links the swap index width his rate
instruments.append(SwapRateHelper.from_index(rate, swapIndex))
# ++++++++++++++++++ Now the creation of the yield curve
riskFreeTS = PiecewiseYieldCurve.from_reference_date(
BootstrapTrait.ZeroYield, Interpolator.Linear, settlementDate,
instruments, dayCounter)
# ++++++++++++++++++ build of the underlying process : with a Black-Scholes model
print('Creating process')
bsProcess = BlackScholesProcess(underlying_priceH, riskFreeTS, flatVolTS)
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++ Description of the option +++++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Option_name = "IBM Option"
maturity = Date(26, Jan, 2013)
strike = 190
option_type = 'call'
# Here, as an implementation exemple, we make the test with borth american and european exercise
europeanExercise = EuropeanExercise(maturity)
# The emericanExercise need also the settlement date, as his right to exerce the buy or call start at the settlement date!
#americanExercise = AmericanExercise(settlementDate, maturity)
americanExercise = AmericanExercise(maturity, settlementDate)
print("**********************************")
print("Description of the option: ", Option_name)
print("Date of maturity: ", maturity)
print("Type of the option: ", option_type)
print("Strike of the option: ", strike)
# ++++++++++++++++++ Description of the discrete dividends
# INPUT You have to determine the frequece and rates of the discrete dividend. Here is a sollution, but she's not the only one.
# Last know dividend:
dividend = 0.75 #//0.75
next_dividend_date = Date(10, Feb, 2012)
# HERE we have make the assumption that the dividend will grow with the quarterly croissance:
dividendCroissance = 1.03
dividendfrequence = Period(3, Months)
dividendDates = []
dividends = []
d = next_dividend_date
while d <= maturity:
dividendDates.append(d)
dividends.append(dividend)
d = d + dividendfrequence
dividend *= dividendCroissance
print("Discrete dividends ")
print("Dates Dividends ")
for date, div in zip(dividendDates, dividends):
print(date, " ", div)
# ++++++++++++++++++ Description of the final payoff
payoff = PlainVanillaPayoff(option_type, strike)
# ++++++++++++++++++ The OPTIONS : (American and European) with their dividends description:
dividendEuropeanOption = DividendVanillaOption(payoff, europeanExercise,
dividendDates, dividends)
dividendAmericanOption = DividendVanillaOption(payoff, americanExercise,
dividendDates, dividends)
# just too test
europeanOption = VanillaOption(payoff, europeanExercise)
americanOption = VanillaOption(payoff, americanExercise)
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++ Description of the pricing +++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# For the european options we have a closed analytic formula: The Black Scholes:
dividendEuropeanEngine = AnalyticDividendEuropeanEngine(bsProcess)
# For the american option we have make the choice of the finite difference model with the CrankNicolson scheme
# this model need to precise the time and space step
# More they are greater, more the calul will be precise.
americanGirdPoints = 600
americanTimeSteps = 600
dividendAmericanEngine = FDDividendAmericanEngine('CrankNicolson',
bsProcess,
americanTimeSteps,
americanGirdPoints)
# just to test
europeanEngine = AnalyticEuropeanEngine(bsProcess)
americanEngine = FDAmericanEngine('CrankNicolson', bsProcess,
americanTimeSteps, americanGirdPoints)
# ++++++++++++++++++++ Valorisation ++++++++++++++++++++++++++++++++++++++++
# Link the pricing Engine to the option
dividendEuropeanOption.set_pricing_engine(dividendEuropeanEngine)
dividendAmericanOption.set_pricing_engine(dividendAmericanEngine)
# just to test
europeanOption.set_pricing_engine(europeanEngine)
americanOption.set_pricing_engine(americanEngine)
# Now we make all the needing calcul
# ... and final results
print(
"NPV of the European Option with discrete dividends=0: {:.4f}".format(
dividendEuropeanOption.npv))
print("NPV of the European Option without dividend: {:.4f}".format(
europeanOption.npv))
print(
"NPV of the American Option with discrete dividends=0: {:.4f}".format(
dividendAmericanOption.npv))
print("NPV of the American Option without dividend: {:.4f}".format(
americanOption.npv))
# just a single test
print("ZeroRate with a maturity at ", maturity, ": ", \
riskFreeTS.zero_rate(maturity, dayCounter, Simple))
def test_zero_curve_on_swap_index(self):
todays_date = today()
calendar = UnitedStates() # INPUT
dayCounter = Actual360() # INPUT
currency = USDCurrency() # INPUT
Settings.instance().evaluation_date = todays_date
settlement_days = 2
settlement_date = calendar.advance(
todays_date, period=Period(settlement_days, Days)
)
liborRates = [ SimpleQuote(0.002763), SimpleQuote(0.004082), SimpleQuote(0.005601), SimpleQuote(0.006390), SimpleQuote(0.007125),
SimpleQuote(0.007928), SimpleQuote(0.009446), SimpleQuote(0.01110)]
liborRatesTenor = [Period(tenor, Months) for tenor in [1,2,3,4,5,6,9,12]]
Libor_dayCounter = Actual360();
swapRates = [SimpleQuote(0.005681), SimpleQuote(0.006970), SimpleQuote(0.009310), SimpleQuote(0.012010), SimpleQuote(0.014628),
SimpleQuote(0.016881), SimpleQuote(0.018745), SimpleQuote(0.020260), SimpleQuote(0.021545)]
swapRatesTenor = [Period(i, Years) for i in range(2, 11)]
# description of the fixed leg of the swap
Swap_fixedLegTenor = Period(12, Months) # INPUT
Swap_fixedLegConvention = ModifiedFollowing # INPUT
Swap_fixedLegDayCounter = Actual360() # INPUT
# description of the float leg of the swap
Swap_iborIndex = Libor(
"USDLibor", Period(3, Months), settlement_days, USDCurrency(),
UnitedStates(), Actual360()
)
SwapFamilyName = currency.name + "swapIndex"
instruments = []
# ++++++++++++++++++++ Creation of the vector of RateHelper (need for the Yield Curve construction)
# ++++++++++++++++++++ Libor
LiborFamilyName = currency.name + "Libor"
instruments = []
for rate, tenor in zip(liborRates, liborRatesTenor):
# Index description ___ creation of a Libor index
liborIndex = Libor(
LiborFamilyName, tenor, settlement_days, currency, calendar,
Libor_dayCounter
)
# Initialize rate helper
# the DepositRateHelper link the recording rate with the Libor
# index
instruments.append(DepositRateHelper(rate, index=liborIndex))
for tenor, rate in zip(swapRatesTenor, swapRates):
# swap description ___ creation of a swap index. The floating leg is described in the index 'Swap_iborIndex'
swapIndex = SwapIndex (
SwapFamilyName, tenor, settlement_days, currency, calendar,
Swap_fixedLegTenor, Swap_fixedLegConvention,
Swap_fixedLegDayCounter, Swap_iborIndex
)
# Initialize rate helper __ the SwapRateHelper links the swap index width his rate
instruments.append(SwapRateHelper.from_index(rate,swapIndex))
# ++++++++++++++++++ Now the creation of the yield curve
tolerance = 1.0e-15
ts = PiecewiseYieldCurve.from_reference_date(
BootstrapTrait.ZeroYield, Interpolator.Linear, settlement_date, instruments, dayCounter,
tolerance
)
self.assertEqual(settlement_date, ts.reference_date)