public HazardRateCurve(DateVector dates, DoubleVector hazardRates, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_HazardRateCurve__SWIG_2(DateVector.getCPtr(dates), DoubleVector.getCPtr(hazardRates), DayCounter.getCPtr(dayCounter)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public SwaptionVolatilityMatrix(Date referenceDate, DateVector dates, PeriodVector lengths, Matrix vols, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_SwaptionVolatilityMatrix__SWIG_3(Date.getCPtr(referenceDate), DateVector.getCPtr(dates), PeriodVector.getCPtr(lengths), Matrix.getCPtr(vols), DayCounter.getCPtr(dayCounter)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public MonotonicCubicZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar) : this(NQuantLibcPINVOKE.new_MonotonicCubicZeroCurve__SWIG_3(DateVector.getCPtr(dates), DoubleVector.getCPtr(yields), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public ForwardFlatZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_ForwardFlatZeroCurve__SWIG_4(DateVector.getCPtr(dates), DoubleVector.getCPtr(yields), DayCounter.getCPtr(dayCounter)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public ForwardFlatZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar, ForwardFlat i, Compounding compounding) : this(NQuantLibcPINVOKE.new_ForwardFlatZeroCurve__SWIG_1(DateVector.getCPtr(dates), DoubleVector.getCPtr(yields), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar), ForwardFlat.getCPtr(i), (int)compounding), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public LinearDiscountCurve(DateVector dates, DoubleVector discounts, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_LinearDiscountCurve__SWIG_2(DateVector.getCPtr(dates), DoubleVector.getCPtr(discounts), DayCounter.getCPtr(dayCounter)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public CommodityCurveExt(string name, DateVector dates, DoubleVector prices, Calendar calendar, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_CommodityCurveExt(name, DateVector.getCPtr(dates), DoubleVector.getCPtr(prices), Calendar.getCPtr(calendar), DayCounter.getCPtr(dayCounter)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public BackwardFlatZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar, BackwardFlat i) : this(NQuantLibcPINVOKE.new_BackwardFlatZeroCurve__SWIG_2(DateVector.getCPtr(dates), DoubleVector.getCPtr(yields), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar), BackwardFlat.getCPtr(i)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public ForwardCurve(DateVector dates, DoubleVector forwards, DayCounter dayCounter, Calendar calendar) : this(NQuantLibcPINVOKE.new_ForwardCurve__SWIG_1(DateVector.getCPtr(dates), DoubleVector.getCPtr(forwards), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public DefaultDensityCurve(DateVector dates, DoubleVector densities, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_DefaultDensityCurve__SWIG_2(DateVector.getCPtr(dates), DoubleVector.getCPtr(densities), DayCounter.getCPtr(dayCounter)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public TimeBasket(DateVector arg0, DoubleVector arg1) : this(NQuantLibcPINVOKE.new_TimeBasket__SWIG_1(DateVector.getCPtr(arg0), DoubleVector.getCPtr(arg1)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public DateVectorEnumerator(DateVector collection)
{
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
public DateVector(DateVector other) : this(NQuantLibcPINVOKE.new_DateVector__SWIG_1(DateVector.getCPtr(other)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public SwaptionVolatilityMatrix(Date referenceDate, DateVector dates, PeriodVector lengths, Matrix vols, DayCounter dayCounter, bool flatExtrapolation, VolatilityType type, Matrix shifts) : this(NQuantLibcPINVOKE.new_SwaptionVolatilityMatrix__SWIG_0(Date.getCPtr(referenceDate), DateVector.getCPtr(dates), PeriodVector.getCPtr(lengths), Matrix.getCPtr(vols), DayCounter.getCPtr(dayCounter), flatExtrapolation, (int)type, Matrix.getCPtr(shifts)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public BermudanExercise(DateVector dates) : this(NQuantLibcPINVOKE.new_BermudanExercise__SWIG_1(DateVector.getCPtr(dates)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public LogCubicZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar, DefaultLogCubic i) : this(NQuantLibcPINVOKE.new_LogCubicZeroCurve__SWIG_2(DateVector.getCPtr(dates), DoubleVector.getCPtr(yields), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar), DefaultLogCubic.getCPtr(i)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public BlackVarianceCurve(Date referenceDate, DateVector dates, DoubleVector volatilities, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_BlackVarianceCurve__SWIG_1(Date.getCPtr(referenceDate), DateVector.getCPtr(dates), DoubleVector.getCPtr(volatilities), DayCounter.getCPtr(dayCounter)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public Schedule(DateVector arg0) : this(NQuantLibcPINVOKE.new_Schedule__SWIG_2(DateVector.getCPtr(arg0)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public BlackVarianceSurface(Date referenceDate, Calendar cal, DateVector dates, DoubleVector strikes, Matrix blackVols, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_BlackVarianceSurface__SWIG_3(Date.getCPtr(referenceDate), Calendar.getCPtr(cal), DateVector.getCPtr(dates), DoubleVector.getCPtr(strikes), Matrix.getCPtr(blackVols), DayCounter.getCPtr(dayCounter)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public SurvivalProbabilityCurve(DateVector dates, DoubleVector probabilities, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_SurvivalProbabilityCurve__SWIG_2(DateVector.getCPtr(dates), DoubleVector.getCPtr(probabilities), DayCounter.getCPtr(dayCounter)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public MonotonicCubicZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar, MonotonicCubic i, Compounding compounding, Frequency frequency) : this(NQuantLibcPINVOKE.new_MonotonicCubicZeroCurve__SWIG_0(DateVector.getCPtr(dates), DoubleVector.getCPtr(yields), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar), MonotonicCubic.getCPtr(i), (int)compounding, (int)frequency), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public IntervalPriceTimeSeries(DateVector d, IntervalPriceVector v) : this(NQuantLibcPINVOKE.new_IntervalPriceTimeSeries__SWIG_1(DateVector.getCPtr(d), IntervalPriceVector.getCPtr(v)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public Gsr(YieldTermStructureHandle termStructure, DateVector volstepdates, QuoteHandleVector volatilities, QuoteHandleVector reversions) : this(NQuantLibcPINVOKE.new_Gsr__SWIG_1(YieldTermStructureHandle.getCPtr(termStructure), DateVector.getCPtr(volstepdates), QuoteHandleVector.getCPtr(volatilities), QuoteHandleVector.getCPtr(reversions)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public RealTimeSeries(DateVector d, DoubleVector v) : this(NQuantLibcPINVOKE.new_RealTimeSeries__SWIG_1(DateVector.getCPtr(d), DoubleVector.getCPtr(v)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public HimalayaOption(DateVector fixingDates, double strike) : this(NQuantLibcPINVOKE.new_HimalayaOption(DateVector.getCPtr(fixingDates), strike), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public DiscountCurve(DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar, LogLinear i) : this(NQuantLibcPINVOKE.new_DiscountCurve__SWIG_0(DateVector.getCPtr(dates), DoubleVector.getCPtr(discounts), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar), LogLinear.getCPtr(i)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public Schedule(DateVector arg0, Calendar calendar, BusinessDayConvention convention) : this(NQuantLibcPINVOKE.new_Schedule__SWIG_0(DateVector.getCPtr(arg0), Calendar.getCPtr(calendar), (int)convention), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public DividendVanillaOption(Payoff payoff, Exercise exercise, DateVector dividendDates, DoubleVector dividends) : this(NQuantLibcPINVOKE.new_DividendVanillaOption(Payoff.getCPtr(payoff), Exercise.getCPtr(exercise), DateVector.getCPtr(dividendDates), DoubleVector.getCPtr(dividends)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public void addFixings(DateVector fixingDates, DoubleVector fixings)
{
NQuantLibcPINVOKE.Index_addFixings(swigCPtr, DateVector.getCPtr(fixingDates), DoubleVector.getCPtr(fixings));
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public void SetRange(int index, DateVector values)
{
NQuantLibcPINVOKE.DateVector_SetRange(swigCPtr, index, DateVector.getCPtr(values));
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
static void Main(string[] args)
{
DateTime startTime = DateTime.Now;
Option.Type optionType = Option.Type.Put;
double underlyingPrice = 36;
double strikePrice = 40;
double dividendYield = 0.0;
double riskFreeRate = 0.06;
double volatility = 0.2;
Date todaysDate = new Date(15, Month.May, 1998);
Settings.instance().setEvaluationDate(todaysDate);
Date settlementDate = new Date(17, Month.May, 1998);
Date maturityDate = new Date(17, Month.May, 1999);
Calendar calendar = new TARGET();
DateVector exerciseDates = new DateVector(4);
for (int i = 1; i <= 4; i++) {
Period forwardPeriod = new Period(3 * i, TimeUnit.Months);
Date forwardDate = settlementDate.Add(forwardPeriod);
exerciseDates.Add(forwardDate);
}
EuropeanExercise europeanExercise =
new EuropeanExercise(maturityDate);
BermudanExercise bermudanExercise =
new BermudanExercise(exerciseDates);
AmericanExercise americanExercise =
new AmericanExercise(settlementDate, maturityDate);
// bootstrap the yield/dividend/vol curves and create a
// BlackScholesMerton stochastic process
DayCounter dayCounter = new Actual365Fixed();
YieldTermStructureHandle flatRateTSH =
new YieldTermStructureHandle(
new FlatForward(settlementDate, riskFreeRate,
dayCounter));
YieldTermStructureHandle flatDividendTSH =
new YieldTermStructureHandle(
new FlatForward(settlementDate, dividendYield,
dayCounter));
BlackVolTermStructureHandle flatVolTSH =
new BlackVolTermStructureHandle(
new BlackConstantVol(settlementDate, calendar,
volatility, dayCounter));
QuoteHandle underlyingQuoteH =
new QuoteHandle(new SimpleQuote(underlyingPrice));
BlackScholesMertonProcess stochasticProcess =
new BlackScholesMertonProcess(underlyingQuoteH,
flatDividendTSH,
flatRateTSH,
flatVolTSH);
PlainVanillaPayoff payoff =
new PlainVanillaPayoff(optionType, strikePrice);
// options
VanillaOption europeanOption =
new VanillaOption(payoff, europeanExercise);
VanillaOption bermudanOption =
new VanillaOption(payoff, bermudanExercise);
VanillaOption americanOption =
new VanillaOption(payoff, americanExercise);
// report the parameters we are using
ReportParameters(optionType, underlyingPrice, strikePrice,
dividendYield, riskFreeRate,
volatility, maturityDate);
// write out the column headings
ReportHeadings();
#region Analytic Formulas
// Black-Scholes for European
try {
europeanOption.setPricingEngine(
new AnalyticEuropeanEngine(stochasticProcess));
ReportResults("Black-Scholes",
europeanOption.NPV(), null, null);
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
// Barone-Adesi and Whaley approximation for American
try {
americanOption.setPricingEngine(
new BaroneAdesiWhaleyEngine(stochasticProcess));
ReportResults("Barone-Adesi/Whaley",
null, null, americanOption.NPV());
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
// Bjerksund and Stensland approximation for American
try {
americanOption.setPricingEngine(
new BjerksundStenslandEngine(stochasticProcess));
ReportResults("Bjerksund/Stensland",
null, null, americanOption.NPV());
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
// Integral
try {
europeanOption.setPricingEngine(
new IntegralEngine(stochasticProcess));
ReportResults("Integral",
europeanOption.NPV(), null, null);
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
uint timeSteps = 801;
// Finite differences
try {
europeanOption.setPricingEngine(
new FDEuropeanEngine(stochasticProcess,
timeSteps, timeSteps - 1));
bermudanOption.setPricingEngine(
new FDBermudanEngine(stochasticProcess,
timeSteps, timeSteps - 1));
americanOption.setPricingEngine(
new FDAmericanEngine(stochasticProcess,
timeSteps, timeSteps - 1));
ReportResults("Finite differences",
europeanOption.NPV(),
bermudanOption.NPV(),
americanOption.NPV());
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
#endregion Analytic Formulas
#region Binomial Methods
// Binomial Jarrow-Rudd
try {
europeanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"jarrowrudd", timeSteps));
bermudanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"jarrowrudd", timeSteps));
americanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"jarrowrudd", timeSteps));
ReportResults("Binomial Jarrow-Rudd",
europeanOption.NPV(),
bermudanOption.NPV(),
americanOption.NPV());
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
// Binomial Cox-Ross-Rubinstein
try {
europeanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"coxrossrubinstein", timeSteps));
bermudanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"coxrossrubinstein", timeSteps));
americanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"coxrossrubinstein", timeSteps));
ReportResults("Binomial Cox-Ross-Rubinstein",
europeanOption.NPV(),
bermudanOption.NPV(),
americanOption.NPV());
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
// Additive Equiprobabilities
try {
europeanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"eqp", timeSteps));
bermudanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"eqp", timeSteps));
americanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"eqp", timeSteps));
ReportResults("Additive Equiprobabilities",
europeanOption.NPV(),
bermudanOption.NPV(),
americanOption.NPV());
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
// Binomial Trigeorgis
try {
europeanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"trigeorgis", timeSteps));
bermudanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"trigeorgis", timeSteps));
americanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"trigeorgis", timeSteps));
ReportResults("Binomial Trigeorgis",
europeanOption.NPV(),
bermudanOption.NPV(),
americanOption.NPV());
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
// Binomial Tian
try {
europeanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"tian", timeSteps));
bermudanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"tian", timeSteps));
americanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"tian", timeSteps));
ReportResults("Binomial Tian",
europeanOption.NPV(),
bermudanOption.NPV(),
americanOption.NPV());
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
// Binomial Leisen-Reimer
try {
europeanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"leisenreimer", timeSteps));
bermudanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"leisenreimer", timeSteps));
americanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"leisenreimer", timeSteps));
ReportResults("Binomial Leisen-Reimer",
europeanOption.NPV(),
bermudanOption.NPV(),
americanOption.NPV());
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
// Binomial Joshi
try {
europeanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"joshi4", timeSteps));
bermudanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"joshi4", timeSteps));
americanOption.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess,
"joshi4", timeSteps));
ReportResults("Binomial Joshi",
europeanOption.NPV(),
bermudanOption.NPV(),
americanOption.NPV());
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
#endregion Binomial Methods
#region Monte Carlo Methods
// quantlib appears to use max numeric (int and real) values to test for 'null' (or rather 'default') values
// MC (crude)
try {
string traits = "pseudorandom";
int mcTimeSteps = 1;
int timeStepsPerYear = int.MaxValue;
bool brownianBridge = false;
bool antitheticVariate = false;
int requiredSamples = int.MaxValue;
double requiredTolerance = 0.02;
int maxSamples = int.MaxValue;
int seed = 42;
europeanOption.setPricingEngine(
new MCEuropeanEngine(stochasticProcess,
traits, mcTimeSteps,
timeStepsPerYear,
brownianBridge,
antitheticVariate,
requiredSamples,
requiredTolerance,
maxSamples, seed));
ReportResults("MC (crude)", europeanOption.NPV(), null, null);
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
// MC (Sobol)
try {
string traits = "lowdiscrepancy";
int mcTimeSteps = 1;
int timeStepsPerYear = int.MaxValue;
bool brownianBridge = false;
bool antitheticVariate = false;
int requiredSamples = 32768; // 2^15
double requiredTolerance = double.MaxValue;
int maxSamples = int.MaxValue;
int seed = 0;
europeanOption.setPricingEngine(
new MCEuropeanEngine(stochasticProcess,
traits, mcTimeSteps,
timeStepsPerYear,
brownianBridge,
antitheticVariate,
requiredSamples,
requiredTolerance, maxSamples, seed));
ReportResults("MC (Sobol)", europeanOption.NPV(), null, null);
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
// MC (Longstaff Schwartz)
/*
try {
// MCAmericanEngine is not currently exposed in SWIG
//americanOption.setPricingEngine(new MCAmericanEngine());
ReportResults("MC (Longstaff Schwartz)", null, null, null);
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
*/
#endregion Monte Carlo Methods
DateTime endTime = DateTime.Now;
TimeSpan delta = endTime - startTime;
Console.WriteLine();
Console.WriteLine("Run completed in {0} s", delta.TotalSeconds);
Console.WriteLine();
}
public BlackVarianceCurve(Date referenceDate, DateVector dates, DoubleVector volatilities, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_BlackVarianceCurve__SWIG_1(Date.getCPtr(referenceDate), DateVector.getCPtr(dates), DoubleVector.getCPtr(volatilities), DayCounter.getCPtr(dayCounter)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public SwaptionVolatilityMatrix(Date referenceDate, DateVector dates, PeriodVector lengths, Matrix vols, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_SwaptionVolatilityMatrix__SWIG_0(Date.getCPtr(referenceDate), DateVector.getCPtr(dates), PeriodVector.getCPtr(lengths), Matrix.getCPtr(vols), DayCounter.getCPtr(dayCounter)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public ForwardCurve(DateVector dates, DoubleVector forwards, DayCounter dayCounter, Calendar calendar) : this(NQuantLibcPINVOKE.new_ForwardCurve__SWIG_1(DateVector.getCPtr(dates), DoubleVector.getCPtr(forwards), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public TimeBasket rebin(DateVector arg0) {
TimeBasket ret = new TimeBasket(NQuantLibcPINVOKE.TimeBasket_rebin(swigCPtr, DateVector.getCPtr(arg0)), true);
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public DefaultDensityCurve(DateVector dates, DoubleVector densities, DayCounter dayCounter, Calendar calendar) : this(NQuantLibcPINVOKE.new_DefaultDensityCurve__SWIG_1(DateVector.getCPtr(dates), DoubleVector.getCPtr(densities), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public HimalayaOption(DateVector fixingDates, double strike) : this(NQuantLibcPINVOKE.new_HimalayaOption(DateVector.getCPtr(fixingDates), strike), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public Schedule(DateVector arg0, Calendar calendar, BusinessDayConvention rollingConvention) : this(NQuantLibcPINVOKE.new_Schedule__SWIG_0(DateVector.getCPtr(arg0), Calendar.getCPtr(calendar), (int)rollingConvention), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public ZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar, Linear i, Compounding compounding) : this(NQuantLibcPINVOKE.new_ZeroCurve__SWIG_1(DateVector.getCPtr(dates), DoubleVector.getCPtr(yields), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar), Linear.getCPtr(i), (int)compounding), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public PiecewiseLinearZero(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps, DateVector jumpDates, double accuracy) : this(NQuantLibcPINVOKE.new_PiecewiseLinearZero__SWIG_1(Date.getCPtr(referenceDate), RateHelperVector.getCPtr(instruments), DayCounter.getCPtr(dayCounter), QuoteHandleVector.getCPtr(jumps), DateVector.getCPtr(jumpDates), accuracy), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public static IntervalPriceTimeSeries makeSeries(DateVector d, DoubleVector open, DoubleVector close, DoubleVector high, DoubleVector low) {
IntervalPriceTimeSeries ret = new IntervalPriceTimeSeries(NQuantLibcPINVOKE.IntervalPrice_makeSeries(DateVector.getCPtr(d), DoubleVector.getCPtr(open), DoubleVector.getCPtr(close), DoubleVector.getCPtr(high), DoubleVector.getCPtr(low)), true);
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public PiecewiseLinearZero(int settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps, DateVector jumpDates, double accuracy) : this(NQuantLibcPINVOKE.new_PiecewiseLinearZero__SWIG_6(settlementDays, Calendar.getCPtr(calendar), RateHelperVector.getCPtr(instruments), DayCounter.getCPtr(dayCounter), QuoteHandleVector.getCPtr(jumps), DateVector.getCPtr(jumpDates), accuracy), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public SpreadedLinearZeroInterpolatedTermStructure(YieldTermStructureHandle curveHandle, QuoteHandleVector spreadHandles, DateVector dates) : this(NQuantLibcPINVOKE.new_SpreadedLinearZeroInterpolatedTermStructure(YieldTermStructureHandle.getCPtr(curveHandle), QuoteHandleVector.getCPtr(spreadHandles), DateVector.getCPtr(dates)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public BlackVarianceSurface(Date referenceDate, Calendar cal, DateVector dates, DoubleVector strikes, Matrix blackVols, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_BlackVarianceSurface__SWIG_3(Date.getCPtr(referenceDate), Calendar.getCPtr(cal), DateVector.getCPtr(dates), DoubleVector.getCPtr(strikes), Matrix.getCPtr(blackVols), DayCounter.getCPtr(dayCounter)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public DateVector dates() {
DateVector ret = new DateVector(NQuantLibcPINVOKE.RealTimeSeries_dates(swigCPtr), true);
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_ZeroCurve__SWIG_4(DateVector.getCPtr(dates), DoubleVector.getCPtr(yields), DayCounter.getCPtr(dayCounter)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public RealTimeSeries(DateVector d, DoubleVector v) : this(NQuantLibcPINVOKE.new_RealTimeSeries__SWIG_1(DateVector.getCPtr(d), DoubleVector.getCPtr(v)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public void addFixings(DateVector fixingDates, DoubleVector fixings) {
NQuantLibcPINVOKE.Index_addFixings(swigCPtr, DateVector.getCPtr(fixingDates), DoubleVector.getCPtr(fixings));
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public DividendVanillaOption(Payoff payoff, Exercise exercise, DateVector dividendDates, DoubleVector dividends) : this(NQuantLibcPINVOKE.new_DividendVanillaOption(Payoff.getCPtr(payoff), Exercise.getCPtr(exercise), DateVector.getCPtr(dividendDates), DoubleVector.getCPtr(dividends)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public TimeBasket(DateVector arg0, DoubleVector arg1) : this(NQuantLibcPINVOKE.new_TimeBasket__SWIG_1(DateVector.getCPtr(arg0), DoubleVector.getCPtr(arg1)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public HazardRateCurve(DateVector dates, DoubleVector hazardRates, DayCounter dayCounter, Calendar calendar, BackwardFlat i) : this(NQuantLibcPINVOKE.new_HazardRateCurve__SWIG_0(DateVector.getCPtr(dates), DoubleVector.getCPtr(hazardRates), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar), BackwardFlat.getCPtr(i)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public DiscreteAveragingAsianOption(Average.Type averageType, double runningAccumulator, uint pastFixings, DateVector fixingDates, Payoff payoff, Exercise exercise) : this(NQuantLibcPINVOKE.new_DiscreteAveragingAsianOption((int)averageType, runningAccumulator, pastFixings, DateVector.getCPtr(fixingDates), Payoff.getCPtr(payoff), Exercise.getCPtr(exercise)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public DateVector dates() {
DateVector ret = new DateVector(NQuantLibcPINVOKE.DiscountCurve_dates(swigCPtr), false);
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public DiscountCurve(DateVector dates, DoubleVector discounts, DayCounter dayCounter) : this(NQuantLibcPINVOKE.new_DiscountCurve__SWIG_2(DateVector.getCPtr(dates), DoubleVector.getCPtr(discounts), DayCounter.getCPtr(dayCounter)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public BermudanExercise(DateVector dates) : this(NQuantLibcPINVOKE.new_BermudanExercise__SWIG_1(DateVector.getCPtr(dates)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public DiscountCurve(DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar, LogLinear i) : this(NQuantLibcPINVOKE.new_DiscountCurve__SWIG_0(DateVector.getCPtr(dates), DoubleVector.getCPtr(discounts), DayCounter.getCPtr(dayCounter), Calendar.getCPtr(calendar), LogLinear.getCPtr(i)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public DateVector dates() {
DateVector ret = new DateVector(NQuantLibcPINVOKE.PiecewiseFlatForward_dates(swigCPtr), false);
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public PiecewiseFlatForward(int settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps, DateVector jumpDates) : this(NQuantLibcPINVOKE.new_PiecewiseFlatForward__SWIG_7(settlementDays, Calendar.getCPtr(calendar), RateHelperVector.getCPtr(instruments), DayCounter.getCPtr(dayCounter), QuoteHandleVector.getCPtr(jumps), DateVector.getCPtr(jumpDates)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
public PiecewiseFlatForward(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps, DateVector jumpDates) : this(NQuantLibcPINVOKE.new_PiecewiseFlatForward__SWIG_2(Date.getCPtr(referenceDate), RateHelperVector.getCPtr(instruments), DayCounter.getCPtr(dayCounter), QuoteHandleVector.getCPtr(jumps), DateVector.getCPtr(jumpDates)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
static void Main(string[] args)
{
DateTime startTime = DateTime.Now;
Date todaysDate = new Date(15, Month.February, 2002);
Calendar calendar = new TARGET();
Date settlementDate = new Date(19, Month.February, 2002);
Settings.instance().setEvaluationDate( todaysDate );
// flat yield term structure impling 1x5 swap at 5%
Quote flatRate = new SimpleQuote(0.04875825);
FlatForward myTermStructure = new FlatForward(
settlementDate,
new QuoteHandle( flatRate ),
new Actual365Fixed() );
RelinkableYieldTermStructureHandle rhTermStructure =
new RelinkableYieldTermStructureHandle();
rhTermStructure.linkTo( myTermStructure );
// Define the ATM/OTM/ITM swaps
Period fixedLegTenor = new Period(1,TimeUnit.Years);
BusinessDayConvention fixedLegConvention =
BusinessDayConvention.Unadjusted;
BusinessDayConvention floatingLegConvention =
BusinessDayConvention.ModifiedFollowing;
DayCounter fixedLegDayCounter =
new Thirty360( Thirty360.Convention.European );
Period floatingLegTenor = new Period(6,TimeUnit.Months);
double dummyFixedRate = 0.03;
IborIndex indexSixMonths = new Euribor6M( rhTermStructure );
Date startDate = calendar.advance(settlementDate,1,TimeUnit.Years,
floatingLegConvention);
Date maturity = calendar.advance(startDate,5,TimeUnit.Years,
floatingLegConvention);
Schedule fixedSchedule = new Schedule(startDate,maturity,
fixedLegTenor,calendar,fixedLegConvention,fixedLegConvention,
DateGeneration.Rule.Forward,false);
Schedule floatSchedule = new Schedule(startDate,maturity,
floatingLegTenor,calendar,floatingLegConvention,
floatingLegConvention,DateGeneration.Rule.Forward,false);
VanillaSwap swap = new VanillaSwap(
VanillaSwap.Payer, 1000.0,
fixedSchedule, dummyFixedRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
DiscountingSwapEngine swapEngine =
new DiscountingSwapEngine(rhTermStructure);
swap.setPricingEngine(swapEngine);
double fixedATMRate = swap.fairRate();
double fixedOTMRate = fixedATMRate * 1.2;
double fixedITMRate = fixedATMRate * 0.8;
VanillaSwap atmSwap = new VanillaSwap(
VanillaSwap.Payer, 1000.0,
fixedSchedule, fixedATMRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter() );
VanillaSwap otmSwap = new VanillaSwap(
VanillaSwap.Payer, 1000.0,
fixedSchedule, fixedOTMRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
VanillaSwap itmSwap = new VanillaSwap(
VanillaSwap.Payer, 1000.0,
fixedSchedule, fixedITMRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
atmSwap.setPricingEngine(swapEngine);
otmSwap.setPricingEngine(swapEngine);
itmSwap.setPricingEngine(swapEngine);
// defining the swaptions to be used in model calibration
PeriodVector swaptionMaturities = new PeriodVector();
swaptionMaturities.Add( new Period(1, TimeUnit.Years) );
swaptionMaturities.Add( new Period(2, TimeUnit.Years) );
swaptionMaturities.Add( new Period(3, TimeUnit.Years) );
swaptionMaturities.Add( new Period(4, TimeUnit.Years) );
swaptionMaturities.Add( new Period(5, TimeUnit.Years) );
CalibrationHelperVector swaptions = new CalibrationHelperVector();
// List of times that have to be included in the timegrid
DoubleVector times = new DoubleVector();
for ( int i=0; i<numRows; i++) {
int j = numCols - i -1; // 1x5, 2x4, 3x3, 4x2, 5x1
int k = i*numCols + j;
Quote vol = new SimpleQuote( swaptionVols[k] );
SwaptionHelper helper = new SwaptionHelper(
swaptionMaturities[i],
new Period(swapLenghts[j], TimeUnit.Years),
new QuoteHandle(vol),
indexSixMonths,
indexSixMonths.tenor(),
indexSixMonths.dayCounter(),
indexSixMonths.dayCounter(),
rhTermStructure );
swaptions.Add( helper );
times.AddRange( helper.times() );
}
// Building time-grid
TimeGrid grid = new TimeGrid( times, 30);
// defining the models
// G2 modelG2 = new G2(rhTermStructure));
HullWhite modelHW = new HullWhite( rhTermStructure );
HullWhite modelHW2 = new HullWhite( rhTermStructure );
BlackKarasinski modelBK = new BlackKarasinski( rhTermStructure );
// model calibrations
// Console.WriteLine( "G2 (analytic formulae) calibration" );
// for (int i=0; i<swaptions.Count; i++)
// swaptions[i].setPricingEngine( new G2SwaptionEngine( modelG2, 6.0, 16 ) );
//
// calibrateModel( modelG2, swaptions, 0.05);
// Console.WriteLine( "calibrated to:" );
// Console.WriteLine( "a = " + modelG2.parameters()[0] );
// Console.WriteLine( "sigma = " + modelG2.parameters()[1] );
// Console.WriteLine( "b = " + modelG2.parameters()[2] );
// Console.WriteLine( "eta = " + modelG2.parameters()[3] );
// Console.WriteLine( "rho = " + modelG2.parameters()[4] );
Console.WriteLine( "Hull-White (analytic formulae) calibration" );
for (int i=0; i<swaptions.Count; i++)
swaptions[i].setPricingEngine(
new JamshidianSwaptionEngine(modelHW));
calibrateModel( modelHW, swaptions, 0.05);
// Console.WriteLine( "calibrated to:" );
// Console.WriteLine( "a = " + modelHW.parameters()[0] );
// Console.WriteLine( "sigma = " + modelHW.parameters()[1] );
Console.WriteLine( "Hull-White (numerical) calibration" );
for (int i=0; i<swaptions.Count; i++)
swaptions[i].setPricingEngine(
new TreeSwaptionEngine(modelHW2,grid));
calibrateModel(modelHW2, swaptions, 0.05);
// std::cout << "calibrated to:\n"
// << "a = " << modelHW2->params()[0] << ", "
// << "sigma = " << modelHW2->params()[1]
// << std::endl << std::endl;
Console.WriteLine( "Black-Karasinski (numerical) calibration" );
for (int i=0; i<swaptions.Count; i++)
swaptions[i].setPricingEngine(
new TreeSwaptionEngine(modelBK,grid));
calibrateModel(modelBK, swaptions, 0.05);
// std::cout << "calibrated to:\n"
// << "a = " << modelBK->params()[0] << ", "
// << "sigma = " << modelBK->params()[1]
// << std::endl << std::endl;
// ATM Bermudan swaption pricing
Console.WriteLine( "Payer bermudan swaption struck at {0} (ATM)",
fixedATMRate );
DateVector bermudanDates = new DateVector();
Schedule schedule = new Schedule(startDate,maturity,
new Period(3,TimeUnit.Months),calendar,
BusinessDayConvention.Following,
BusinessDayConvention.Following,
DateGeneration.Rule.Forward,false);
for (uint i=0; i<schedule.size(); i++)
bermudanDates.Add( schedule.date( i ) );
Exercise bermudaExercise = new BermudanExercise( bermudanDates );
Swaption bermudanSwaption =
new Swaption( atmSwap, bermudaExercise);
bermudanSwaption.setPricingEngine(
new TreeSwaptionEngine(modelHW, 50));
Console.WriteLine( "HW: " + bermudanSwaption.NPV() );
bermudanSwaption.setPricingEngine(
new TreeSwaptionEngine(modelHW2, 50));
Console.WriteLine( "HW (num): " + bermudanSwaption.NPV() );
bermudanSwaption.setPricingEngine(
new TreeSwaptionEngine(modelBK, 50));
Console.WriteLine( "BK (num): " + bermudanSwaption.NPV() );
DateTime endTime = DateTime.Now;
TimeSpan delta = endTime - startTime;
Console.WriteLine();
Console.WriteLine("Run completed in {0} s", delta.TotalSeconds);
Console.WriteLine();
}
