public static Greeks GetOptionOnFutureGreeks(double underlyingPrice, double strike, double riskFreeRate,
DateTime expirationDate, DateTime calculationDate, string optionType, string exerciseType,
double optionPrice = double.NaN, double impliedVol = 0.15, string engineName = "baw")
{
QLNet.Date ExpirationDateObj = new QLNet.Date(expirationDate.Day, expirationDate.Month, expirationDate.Year);
QLNet.Date CalculationDateObj = new QLNet.Date(calculationDate.Day, calculationDate.Month, calculationDate.Year);
QLNet.DayCounter DayCountObj = new QLNet.Actual365Fixed();
QLNet.Calendar CalendarObj = new QLNet.UnitedStates();
Greeks GreeksOutput = new Greeks();
QLNet.Option.Type OptionTypeObj;
QLNet.Exercise ExerciseObj;
double ImpliedVol;
double OptionPrice;
int CalDte = DayCountObj.dayCount(CalculationDateObj, ExpirationDateObj);
GreeksOutput.CalDte = CalDte;
if (!double.IsNaN(optionPrice))
{
if (optionType.ToUpper() == "C")
{
if (optionPrice + strike - underlyingPrice <= 1.0e-12)
{
GreeksOutput.Delta = 1;
return(GreeksOutput);
}
}
else if (optionType.ToUpper() == "P")
{
if (optionPrice - strike + underlyingPrice <= 1.0e-12)
{
GreeksOutput.Delta = -1;
return(GreeksOutput);
}
}
}
if (CalDte == 0)
{
if (optionType.ToUpper() == "C")
{
if (strike <= underlyingPrice)
{
GreeksOutput.Delta = 1;
}
else
{
GreeksOutput.Delta = 0;
}
}
else if (optionType.ToUpper() == "P")
{
if (strike >= underlyingPrice)
{
GreeksOutput.Delta = -1;
}
else
{
GreeksOutput.Delta = 0;
}
}
return(GreeksOutput);
}
if (optionType.ToUpper() == "C")
{
OptionTypeObj = QLNet.Option.Type.Call;
}
else if (optionType.ToUpper() == "P")
{
OptionTypeObj = QLNet.Option.Type.Put;
}
else
{
return(GreeksOutput);
}
if (exerciseType.ToUpper() == "E")
{
ExerciseObj = new QLNet.EuropeanExercise(ExpirationDateObj);
}
else if (exerciseType.ToUpper() == "A")
{
ExerciseObj = new QLNet.AmericanExercise(CalculationDateObj, ExpirationDateObj);
}
else
{
return(GreeksOutput);
}
QLNet.Settings.setEvaluationDate(CalculationDateObj);
QLNet.Handle <Quote> UnderlyingObj = new QLNet.Handle <Quote>(new QLNet.SimpleQuote(underlyingPrice));
QLNet.Handle <YieldTermStructure> FlatRateObj = new QLNet.Handle <YieldTermStructure>(new QLNet.FlatForward(CalculationDateObj, riskFreeRate, DayCountObj));
QLNet.Handle <BlackVolTermStructure> FlatVolTsObj = new QLNet.Handle <BlackVolTermStructure>(new QLNet.BlackConstantVol(CalculationDateObj, CalendarObj, impliedVol, DayCountObj));
QLNet.BlackProcess BlackProc = new QLNet.BlackProcess(UnderlyingObj, FlatRateObj, FlatVolTsObj);
QLNet.PlainVanillaPayoff PayoffObj = new QLNet.PlainVanillaPayoff(OptionTypeObj, strike);
QLNet.VanillaOption OptionObj = new QLNet.VanillaOption(PayoffObj, ExerciseObj);
if (engineName == "baw")
{
OptionObj.setPricingEngine(new QLNet.BaroneAdesiWhaleyApproximationEngine(BlackProc));
}
else if (engineName == "fda")
{
OptionObj.setPricingEngine(new QLNet.FDAmericanEngine(BlackProc, 100, 100));
}
else
{
return(GreeksOutput);
}
if (!double.IsNaN(optionPrice))
{
try
{
ImpliedVol = OptionObj.impliedVolatility(targetValue: optionPrice, process: BlackProc, accuracy: 1e-5);
}
catch
{
return(GreeksOutput);
}
FlatVolTsObj = new QLNet.Handle <BlackVolTermStructure>(new QLNet.BlackConstantVol(CalculationDateObj, CalendarObj, ImpliedVol, DayCountObj));
BlackProc = new QLNet.BlackProcess(UnderlyingObj, FlatRateObj, FlatVolTsObj);
if (engineName == "baw")
{
OptionObj.setPricingEngine(new QLNet.BaroneAdesiWhaleyApproximationEngine(BlackProc));
}
else if (engineName == "fda")
{
OptionObj.setPricingEngine(new QLNet.FDAmericanEngine(BlackProc, 100, 100));
}
OptionPrice = optionPrice;
}
else
{
OptionPrice = OptionObj.NPV();
ImpliedVol = impliedVol;
}
OptionObj = new QLNet.VanillaOption(PayoffObj, new QLNet.EuropeanExercise(ExpirationDateObj));
OptionObj.setPricingEngine(new QLNet.AnalyticEuropeanEngine(BlackProc));
GreeksOutput.Delta = OptionObj.delta();
GreeksOutput.Vega = OptionObj.vega();
GreeksOutput.Theta = OptionObj.thetaPerDay();
GreeksOutput.Gamma = OptionObj.gamma();
GreeksOutput.OptionPrice = OptionPrice;
GreeksOutput.ImpliedVol = ImpliedVol;
return(GreeksOutput);
}
static void Main(string[] args)
{
Calendar calendar = new TARGET();
Date todaysDate = new Date(22, 7, 2014);
Date settlementDate = new Date(3, 6, 2014);
Settings.setEvaluationDate(todaysDate);
DayCounter dayCounter = new Actual365Fixed();
double dividendYield = 0.0117;
double volatility = 0.15517;
Barrier.Type type = Barrier.Type.UpOut;
QLNet.PlainVanillaPayoff payoff = new PlainVanillaPayoff(Option.Type.Call,261.4);
QLNet.EuropeanExercise ex = new EuropeanExercise(new Date(30,11,2015));
//QLNet.BarrierOption barrierOption = new BarrierOption(type, 1.2,1.0, 0.0, payoff, ex);
//QLNet.BarrierOption barrierOption = new BarrierOption(type, 313.68, 0.0, payoff, ex);
QLNet.BarrierOption barrierOption = new BarrierOption(type, 313.68, 0.32,0.0, payoff, ex);
double underlying = 262.86;
double riskFreeRate = 0.0243;
Handle<Quote> underlyingH = new Handle<Quote>(new SimpleQuote(underlying));
// bootstrap the yield/dividend/vol curves
var flatTermStructure = new Handle<YieldTermStructure>(new FlatForward(settlementDate, riskFreeRate, dayCounter));
var flatDividendTS = new Handle<YieldTermStructure>(new FlatForward(settlementDate, dividendYield, dayCounter));
var flatVolTS = new Handle<BlackVolTermStructure>(new BlackConstantVol(settlementDate, calendar, volatility, dayCounter));
var bsmProcess = new BlackScholesMertonProcess(underlyingH, flatDividendTS, flatTermStructure, flatVolTS);
QLNet.AnalyticBarrierWithPartiRateEngine engine = new AnalyticBarrierWithPartiRateEngine(bsmProcess);
barrierOption.setPricingEngine(engine);
double kk = barrierOption.NPV();
Console.WriteLine(kk);
Console.WriteLine(kk / 261.4);
}
public YieldTermStructure buildQLNet_YieldTS(Excel_irCurveDataViewModel e_irCurveData)
{
QLNet.YieldTermStructure ql_yts = new YieldTermStructure();
List <QLNet.Date> dates = new List <QLNet.Date>();
List <double> yields = new List <double>();
foreach (var item in e_irCurveData.Excel_rateDataViewModelList_)
{
string tenor = item.Tenor_;
if (tenor.Substring(0, 1) == "D")
{
int addDays = Convert.ToInt32(tenor.Substring(1, 3));
dates.Add(ProgramVariable.ReferenceDate_.AddDays(addDays));
}
else if (tenor.Substring(0, 1) == "M")
{
int addMonths = Convert.ToInt32(tenor.Substring(1, 3));
dates.Add(ProgramVariable.ReferenceDate_.AddMonths(addMonths));
}
else
{
throw new Exception("unknown type tenor : " + tenor);
}
yields.Add(Convert.ToDouble(item.Value_));
}
QLNet.DayCounter dc = new QLNet.Actual365Fixed();
QLNet.InterpolatedZeroCurve <QLNet.Linear> curve = new QLNet.InterpolatedZeroCurve <QLNet.Linear>(
dates, yields, dc, new QLNet.Linear());
return(ql_yts);
}
static void Main(string[] args) {
DateTime timer = DateTime.Now;
/*********************
*** MARKET DATA ***
*********************/
Calendar calendar = new TARGET();
Date settlementDate = new Date(18, Month.September, 2008);
// must be a business day
settlementDate = calendar.adjust(settlementDate);
int fixingDays = 3;
int settlementDays = 3;
Date todaysDate = calendar.advance(settlementDate, -fixingDays, TimeUnit.Days);
// nothing to do with Date::todaysDate
Settings.setEvaluationDate(todaysDate);
Console.WriteLine("Today: {0}, {1}", todaysDate.DayOfWeek, todaysDate);
Console.WriteLine("Settlement date: {0}, {1}", settlementDate.DayOfWeek, settlementDate);
// Building of the bonds discounting yield curve
/*********************
*** RATE HELPERS ***
*********************/
// RateHelpers are built from the above quotes together with
// other instrument dependant infos. Quotes are passed in
// relinkable handles which could be relinked to some other
// data source later.
// Common data
// ZC rates for the short end
double zc3mQuote=0.0096;
double zc6mQuote=0.0145;
double zc1yQuote=0.0194;
Quote zc3mRate = new SimpleQuote(zc3mQuote);
Quote zc6mRate = new SimpleQuote(zc6mQuote);
Quote zc1yRate = new SimpleQuote(zc1yQuote);
DayCounter zcBondsDayCounter = new Actual365Fixed();
RateHelper zc3m = new DepositRateHelper(new Handle<Quote>(zc3mRate),
new Period(3, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, zcBondsDayCounter);
RateHelper zc6m = new DepositRateHelper(new Handle<Quote>(zc6mRate),
new Period(6, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, zcBondsDayCounter);
RateHelper zc1y = new DepositRateHelper(new Handle<Quote>(zc1yRate),
new Period(1, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, zcBondsDayCounter);
// setup bonds
double redemption = 100.0;
const int numberOfBonds = 5;
Date[] issueDates = {
new Date (15, Month.March, 2005),
new Date (15, Month.June, 2005),
new Date (30, Month.June, 2006),
new Date (15, Month.November, 2002),
new Date (15, Month.May, 1987)
};
Date[] maturities = {
new Date (31, Month.August, 2010),
new Date (31, Month.August, 2011),
new Date (31, Month.August, 2013),
new Date (15, Month.August, 2018),
new Date (15, Month.May, 2038)
};
double[] couponRates = {
0.02375,
0.04625,
0.03125,
0.04000,
0.04500
};
double[] marketQuotes = {
100.390625,
106.21875,
100.59375,
101.6875,
102.140625
};
List<SimpleQuote> quote = new List<SimpleQuote>();
for (int i=0; i<numberOfBonds; i++) {
SimpleQuote cp = new SimpleQuote(marketQuotes[i]);
quote.Add(cp);
}
List<RelinkableHandle<Quote>> quoteHandle = new InitializedList<RelinkableHandle<Quote>>(numberOfBonds);
for (int i=0; i<numberOfBonds; i++) {
quoteHandle[i].linkTo(quote[i]);
}
// Definition of the rate helpers
List<FixedRateBondHelper> bondsHelpers = new List<FixedRateBondHelper>();
for (int i=0; i<numberOfBonds; i++) {
Schedule schedule = new Schedule(issueDates[i], maturities[i], new Period(Frequency.Semiannual),
new UnitedStates(UnitedStates.Market.GovernmentBond),
BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted,
DateGeneration.Rule.Backward, false);
FixedRateBondHelper bondHelper = new FixedRateBondHelper(quoteHandle[i],
settlementDays,
100.0,
schedule,
new List<double>() { couponRates[i] },
new ActualActual(ActualActual.Convention.Bond),
BusinessDayConvention.Unadjusted,
redemption,
issueDates[i]);
bondsHelpers.Add(bondHelper);
}
/*********************
** CURVE BUILDING **
*********************/
// Any DayCounter would be fine.
// ActualActual::ISDA ensures that 30 years is 30.0
DayCounter termStructureDayCounter = new ActualActual(ActualActual.Convention.ISDA);
double tolerance = 1.0e-15;
// A depo-bond curve
List<RateHelper> bondInstruments = new List<RateHelper>();
// Adding the ZC bonds to the curve for the short end
bondInstruments.Add(zc3m);
bondInstruments.Add(zc6m);
bondInstruments.Add(zc1y);
// Adding the Fixed rate bonds to the curve for the long end
for (int i=0; i<numberOfBonds; i++) {
bondInstruments.Add(bondsHelpers[i]);
}
YieldTermStructure bondDiscountingTermStructure = new PiecewiseYieldCurve<Discount,LogLinear>(
settlementDate, bondInstruments,
termStructureDayCounter,
new List<Handle<Quote>>(),
new List<Date>(),
tolerance);
// Building of the Libor forecasting curve
// deposits
double d1wQuote=0.043375;
double d1mQuote=0.031875;
double d3mQuote=0.0320375;
double d6mQuote=0.03385;
double d9mQuote=0.0338125;
double d1yQuote=0.0335125;
// swaps
double s2yQuote=0.0295;
double s3yQuote=0.0323;
double s5yQuote=0.0359;
double s10yQuote=0.0412;
double s15yQuote=0.0433;
/********************
*** QUOTES ***
********************/
// SimpleQuote stores a value which can be manually changed;
// other Quote subclasses could read the value from a database
// or some kind of data feed.
// deposits
Quote d1wRate = new SimpleQuote(d1wQuote);
Quote d1mRate = new SimpleQuote(d1mQuote);
Quote d3mRate = new SimpleQuote(d3mQuote);
Quote d6mRate = new SimpleQuote(d6mQuote);
Quote d9mRate = new SimpleQuote(d9mQuote);
Quote d1yRate = new SimpleQuote(d1yQuote);
// swaps
Quote s2yRate = new SimpleQuote(s2yQuote);
Quote s3yRate = new SimpleQuote(s3yQuote);
Quote s5yRate = new SimpleQuote(s5yQuote);
Quote s10yRate = new SimpleQuote(s10yQuote);
Quote s15yRate = new SimpleQuote(s15yQuote);
/*********************
*** RATE HELPERS ***
*********************/
// RateHelpers are built from the above quotes together with
// other instrument dependant infos. Quotes are passed in
// relinkable handles which could be relinked to some other
// data source later.
// deposits
DayCounter depositDayCounter = new Actual360();
RateHelper d1w = new DepositRateHelper(
new Handle<Quote>(d1wRate),
new Period(1, TimeUnit.Weeks), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
RateHelper d1m = new DepositRateHelper(
new Handle<Quote>(d1mRate),
new Period(1, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
RateHelper d3m = new DepositRateHelper(
new Handle<Quote>(d3mRate),
new Period(3, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
RateHelper d6m = new DepositRateHelper(
new Handle<Quote>(d6mRate),
new Period(6, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
RateHelper d9m = new DepositRateHelper(
new Handle<Quote>(d9mRate),
new Period(9, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
RateHelper d1y = new DepositRateHelper(
new Handle<Quote>(d1yRate),
new Period(1, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
// setup swaps
Frequency swFixedLegFrequency =Frequency.Annual;
BusinessDayConvention swFixedLegConvention = BusinessDayConvention.Unadjusted;
DayCounter swFixedLegDayCounter = new Thirty360(Thirty360.Thirty360Convention.European);
IborIndex swFloatingLegIndex = new Euribor6M();
Period forwardStart = new Period(1, TimeUnit.Days);
RateHelper s2y = new SwapRateHelper(
new Handle<Quote>(s2yRate), new Period(2, TimeUnit.Years),
calendar, swFixedLegFrequency,
swFixedLegConvention, swFixedLegDayCounter,
swFloatingLegIndex, new Handle<Quote>(),forwardStart);
RateHelper s3y = new SwapRateHelper(
new Handle<Quote>(s3yRate), new Period(3, TimeUnit.Years),
calendar, swFixedLegFrequency,
swFixedLegConvention, swFixedLegDayCounter,
swFloatingLegIndex, new Handle<Quote>(),forwardStart);
RateHelper s5y = new SwapRateHelper(
new Handle<Quote>(s5yRate), new Period(5, TimeUnit.Years),
calendar, swFixedLegFrequency,
swFixedLegConvention, swFixedLegDayCounter,
swFloatingLegIndex, new Handle<Quote>(),forwardStart);
RateHelper s10y = new SwapRateHelper(
new Handle<Quote>(s10yRate), new Period(10, TimeUnit.Years),
calendar, swFixedLegFrequency,
swFixedLegConvention, swFixedLegDayCounter,
swFloatingLegIndex, new Handle<Quote>(),forwardStart);
RateHelper s15y = new SwapRateHelper(
new Handle<Quote>(s15yRate), new Period(15, TimeUnit.Years),
calendar, swFixedLegFrequency,
swFixedLegConvention, swFixedLegDayCounter,
swFloatingLegIndex, new Handle<Quote>(),forwardStart);
/*********************
** CURVE BUILDING **
*********************/
// Any DayCounter would be fine.
// ActualActual::ISDA ensures that 30 years is 30.0
// A depo-swap curve
List<RateHelper> depoSwapInstruments = new List<RateHelper>();
depoSwapInstruments.Add(d1w);
depoSwapInstruments.Add(d1m);
depoSwapInstruments.Add(d3m);
depoSwapInstruments.Add(d6m);
depoSwapInstruments.Add(d9m);
depoSwapInstruments.Add(d1y);
depoSwapInstruments.Add(s2y);
depoSwapInstruments.Add(s3y);
depoSwapInstruments.Add(s5y);
depoSwapInstruments.Add(s10y);
depoSwapInstruments.Add(s15y);
YieldTermStructure depoSwapTermStructure = new PiecewiseYieldCurve<Discount,LogLinear>(
settlementDate, depoSwapInstruments,
termStructureDayCounter,
new List<Handle<Quote> >(),
new List<Date>(),
tolerance);
// Term structures that will be used for pricing:
// the one used for discounting cash flows
RelinkableHandle<YieldTermStructure> discountingTermStructure = new RelinkableHandle<YieldTermStructure>();
// the one used for forward rate forecasting
RelinkableHandle<YieldTermStructure> forecastingTermStructure = new RelinkableHandle<YieldTermStructure>();
/*********************
* BONDS TO BE PRICED *
**********************/
// Common data
double faceAmount = 100;
// Pricing engine
IPricingEngine bondEngine = new DiscountingBondEngine(discountingTermStructure);
// Zero coupon bond
ZeroCouponBond zeroCouponBond = new ZeroCouponBond(
settlementDays,
new UnitedStates(UnitedStates.Market.GovernmentBond),
faceAmount,
new Date(15, Month.August,2013),
BusinessDayConvention.Following,
116.92,
new Date(15, Month.August,2003));
zeroCouponBond.setPricingEngine(bondEngine);
// Fixed 4.5% US Treasury Note
Schedule fixedBondSchedule = new Schedule(new Date(15, Month.May, 2007),
new Date(15,Month.May,2017), new Period(Frequency.Semiannual),
new UnitedStates(UnitedStates.Market.GovernmentBond),
BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted, DateGeneration.Rule.Backward, false);
FixedRateBond fixedRateBond = new FixedRateBond(
settlementDays,
faceAmount,
fixedBondSchedule,
new List<double>() { 0.045 },
new ActualActual(ActualActual.Convention.Bond),
BusinessDayConvention.ModifiedFollowing,
100.0, new Date(15, Month.May, 2007));
fixedRateBond.setPricingEngine(bondEngine);
// Floating rate bond (3M USD Libor + 0.1%)
// Should and will be priced on another curve later...
RelinkableHandle<YieldTermStructure> liborTermStructure = new RelinkableHandle<YieldTermStructure>();
IborIndex libor3m = new USDLibor(new Period(3, TimeUnit.Months), liborTermStructure);
libor3m.addFixing(new Date(17, Month.July, 2008),0.0278625);
Schedule floatingBondSchedule = new Schedule(new Date(21, Month.October, 2005),
new Date(21, Month.October, 2010), new Period(Frequency.Quarterly),
new UnitedStates(UnitedStates.Market.NYSE),
BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted, DateGeneration.Rule.Backward, true);
FloatingRateBond floatingRateBond = new FloatingRateBond(
settlementDays,
faceAmount,
floatingBondSchedule,
libor3m,
new Actual360(),
BusinessDayConvention.ModifiedFollowing,
2,
// Gearings
new List<double>() { 1.0 },
// Spreads
new List<double>() { 0.001 },
// Caps
new List<double>(),
// Floors
new List<double>(),
// Fixing in arrears
true,
100.0,
new Date(21, Month.October, 2005));
floatingRateBond.setPricingEngine(bondEngine);
// Coupon pricers
IborCouponPricer pricer = new BlackIborCouponPricer();
// optionLet volatilities
double volatility = 0.0;
Handle<OptionletVolatilityStructure> vol;
vol = new Handle<OptionletVolatilityStructure>(
new ConstantOptionletVolatility(
settlementDays,
calendar,
BusinessDayConvention.ModifiedFollowing,
volatility,
new Actual365Fixed()));
pricer.setCapletVolatility(vol);
Utils.setCouponPricer(floatingRateBond.cashflows(),pricer);
// Yield curve bootstrapping
forecastingTermStructure.linkTo(depoSwapTermStructure);
discountingTermStructure.linkTo(bondDiscountingTermStructure);
// We are using the depo & swap curve to estimate the future Libor rates
liborTermStructure.linkTo(depoSwapTermStructure);
/***************
* BOND PRICING *
****************/
// write column headings
int[] widths = { 18, 10, 10, 10 };
Console.WriteLine("{0,18}{1,10}{2,10}{3,10}", "", "ZC", "Fixed", "Floating");
string separator = " | ";
int width = widths[0]
+ widths[1]
+ widths[2]
+ widths[3];
string rule = "".PadLeft(width, '-'), dblrule = "".PadLeft(width, '=');
string tab = "".PadLeft(8, ' ');
Console.WriteLine(rule);
Console.WriteLine("Net present value".PadLeft(widths[0]) + "{0,10:n2}{1,10:n2}{2,10:n2}",
zeroCouponBond.NPV(),
fixedRateBond.NPV(),
floatingRateBond.NPV());
Console.WriteLine("Clean price".PadLeft(widths[0]) + "{0,10:n2}{1,10:n2}{2,10:n2}",
zeroCouponBond.cleanPrice(),
fixedRateBond.cleanPrice(),
floatingRateBond.cleanPrice());
Console.WriteLine("Dirty price".PadLeft(widths[0]) + "{0,10:n2}{1,10:n2}{2,10:n2}",
zeroCouponBond.dirtyPrice(),
fixedRateBond.dirtyPrice(),
floatingRateBond.dirtyPrice());
Console.WriteLine("Accrued coupon".PadLeft(widths[0]) + "{0,10:n2}{1,10:n2}{2,10:n2}",
zeroCouponBond.accruedAmount(),
fixedRateBond.accruedAmount(),
floatingRateBond.accruedAmount());
Console.WriteLine("Previous coupon".PadLeft(widths[0]) + "{0,10:0.00%}{1,10:0.00%}{2,10:0.00%}",
"N/A",
fixedRateBond.previousCoupon(),
floatingRateBond.previousCoupon());
Console.WriteLine("Next coupon".PadLeft(widths[0]) + "{0,10:0.00%}{1,10:0.00%}{2,10:0.00%}",
"N/A",
fixedRateBond.nextCoupon(),
floatingRateBond.nextCoupon());
Console.WriteLine("Yield".PadLeft(widths[0]) + "{0,10:0.00%}{1,10:0.00%}{2,10:0.00%}",
zeroCouponBond.yield(new Actual360(), Compounding.Compounded, Frequency.Annual),
fixedRateBond.yield(new Actual360(), Compounding.Compounded, Frequency.Annual),
floatingRateBond.yield(new Actual360(), Compounding.Compounded, Frequency.Annual));
Console.WriteLine();
// Other computations
Console.WriteLine("Sample indirect computations (for the floating rate bond): ");
Console.WriteLine(rule);
Console.WriteLine("Yield to Clean Price: {0:n2}",
floatingRateBond.cleanPrice(floatingRateBond.yield(new Actual360(), Compounding.Compounded, Frequency.Annual),
new Actual360(), Compounding.Compounded, Frequency.Annual,
settlementDate));
Console.WriteLine("Clean Price to Yield: {0:0.00%}",
floatingRateBond.yield(floatingRateBond.cleanPrice(),new Actual360(), Compounding.Compounded, Frequency.Annual,
settlementDate));
/* "Yield to Price"
"Price to Yield" */
Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
Console.WriteLine();
Console.Write("Press any key to continue ...");
Console.ReadKey();
}
public QLNet.YieldTermStructure yieldCurve(CurveShift curveShift = null)
{
if (curveShift == null)
curveShift = new ParallelCurveShift(0.0);
QLNet.DayCounter dc = new QLNet.Actual365Fixed();
List<Handle<Quote>> quotes = new List<Handle<Quote>>();
List<double> datas = new List<double>();
List<Date> dates = new List<Date>();
CalendarManager cm = new CalendarManager(this.ReferenceDate_, CalendarManager.CountryType.SOUTH_KOREA);
foreach (clsHDAT_CURVEDATA_TB tb in this.ResultCuveData_)
{
DateTime dt = cm.adjust(this.ReferenceDate_,tb.TENOR);
double? rate = tb.RATE + curveShift.shift(dt);
dates.Add(dt);
SimpleQuote quote = new SimpleQuote(rate);
Handle<Quote> handleQuote = new Handle<Quote>(quote);
quotes.Add(handleQuote);
datas.Add(rate.Value);
}
InterpolatedZeroCurve<ConvexMonotone>
yiels_ts = new InterpolatedZeroCurve<ConvexMonotone>(
this.ReferenceDate_,
dates,
datas,
dc,
new ConvexMonotone(),
Compounding.Compounded,
Frequency.Annual);
return yiels_ts;
}
public void testImpliedHazardRate()
{
// Testing implied hazard-rate for credit-default swaps...
SavedSettings backup = new SavedSettings();
// Initialize curves
Calendar calendar = new TARGET();
Date today = calendar.adjust(Date.Today);
Settings.setEvaluationDate(today);
double h1 = 0.30, h2 = 0.40;
DayCounter dayCounter = new Actual365Fixed();
List<Date> dates = new List<Date>(3);
List<double> hazardRates = new List<double>(3);
dates.Add(today);
hazardRates.Add(h1);
dates.Add(today + new Period(5,TimeUnit.Years));
hazardRates.Add(h1);
dates.Add(today + new Period(10,TimeUnit.Years));
hazardRates.Add(h2);
RelinkableHandle<DefaultProbabilityTermStructure> probabilityCurve =
new RelinkableHandle<DefaultProbabilityTermStructure>();
probabilityCurve.linkTo(new InterpolatedHazardRateCurve<BackwardFlat>(dates,
hazardRates,
dayCounter));
RelinkableHandle<YieldTermStructure> discountCurve = new RelinkableHandle<YieldTermStructure>();
discountCurve.linkTo(new FlatForward(today,0.03,new Actual360()));
Frequency frequency = Frequency.Semiannual;
BusinessDayConvention convention = BusinessDayConvention.ModifiedFollowing;
Date issueDate = calendar.advance(today, -6, TimeUnit.Months);
double fixedRate = 0.0120;
DayCounter cdsDayCount = new Actual360();
double notional = 10000.0;
double recoveryRate = 0.4;
double? latestRate = null;
for (int n=6; n<=10; ++n)
{
Date maturity = calendar.advance(issueDate, n, TimeUnit.Years);
Schedule schedule = new Schedule(issueDate, maturity, new Period(frequency), calendar,
convention, convention,
DateGeneration.Rule.Forward, false);
CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
schedule, convention, cdsDayCount,true, true);
cds.setPricingEngine(new MidPointCdsEngine(probabilityCurve, recoveryRate, discountCurve));
double NPV = cds.NPV();
double flatRate = cds.impliedHazardRate(NPV, discountCurve,
dayCounter,
recoveryRate);
if (flatRate < h1 || flatRate > h2) {
Assert.Fail("implied hazard rate outside expected range\n"
+ " maturity: " + n + " years\n"
+ " expected minimum: " + h1 + "\n"
+ " expected maximum: " + h2 + "\n"
+ " implied rate: " + flatRate);
}
if (n > 6 && flatRate < latestRate) {
Assert.Fail("implied hazard rate decreasing with swap maturity\n"
+ " maturity: " + n + " years\n"
+ " previous rate: " + latestRate + "\n"
+ " implied rate: " + flatRate);
}
latestRate = flatRate;
RelinkableHandle<DefaultProbabilityTermStructure> probability = new RelinkableHandle<DefaultProbabilityTermStructure>();
probability.linkTo(new FlatHazardRate( today,new Handle<Quote>(new SimpleQuote(flatRate)),dayCounter));
CreditDefaultSwap cds2 = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
schedule, convention, cdsDayCount,true, true);
cds2.setPricingEngine(new MidPointCdsEngine(probability,recoveryRate,discountCurve));
double NPV2 = cds2.NPV();
double tolerance = 1.0;
if (Math.Abs(NPV-NPV2) > tolerance) {
Assert.Fail("failed to reproduce NPV with implied rate\n"
+ " expected: " + NPV + "\n"
+ " calculated: " + NPV2);
}
}
}
public static Greeks GetOptionOnFutureGreeks(double underlyingPrice,double strike,double riskFreeRate,
DateTime expirationDate, DateTime calculationDate, string optionType, string exerciseType,
double optionPrice=double.NaN,double impliedVol=0.15,string engineName="baw")
{
QLNet.Date ExpirationDateObj = new QLNet.Date(expirationDate.Day, expirationDate.Month, expirationDate.Year);
QLNet.Date CalculationDateObj = new QLNet.Date(calculationDate.Day, calculationDate.Month, calculationDate.Year);
QLNet.DayCounter DayCountObj = new QLNet.Actual365Fixed();
QLNet.Calendar CalendarObj = new QLNet.UnitedStates();
Greeks GreeksOutput = new Greeks();
QLNet.Option.Type OptionTypeObj;
QLNet.Exercise ExerciseObj;
double ImpliedVol;
double OptionPrice;
int CalDte = DayCountObj.dayCount(CalculationDateObj, ExpirationDateObj);
GreeksOutput.CalDte = CalDte;
if (!double.IsNaN(optionPrice))
{
if (optionType.ToUpper() == "C")
{
if (optionPrice + strike - underlyingPrice <= 1.0e-12)
{
GreeksOutput.Delta = 1;
return GreeksOutput;
}
}
else if (optionType.ToUpper() == "P")
{
if (optionPrice - strike + underlyingPrice <= 1.0e-12)
{
GreeksOutput.Delta = -1;
return GreeksOutput;
}
}
}
if (CalDte == 0)
{
if (optionType.ToUpper() == "C")
{
if (strike <= underlyingPrice)
{
GreeksOutput.Delta = 1;
}
else
{
GreeksOutput.Delta = 0;
}
}
else if (optionType.ToUpper() == "P")
{
if (strike >= underlyingPrice)
{
GreeksOutput.Delta = -1;
}
else
{
GreeksOutput.Delta = 0;
}
}
return GreeksOutput;
}
if (optionType.ToUpper() == "C")
{
OptionTypeObj = QLNet.Option.Type.Call;
}
else if (optionType.ToUpper() == "P")
{
OptionTypeObj = QLNet.Option.Type.Put;
}
else
{
return GreeksOutput;
}
if (exerciseType.ToUpper() == "E")
{
ExerciseObj = new QLNet.EuropeanExercise(ExpirationDateObj);
}
else if (exerciseType.ToUpper() == "A")
{
ExerciseObj = new QLNet.AmericanExercise(CalculationDateObj, ExpirationDateObj);
}
else
{
return GreeksOutput;
}
QLNet.Settings.setEvaluationDate(CalculationDateObj);
QLNet.Handle<Quote> UnderlyingObj = new QLNet.Handle<Quote>(new QLNet.SimpleQuote(underlyingPrice));
QLNet.Handle<YieldTermStructure> FlatRateObj = new QLNet.Handle<YieldTermStructure>(new QLNet.FlatForward(CalculationDateObj, riskFreeRate, DayCountObj));
QLNet.Handle<BlackVolTermStructure> FlatVolTsObj = new QLNet.Handle<BlackVolTermStructure>(new QLNet.BlackConstantVol(CalculationDateObj, CalendarObj, impliedVol, DayCountObj));
QLNet.BlackProcess BlackProc = new QLNet.BlackProcess(UnderlyingObj, FlatRateObj, FlatVolTsObj);
QLNet.PlainVanillaPayoff PayoffObj = new QLNet.PlainVanillaPayoff(OptionTypeObj, strike);
QLNet.VanillaOption OptionObj = new QLNet.VanillaOption(PayoffObj, ExerciseObj);
if (engineName == "baw")
{
OptionObj.setPricingEngine(new QLNet.BaroneAdesiWhaleyApproximationEngine(BlackProc));
}
else if (engineName == "fda")
{
OptionObj.setPricingEngine(new QLNet.FDAmericanEngine(BlackProc, 100, 100));
}
else
{
return GreeksOutput;
}
if (!double.IsNaN(optionPrice))
{
try
{
ImpliedVol = OptionObj.impliedVolatility(targetValue:optionPrice, process:BlackProc,accuracy:1e-5);
}
catch
{
return GreeksOutput;
}
FlatVolTsObj = new QLNet.Handle<BlackVolTermStructure>(new QLNet.BlackConstantVol(CalculationDateObj, CalendarObj, ImpliedVol, DayCountObj));
BlackProc = new QLNet.BlackProcess(UnderlyingObj, FlatRateObj, FlatVolTsObj);
if (engineName == "baw")
{
OptionObj.setPricingEngine(new QLNet.BaroneAdesiWhaleyApproximationEngine(BlackProc));
}
else if (engineName == "fda")
{
OptionObj.setPricingEngine(new QLNet.FDAmericanEngine(BlackProc, 100, 100));
}
OptionPrice = optionPrice;
}
else
{
OptionPrice = OptionObj.NPV();
ImpliedVol = impliedVol;
}
OptionObj = new QLNet.VanillaOption(PayoffObj, new QLNet.EuropeanExercise(ExpirationDateObj));
OptionObj.setPricingEngine(new QLNet.AnalyticEuropeanEngine(BlackProc));
GreeksOutput.Delta = OptionObj.delta();
GreeksOutput.Vega = OptionObj.vega();
GreeksOutput.Theta = OptionObj.thetaPerDay();
GreeksOutput.Gamma = OptionObj.gamma();
GreeksOutput.OptionPrice = OptionPrice;
GreeksOutput.ImpliedVol = ImpliedVol;
return GreeksOutput;
}
public override void calculate(DateTime calcDate, FP_Parameter fp_parameter)
{
// master data load
this.indexOptionDAO_.SelectOwn();
// market data load
// index data
clsHDAT_MARKETDATA_TB clstb = new clsHDAT_MARKETDATA_TB();
string calcDateStr = calcDate.ToString("yyyyMMdd");
QLNet.Settings.setEvaluationDate(calcDate);
clstb.REF_DT = calcDateStr;
clstb.INDEX_CD = this.indexOptionDAO_.UNDERLYING_INDEX_CD;
int checkNum = clstb.SelectOwn();
if (checkNum == 0) { throw new Exception("market data does not exist : " + calcDateStr + " " + clstb.INDEX_CD); }
double indexData = clstb.LAST;
// curveData --------------------------------------------------
string curve_cd = "IRSKRW";
YieldCurve curveManager = new YieldCurve();
curveManager.loadCurveData(calcDate,curve_cd,clsHDAT_CURVEDATA_TB.RATE_TYP_Type.YTM);
QLNet.YieldTermStructure yield_ts = curveManager.yieldCurve();
// calculate
string maturityDateStr = this.indexOptionDAO_.MATURITY_DT;
System.Globalization.CultureInfo us
= new System.Globalization.CultureInfo("en-US");
DateTime maturityDate = DateTime.ParseExact(maturityDateStr, "yyyyMMdd", us);
DayCounter dc = new Actual365Fixed();
Calendar cal = new NullCalendar();
double vol = 0.3;
double strike = this.indexOptionDAO_.STRIKE;
PlainVanillaPayoff strikePayoff = new PlainVanillaPayoff(Option.Type.
Call, strike);
Exercise exercise = new EuropeanExercise(maturityDate);
VanillaOption q_option = new VanillaOption(strikePayoff,exercise);
Handle<Quote> x0 = new Handle<Quote>(new SimpleQuote(indexData));
FlatForward flatForward = new FlatForward(calcDate,0.01,dc);
Handle<YieldTermStructure> dividendTS = new Handle<YieldTermStructure>(flatForward);
Handle<YieldTermStructure> riskFreeTS = new Handle<YieldTermStructure>(yield_ts);
BlackConstantVol blackConstVol = new BlackConstantVol(calcDate,cal,vol,dc);
Handle<BlackVolTermStructure> blackVolTS = new Handle<BlackVolTermStructure>(blackConstVol);
GeneralizedBlackScholesProcess process =new GeneralizedBlackScholesProcess(x0 ,dividendTS,riskFreeTS,blackVolTS);
AnalyticEuropeanEngine europeanEngine = new AnalyticEuropeanEngine(process);
q_option.setPricingEngine(europeanEngine);
double value = q_option.NPV();
double indexMultiplier = this.indexOptionDAO_.INDEX_MULTIPLIER;
int quantity = this.indexOptionDAO_.QUANTITY;
clsHITM_FP_GREEKRESULT_TB result_tb = new clsHITM_FP_GREEKRESULT_TB();
result_tb.FP_GREEKRESULT_ID = IDGenerator.getNewGreekResultID(this.indexOptionDAO_.INSTRUMENT_ID,calcDateStr);
result_tb.CALC_DT = calcDateStr;
result_tb.INSTRUMENT_ID = this.indexOptionDAO_.INSTRUMENT_ID;
result_tb.INSTRUMENT_TYP = this.indexOptionDAO_.INSTRUMENT_TYP;
result_tb.UNDERLYING_ID = "KOSPI200";
result_tb.UNDERLYING_VALUE = indexData;
//result_tb.SEQ = 1;
result_tb.DELTA = (q_option.delta() * indexData / 100) * indexMultiplier * quantity; // 1% Delta
result_tb.GAMMA = 0.5 * (q_option.gamma() * indexData / 100) * indexMultiplier * quantity; // 1% Gamma
result_tb.VEGA = q_option.vega() / 100 * indexMultiplier * quantity; // 1% point Vega
result_tb.CALC_PRICE = value * indexMultiplier * quantity;
result_tb.CALCULATED_FLAG = (int)clsHITM_FP_GREEKRESULT_TB.CALCULATED_FLAG_Type.CALCULATED;
result_tb.CALCULATED_TIME = DateTime.Now.ToString("HHmmss"); ;
result_tb.CALCULATE_TYP = (int)clsHITM_FP_GREEKRESULT_TB.CALCULATE_TYP_Type.ANALYTICS;
// price
if (result_tb.UpdateDateResult() == 0)
{ throw new Exception("update result fail. no exist , calcDate : " + calcDate.ToString("yyyyMMdd") + " , inst_id : " + result_tb.INSTRUMENT_ID); }
// delta
// gamma and others : no exist ?
}
public YieldTermStructure buildQLNet_YieldTS(Excel_irCurveDataViewModel e_irCurveData)
{
QLNet.YieldTermStructure ql_yts = new YieldTermStructure();
List<QLNet.Date> dates = new List<QLNet.Date>();
List<double> yields = new List<double>();
foreach (var item in e_irCurveData.Excel_rateDataViewModelList_)
{
string tenor = item.Tenor_;
if (tenor.Substring(0, 1) == "D")
{
int addDays = Convert.ToInt32(tenor.Substring(1, 3));
dates.Add(ProgramVariable.ReferenceDate_.AddDays(addDays));
}
else if (tenor.Substring(0, 1) == "M")
{
int addMonths = Convert.ToInt32(tenor.Substring(1, 3));
dates.Add(ProgramVariable.ReferenceDate_.AddMonths(addMonths));
}
else
{
throw new Exception("unknown type tenor : " + tenor);
}
yields.Add(Convert.ToDouble(item.Value_));
}
QLNet.DayCounter dc = new QLNet.Actual365Fixed();
QLNet.InterpolatedZeroCurve<QLNet.Linear> curve = new QLNet.InterpolatedZeroCurve<QLNet.Linear>(
dates, yields, dc, new QLNet.Linear());
return ql_yts;
}
//static void Main(string[] args)
//{
// List<double> xGrid = Enumerable.Range(0, 100).Select(x => x / 10.0).ToList();
// List<double> yGrid = Enumerable.Range(0, 100).Select(x => x / 10.0).ToList();
// //List<double> xGrid = Enumerable.Range(0, 100);
// CubicInterpolation cubic = new CubicInterpolation(xGrid, xGrid.Count, yGrid,
// CubicInterpolation.DerivativeApprox.Kruger, true,
// CubicInterpolation.BoundaryCondition.SecondDerivative , 0.0,
// CubicInterpolation.BoundaryCondition.SecondDerivative , 0.0);
//}
static void Main(string[] args)
{
DateTime timer = DateTime.Now;
// set up dates
Calendar calendar = new TARGET();
Date todaysDate = new Date(15, Month.May, 1998);
Date settlementDate = new Date(17, Month.May, 1998);
Settings.setEvaluationDate(todaysDate);
// our options
Option.Type type = Option.Type.Put;
double underlying = 36;
double strike = 40;
double dividendYield = 0.00;
double riskFreeRate = 0.06;
double volatility = 0.20;
Date maturity = new Date(17, Month.May, 1999);
DayCounter dayCounter = new Actual365Fixed();
Console.WriteLine("Option type = " + type);
Console.WriteLine("Maturity = " + maturity);
Console.WriteLine("Underlying price = " + underlying);
Console.WriteLine("Strike = " + strike);
Console.WriteLine("Risk-free interest rate = {0:0.000000%}", riskFreeRate);
Console.WriteLine("Dividend yield = {0:0.000000%}", dividendYield);
Console.WriteLine("Volatility = {0:0.000000%}", volatility);
Console.Write("\n");
string method;
Console.Write("\n");
// write column headings
int[] widths = new int[] { 35, 14, 14, 14 };
Console.Write("{0,-" + widths[0] + "}", "Method");
Console.Write("{0,-" + widths[1] + "}", "European");
Console.Write("{0,-" + widths[2] + "}", "Bermudan");
Console.WriteLine("{0,-" + widths[3] + "}", "American");
List<Date> exerciseDates = new List<Date>(); ;
for (int i = 1; i <= 4; i++)
exerciseDates.Add(settlementDate + new Period(3 * i, TimeUnit.Months));
Exercise europeanExercise = new EuropeanExercise(maturity);
Exercise bermudanExercise = new BermudanExercise(exerciseDates);
Exercise americanExercise = new AmericanExercise(settlementDate, maturity);
Handle<Quote> underlyingH = new Handle<Quote>(new SimpleQuote(underlying));
// bootstrap the yield/dividend/vol curves
var flatTermStructure = new Handle<YieldTermStructure>(new FlatForward(settlementDate, riskFreeRate, dayCounter));
var flatDividendTS = new Handle<YieldTermStructure>(new FlatForward(settlementDate, dividendYield, dayCounter));
var flatVolTS = new Handle<BlackVolTermStructure>(new BlackConstantVol(settlementDate, calendar, volatility, dayCounter));
StrikedTypePayoff payoff = new PlainVanillaPayoff(type, strike);
var bsmProcess = new BlackScholesMertonProcess(underlyingH, flatDividendTS, flatTermStructure, flatVolTS);
// options
VanillaOption europeanOption = new VanillaOption(payoff, europeanExercise);
VanillaOption bermudanOption = new VanillaOption(payoff, bermudanExercise);
VanillaOption americanOption = new VanillaOption(payoff, americanExercise);
// Analytic formulas:
// Black-Scholes for European
method = "Black-Scholes";
europeanOption.setPricingEngine(new AnalyticEuropeanEngine(bsmProcess));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + "}", "N/A");
Console.WriteLine("{0,-" + widths[3] + "}", "N/A");
europeanOption.theta();
// Barone-Adesi and Whaley approximation for American
method = "Barone-Adesi/Whaley";
americanOption.setPricingEngine(new BaroneAdesiWhaleyApproximationEngine(bsmProcess));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + "}", "N/A");
Console.Write("{0,-" + widths[2] + "}", "N/A");
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", americanOption.NPV());
// Bjerksund and Stensland approximation for American
method = "Bjerksund/Stensland";
americanOption.setPricingEngine(new BjerksundStenslandApproximationEngine(bsmProcess));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + "}", "N/A");
Console.Write("{0,-" + widths[2] + "}", "N/A");
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", americanOption.NPV());
// Integral
method = "Integral";
europeanOption.setPricingEngine(new IntegralEngine(bsmProcess));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + "}", "N/A");
Console.WriteLine("{0,-" + widths[3] + "}", "N/A");
// Finite differences
int timeSteps = 801;
method = "Finite differences";
europeanOption.setPricingEngine(new FDEuropeanEngine(bsmProcess, timeSteps, timeSteps - 1));
bermudanOption.setPricingEngine(new FDBermudanEngine(bsmProcess, timeSteps, timeSteps - 1));
americanOption.setPricingEngine(new FDAmericanEngine(bsmProcess, timeSteps, timeSteps - 1));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + ":0.000000}", bermudanOption.NPV());
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", americanOption.NPV());
// Binomial method: Jarrow-Rudd
method = "Binomial Jarrow-Rudd";
europeanOption.setPricingEngine(new BinomialVanillaEngine<JarrowRudd>(bsmProcess, timeSteps));
bermudanOption.setPricingEngine(new BinomialVanillaEngine<JarrowRudd>(bsmProcess, timeSteps));
americanOption.setPricingEngine(new BinomialVanillaEngine<JarrowRudd>(bsmProcess, timeSteps));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + ":0.000000}", bermudanOption.NPV());
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", americanOption.NPV());
method = "Binomial Cox-Ross-Rubinstein";
europeanOption.setPricingEngine(new BinomialVanillaEngine<CoxRossRubinstein>(bsmProcess, timeSteps));
bermudanOption.setPricingEngine(new BinomialVanillaEngine<CoxRossRubinstein>(bsmProcess, timeSteps));
americanOption.setPricingEngine(new BinomialVanillaEngine<CoxRossRubinstein>(bsmProcess, timeSteps));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + ":0.000000}", bermudanOption.NPV());
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", americanOption.NPV());
// Binomial method: Additive equiprobabilities
method = "Additive equiprobabilities";
europeanOption.setPricingEngine(new BinomialVanillaEngine<AdditiveEQPBinomialTree>(bsmProcess, timeSteps));
bermudanOption.setPricingEngine(new BinomialVanillaEngine<AdditiveEQPBinomialTree>(bsmProcess, timeSteps));
americanOption.setPricingEngine(new BinomialVanillaEngine<AdditiveEQPBinomialTree>(bsmProcess, timeSteps));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + ":0.000000}", bermudanOption.NPV());
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", americanOption.NPV());
// Binomial method: Binomial Trigeorgis
method = "Binomial Trigeorgis";
europeanOption.setPricingEngine(new BinomialVanillaEngine<Trigeorgis>(bsmProcess, timeSteps));
bermudanOption.setPricingEngine(new BinomialVanillaEngine<Trigeorgis>(bsmProcess, timeSteps));
americanOption.setPricingEngine(new BinomialVanillaEngine<Trigeorgis>(bsmProcess, timeSteps));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + ":0.000000}", bermudanOption.NPV());
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", americanOption.NPV());
// Binomial method: Binomial Tian
method = "Binomial Tian";
europeanOption.setPricingEngine(new BinomialVanillaEngine<Tian>(bsmProcess, timeSteps));
bermudanOption.setPricingEngine(new BinomialVanillaEngine<Tian>(bsmProcess, timeSteps));
americanOption.setPricingEngine(new BinomialVanillaEngine<Tian>(bsmProcess, timeSteps));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + ":0.000000}", bermudanOption.NPV());
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", americanOption.NPV());
// Binomial method: Binomial Leisen-Reimer
method = "Binomial Leisen-Reimer";
europeanOption.setPricingEngine(new BinomialVanillaEngine<LeisenReimer>(bsmProcess, timeSteps));
bermudanOption.setPricingEngine(new BinomialVanillaEngine<LeisenReimer>(bsmProcess, timeSteps));
americanOption.setPricingEngine(new BinomialVanillaEngine<LeisenReimer>(bsmProcess, timeSteps));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + ":0.000000}", bermudanOption.NPV());
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", americanOption.NPV());
// Binomial method: Binomial Joshi
method = "Binomial Joshi";
europeanOption.setPricingEngine(new BinomialVanillaEngine<Joshi4>(bsmProcess, timeSteps));
bermudanOption.setPricingEngine(new BinomialVanillaEngine<Joshi4>(bsmProcess, timeSteps));
americanOption.setPricingEngine(new BinomialVanillaEngine<Joshi4>(bsmProcess, timeSteps));
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + ":0.000000}", bermudanOption.NPV());
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", americanOption.NPV());
// Monte Carlo Method: MC (crude)
timeSteps = 1;
method = "MC (crude)";
ulong mcSeed = 42;
IPricingEngine mcengine1 = new MakeMCEuropeanEngine<PseudoRandom>(bsmProcess)
.withSteps(timeSteps)
.withAbsoluteTolerance(0.02)
.withSeed(mcSeed)
.value();
europeanOption.setPricingEngine(mcengine1);
// Real errorEstimate = europeanOption.errorEstimate();
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + ":0.000000}", "N/A");
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", "N/A");
// Monte Carlo Method: QMC (Sobol)
method = "QMC (Sobol)";
int nSamples = 32768; // 2^15
IPricingEngine mcengine2 = new MakeMCEuropeanEngine<LowDiscrepancy>(bsmProcess)
.withSteps(timeSteps)
.withSamples(nSamples)
.value();
europeanOption.setPricingEngine(mcengine2);
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", europeanOption.NPV());
Console.Write("{0,-" + widths[2] + ":0.000000}", "N/A");
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", "N/A");
// Monte Carlo Method: MC (Longstaff Schwartz)
method = "MC (Longstaff Schwartz)";
IPricingEngine mcengine3 = new MakeMCAmericanEngine<PseudoRandom>(bsmProcess)
.withSteps(100)
.withAntitheticVariate()
.withCalibrationSamples(4096)
.withAbsoluteTolerance(0.02)
.withSeed(mcSeed)
.value();
americanOption.setPricingEngine(mcengine3);
Console.Write("{0,-" + widths[0] + "}", method);
Console.Write("{0,-" + widths[1] + ":0.000000}", "N/A");
Console.Write("{0,-" + widths[2] + ":0.000000}", "N/A");
Console.WriteLine("{0,-" + widths[3] + ":0.000000}", americanOption.NPV());
// End test
Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
Console.WriteLine();
Console.Write("Press any key to continue ...");
Console.ReadKey();
}
public void calculate(GBMParaViewModel para)
{
// set up dates
Calendar calendar = new TARGET();
//Date todaysDate = new Date(DateTime.Now);
Date settlementDate = new Date(para.ReferenceDate_);
Settings.setEvaluationDate(settlementDate);
// our options
Option.Type type = this.callPutEnum_;
double underlying = para.CurrentPrice_;
double strike = this.strike_;
double dividendYield = para.Dividend_ / 100;
double riskFreeRate = para.Drift_ / 100;
double volatility = 0.0;
if (this.callPutEnum_ == Option.Type.Call)
{
try
{
volatility = para.Call_Interpolation_.value(this.strike_) / 100;
this.imVolCal_ = Math.Round(para.Call_Interpolation_.value(this.strike_), 1);
}
catch (Exception)
{
volatility = para.Call_Interpolation_.value(this.strike_, true) / 100;
this.imVolCal_ = Math.Round(para.Call_Interpolation_.value(this.strike_,true), 1);
}
}
else if (this.callPutEnum_ == Option.Type.Put)
{
try
{
volatility = para.Call_Interpolation_.value(this.strike_) / 100;
this.imVolCal_ = Math.Round(para.Put_Interpolation_.value(this.strike_), 1);
}
catch (Exception)
{
volatility = para.Call_Interpolation_.value(this.strike_, true) / 100;
this.imVolCal_ = Math.Round(para.Put_Interpolation_.value(this.strike_,true), 1);
}
}
Date maturity = new Date(this.maturiry_);
DayCounter dayCounter = new Actual365Fixed();
//// write column headings
//int[] widths = new int[] { 35, 14, 14, 14 };
//Console.Write("{0,-" + widths[0] + "}", "Method");
//Console.Write("{0,-" + widths[1] + "}", "European");
//Console.Write("{0,-" + widths[2] + "}", "Bermudan");
//Console.WriteLine("{0,-" + widths[3] + "}", "American");
//List<Date> exerciseDates = new List<Date>(); ;
//for (int i = 1; i <= 4; i++)
// exerciseDates.Add(settlementDate + new Period(3 * i, TimeUnit.Months));
Exercise europeanExercise = new EuropeanExercise(maturity);
//Exercise bermudanExercise = new BermudanExercise(exerciseDates);
//Exercise americanExercise = new AmericanExercise(settlementDate, maturity);
Handle<Quote> underlyingH = new Handle<Quote>(new SimpleQuote(underlying));
// bootstrap the yield/dividend/vol curves
var flatTermStructure = new Handle<YieldTermStructure>(new FlatForward(settlementDate, riskFreeRate, dayCounter));
var flatDividendTS = new Handle<YieldTermStructure>(new FlatForward(settlementDate, dividendYield, dayCounter));
var flatVolTS = new Handle<BlackVolTermStructure>(new BlackConstantVol(settlementDate, calendar, volatility, dayCounter));
StrikedTypePayoff payoff = new PlainVanillaPayoff(type, strike);
var bsmProcess = new BlackScholesMertonProcess(underlyingH, flatDividendTS, flatTermStructure, flatVolTS);
// options
VanillaOption europeanOption = new VanillaOption(payoff, europeanExercise);
// Analytic formulas:
// Black-Scholes for European
europeanOption.setPricingEngine(new AnalyticEuropeanEngine(bsmProcess));
this.npv_ = Math.Round(europeanOption.NPV(),6);
this.deltaCal_ = Math.Round(europeanOption.delta(),6);
this.gammaCal_= Math.Round(europeanOption.gamma(),6);
this.vegaCal_ = Math.Round(europeanOption.vega()/ 100, 6);
this.thetaCal_= Math.Round(europeanOption.theta()/ 365,6) ;
this.rhoCal_ = Math.Round(europeanOption.rho() / 100, 6);
}
public void calculate(double[] p, GBMParaViewModel para)
{
this.xData_ = p;
this.yData_ = new double[p.Length];
double sellBuySign = 1.0;
if (this.sellBuy_ == "매도")
{
sellBuySign = -1.0;
}
else
{
}
// set up dates
Calendar calendar = new TARGET();
//Date todaysDate = new Date(DateTime.Now);
Date settlementDate = new Date(para.ReferenceDate_);
Settings.setEvaluationDate(settlementDate);
// our options
Option.Type type = this.callPutEnum_;
double underlying = para.CurrentPrice_;
double strike = this.strike_;
double dividendYield = para.Dividend_ / 100;
double riskFreeRate = para.Drift_ / 100;
if (this.callPutEnum_ == Option.Type.Call)
{
this.imVol_ = para.Call_Interpolation_.value(this.strike_);
}
else if (this.callPutEnum_ == Option.Type.Put)
{
this.imVol_ = para.Put_Interpolation_.value(this.strike_);
}
double volatility = (this.imVol_ ) / 100;
Date maturity = new Date(this.maturiry_.AddDays(1));
if (this.callPutEnum_ == 0)
{
this.deltaCal_ = 1.0;
this.gammaCal_ = 0.0;
this.vegaCal_ = 0.0;
this.thetaCal_ = 0.0;
this.rhoCal_ = 0.0;
this.deltaPosition_ = sellBuySign * this.unit_ * 500000 * underlying;
this.deltaRisk_ = this.deltaPosition_ * 0.09;
this.gammaRisk_ = 0.0;
this.vegaRisk_ = 0.0;
this.totalRisk_ = this.deltaRisk_ + this.gammaRisk_ + this.vegaRisk_;
this.deepOTM_ = 0.0;
//this.remainDays_ = maturity - settlementDate;
this.remainDays_ = (this.maturiry_ - para.ReferenceDate_).Days + 1;
return;
}
DayCounter dayCounter = new Actual365Fixed();
Exercise europeanExercise = new EuropeanExercise(maturity);
SimpleQuote quote = new SimpleQuote(underlying);
Handle<Quote> underlyingH = new Handle<Quote>(quote);
// bootstrap the yield/dividend/vol curves
var flatTermStructure = new Handle<YieldTermStructure>(new FlatForward(settlementDate, riskFreeRate, dayCounter));
var flatDividendTS = new Handle<YieldTermStructure>(new FlatForward(settlementDate, dividendYield, dayCounter));
var flatVolTS = new Handle<BlackVolTermStructure>(new BlackConstantVol(settlementDate, calendar, volatility, dayCounter));
StrikedTypePayoff payoff = new PlainVanillaPayoff(type, strike);
var bsmProcess = new BlackScholesMertonProcess(underlyingH, flatDividendTS, flatTermStructure, flatVolTS);
// options
VanillaOption europeanOption = new VanillaOption(payoff, europeanExercise);
// Analytic formulas:
// Black-Scholes for European
europeanOption.setPricingEngine(new AnalyticEuropeanEngine(bsmProcess));
this.npv_ = Math.Round(europeanOption.NPV(), 6);
this.deltaCal_ = sellBuySign * Math.Round(europeanOption.delta(), 6);
this.gammaCal_ = sellBuySign * Math.Round(europeanOption.gamma(), 6);
this.vegaCal_ = sellBuySign * Math.Round(europeanOption.vega() / 100, 6);
this.thetaCal_ = sellBuySign * Math.Round(europeanOption.theta() / 365, 6);
this.rhoCal_ = sellBuySign * Math.Round(europeanOption.rho() / 100, 6);
this.deltaPosition_ = Math.Round(this.deltaCal_ * this.unit_ * 500000 * underlying,0);
this.deltaRisk_ = Math.Round(this.deltaPosition_ * 0.09,0);
this.gammaRisk_ = Math.Round(0.5 * this.gammaCal_ * (underlying * underlying * 0.08 * 0.08) * this.unit_ * 500000, 0);
this.vegaRisk_ = Math.Round(this.vegaCal_ * this.imVol_ * 0.25 * this.unit_ * 500000, 0);
this.totalRisk_ = this.deltaRisk_ + this.gammaRisk_ + this.vegaRisk_;
this.deepOTM_ = 0.0;
//this.remainDays_ = maturity - settlementDate;
this.remainDays_ = (this.maturiry_ - para.ReferenceDate_).Days + 1;
for (int i = 0; i < this.xData_.Length; i++)
{
quote.setValue(this.xData_[i]);
this.yData_[i] = 500000.0 * (double)this.unit_ * europeanOption.NPV();
}
}
