fix example

Author: thrasibule

examples/option_valuation.py

@@ -20,30 +20,30 @@
 NPV of the American Option without dividend:                    17.9647
 
 """
-from __future__ import print_function
-
 from quantlib.settings import Settings
 from quantlib.compounding import Simple
+from quantlib.cashflows.dividend import DividendSchedule
 from quantlib.currency.api import USDCurrency
 from quantlib.indexes.api import Libor
 from quantlib.indexes.swap_index import SwapIndex
-from quantlib.instruments.option import EuropeanExercise, AmericanExercise
-from quantlib.instruments.option import VanillaOption, DividendVanillaOption, Call
+from quantlib.instruments.exercise import EuropeanExercise, AmericanExercise
+from quantlib.instruments.option import VanillaOption, VanillaOption, OptionType
 from quantlib.instruments.payoffs import PlainVanillaPayoff
+from quantlib.math.interpolation import Linear
 from quantlib.pricingengines.api import AnalyticDividendEuropeanEngine
-from quantlib.pricingengines.api import FDDividendAmericanEngine
+from quantlib.pricingengines.api import FdBlackScholesVanillaEngine
 from quantlib.pricingengines.api import AnalyticEuropeanEngine
-from quantlib.pricingengines.api import FDAmericanEngine
 from quantlib.processes.black_scholes_process import BlackScholesProcess
 from quantlib.quotes import SimpleQuote
 from quantlib.time.api import (
-    Date, Days, Period, Actual360, Months, Jan, ModifiedFollowing, Years, Feb
+    Date, Days, Period, Actual360, Months, Jan, ModifiedFollowing, Years, Feb, pydate_from_qldate
 )
+from quantlib.methods.finitedifferences.solvers.fdmbackwardsolver import FdmSchemeDesc
 from quantlib.time.calendars.united_states import UnitedStates
 from quantlib.termstructures.yields.api import (
-    PiecewiseYieldCurve, DepositRateHelper, Interpolator, BootstrapTrait
+    PiecewiseYieldCurve, DepositRateHelper, BootstrapTrait, HandleYieldTermStructure
 )
-from quantlib.termstructures.volatility.equityfx.black_vol_term_structure import BlackConstantVol
+from quantlib.termstructures.volatility.api import BlackConstantVol
 from quantlib.termstructures.yields.api import SwapRateHelper
 
 def dividendOption():
@@ -61,7 +61,7 @@ def dividendOption():
         todaysDate, period=Period(settlement_days, Days)
     )
     dayCounter = Actual360() # INPUT
-    currency = USDCurrency() # INPUT	
+    currency = USDCurrency() # INPUT
 
     print("Date of the evaluation:			", todaysDate)
     print("Calendar used:         			", calendar.name)
@@ -88,28 +88,28 @@ def dividendOption():
 
     # 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 
+
+    #  Libor data record
     print("**********************************")
-    print("Description of the Libor used for the Yield Curve construction") 
-    
+    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, 
+    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 
+    # Swap data record
 
     # description of the fixed leg of the swap
     Swap_fixedLegTenor	= Period(12, Months) # INPUT
@@ -134,19 +134,19 @@ def dividendOption():
     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 
+    # ++++++++++++++++++++ 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													
+        # Initialize rate helper	___ the DepositRateHelper link the recording rate with the Libor index
         instruments.append(DepositRateHelper(rate, index=liborIndex))
 
     # +++++++++++++++++++++ Swap
@@ -158,39 +158,38 @@ def dividendOption():
                 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)
+    riskFreeTS = PiecewiseYieldCurve[BootstrapTrait.ZeroYield, Linear].from_reference_date(settlementDate, instruments, dayCounter)
 
 
-    # ++++++++++++++++++  build of the underlying process : with a Black-Scholes model 
+    # ++++++++++++++++++  build of the underlying process : with a Black-Scholes model
 
     print('Creating process')
 
-    bsProcess = BlackScholesProcess(underlying_priceH, riskFreeTS, flatVolTS)
+    bsProcess = BlackScholesProcess(underlying_priceH, HandleYieldTermStructure(riskFreeTS), flatVolTS)
 
 
     # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     # ++++++++++++++++++++ Description of the option +++++++++++++++++++++++++++++++++++++++
     # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    
+
     Option_name = "IBM Option"
     maturity = Date(26, Jan, 2013)
     strike = 190
-    option_type = Call 
+    option_type = OptionType.Call
 
     # Here, as an implementation example, 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("Type of the option:   			", option_type.name)
     print("Strike of the option:		    ", strike)
 
 
@@ -199,7 +198,7 @@ def dividendOption():
     # INPUT You have to determine the frequence 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)
+    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)
@@ -209,26 +208,24 @@ def dividendOption():
 
     d = next_dividend_date
     while d <= maturity:
-        dividendDates.append(d)
+        dividendDates.append(pydate_from_qldate(d))
         dividends.append(dividend)
-        d = d + dividendfrequence
+        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 
+    # ++++++++++++++++++ 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
-    )
+    dividendEuropeanOption = VanillaOption(
+        payoff, europeanExercise)
+    dividendAmericanOption = VanillaOption(
+        payoff, americanExercise)
 
 
     # just too test
@@ -238,33 +235,33 @@ def dividendOption():
     # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     # ++++++++++++++++++++ Description of the pricing  +++++++++++++++++++++++++++++++++++++
     # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    
+
     # For the european options we have a closed analytic formula: The Black Scholes:
-    dividendEuropeanEngine = AnalyticDividendEuropeanEngine(bsProcess)
+    dividendEuropeanEngine = AnalyticDividendEuropeanEngine(bsProcess, DividendSchedule(dividendDates, dividends))
 
     # 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)
+    dividendAmericanEngine = FdBlackScholesVanillaEngine(bsProcess, americanTimeSteps, americanGirdPoints, scheme=FdmSchemeDesc.CrankNicolson(), dividends=DividendSchedule(dividendDates, dividends))
 
     # just to test
     europeanEngine = AnalyticEuropeanEngine(bsProcess)
-    americanEngine = FDAmericanEngine('CrankNicolson', bsProcess,americanTimeSteps, americanGirdPoints)
+    americanEngine = FdBlackScholesVanillaEngine(bsProcess, americanTimeSteps, americanGirdPoints, scheme=FdmSchemeDesc.CrankNicolson())
 
 
     # ++++++++++++++++++++ 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	
+    # 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))
@@ -279,4 +276,3 @@ def dividendOption():
 if __name__ == '__main__':
 
     dividendOption()
-