public override double value(double x)
{
if (x.IsNotEqual(vol_.value()))
{
vol_.setValue(x);
engine_.calculate();
}
return(results_.value.Value - targetValue_);
}
public void testObservable()
{
//.("Testing observability of instruments...");
SimpleQuote me1 = new SimpleQuote(0.0);
RelinkableHandle<Quote> h = new RelinkableHandle<Quote>(me1);
Instrument s = new Stock(h);
Flag f = new Flag();
s.registerWith(f.update);
s.NPV();
me1.setValue(3.14);
if (!f.isUp())
Assert.Fail("Observer was not notified of instrument change");
s.NPV();
f.lower();
SimpleQuote me2 = new SimpleQuote(0.0);
h.linkTo(me2);
if (!f.isUp())
Assert.Fail("Observer was not notified of instrument change");
f.lower();
s.freeze();
s.NPV();
me2.setValue(2.71);
if (f.isUp())
Assert.Fail("Observer was notified of frozen instrument change");
s.NPV();
s.unfreeze();
if (!f.isUp())
Assert.Fail("Observer was not notified of instrument change");
}
public override double value(double zSpread)
{
zSpread_.setValue(zSpread);
double NPV = CashFlows.npv(leg_, curve_, includeSettlementDateFlows_, settlementDate_, npvDate_);
return(npv_ - NPV);
}
public override double value(double x)
{
vol_.setValue(x);
engine_.calculate();
return(results_.value.GetValueOrDefault() - targetValue_);
}
public void testTheoretical()
{
// "Testing theoretical bond price/yield calculation...");
CommonVars vars = new CommonVars();
double tolerance = 1.0e-7;
int maxEvaluations = 100;
int[] lengths = new int[] { 3, 5, 10, 15, 20 };
int settlementDays = 3;
double[] coupons = new double[] { 0.02, 0.05, 0.08 };
Frequency[] frequencies = new Frequency[] { Frequency.Semiannual, Frequency.Annual };
DayCounter bondDayCount = new Actual360();
BusinessDayConvention accrualConvention = BusinessDayConvention.Unadjusted;
BusinessDayConvention paymentConvention = BusinessDayConvention.ModifiedFollowing;
double redemption = 100.0;
double[] yields = new double[] { 0.03, 0.04, 0.05, 0.06, 0.07 };
for (int j = 0; j < lengths.Length; j++)
{
for (int k = 0; k < coupons.Length; k++)
{
for (int l = 0; l < frequencies.Length; l++)
{
Date dated = vars.today;
Date issue = dated;
Date maturity = vars.calendar.advance(issue, lengths[j], TimeUnit.Years);
SimpleQuote rate = new SimpleQuote(0.0);
var discountCurve = new Handle<YieldTermStructure>(Utilities.flatRate(vars.today, rate, bondDayCount));
Schedule sch = new Schedule(dated, maturity, new Period(frequencies[l]), vars.calendar,
accrualConvention, accrualConvention, DateGeneration.Rule.Backward, false);
FixedRateBond bond = new FixedRateBond(settlementDays, vars.faceAmount, sch, new List<double>() { coupons[k] },
bondDayCount, paymentConvention, redemption, issue);
IPricingEngine bondEngine = new DiscountingBondEngine(discountCurve);
bond.setPricingEngine(bondEngine);
for (int m = 0; m < yields.Length; m++)
{
rate.setValue(yields[m]);
double price = bond.cleanPrice(yields[m], bondDayCount, Compounding.Continuous, frequencies[l]);
double calculatedPrice = bond.cleanPrice();
if (Math.Abs(price - calculatedPrice) > tolerance)
{
Assert.Fail("price calculation failed:"
+ "\n issue: " + issue
+ "\n maturity: " + maturity
+ "\n coupon: " + coupons[k]
+ "\n frequency: " + frequencies[l] + "\n"
+ "\n yield: " + yields[m]
+ "\n expected: " + price
+ "\n calculated': " + calculatedPrice
+ "\n error': " + (price - calculatedPrice));
}
double calculatedYield = bond.yield(bondDayCount, Compounding.Continuous, frequencies[l],
tolerance, maxEvaluations);
if (Math.Abs(yields[m] - calculatedYield) > tolerance)
{
Assert.Fail("yield calculation failed:"
+ "\n issue: " + issue
+ "\n maturity: " + maturity
+ "\n coupon: " + coupons[k]
+ "\n frequency: " + frequencies[l] + "\n"
+ "\n yield: " + yields[m]
+ "\n price: " + price
+ "\n yield': " + calculatedYield);
}
}
}
}
}
}
public void testObservableHandle()
{
// Testing observability of quote handles
SimpleQuote me1 = new SimpleQuote(0.0);
RelinkableHandle<Quote> h = new RelinkableHandle<Quote>(me1);
Flag f = new Flag();
h.registerWith(f.update);
me1.setValue(3.14);
if (!f.isUp())
Assert.Fail("Observer was not notified of quote change");
f.lower();
SimpleQuote me2 = new SimpleQuote(0.0);
h.linkTo(me2);
if (!f.isUp())
Assert.Fail("Observer was not notified of quote change");
}
public void testObservable()
{
// Testing observability of quotes
SimpleQuote me = new SimpleQuote(0.0);
Flag f = new Flag();
me.registerWith(f.update);
me.setValue(3.14);
if (!f.isUp())
Assert.Fail("Observer was not notified of quote change");
}
public void testFSpreadedObs()
{
// ("Testing observability of forward-spreaded term structure...");
CommonVars vars = new CommonVars();
SimpleQuote me = new SimpleQuote(0.01);
Handle<Quote> mh = new Handle<Quote>(me);
RelinkableHandle<YieldTermStructure> h = new RelinkableHandle<YieldTermStructure>(); //(vars.dummyTermStructure);
YieldTermStructure spreaded = new ForwardSpreadedTermStructure(h, mh);
Flag flag = new Flag();
spreaded.registerWith(flag.update);
h.linkTo(vars.termStructure);
if (!flag.isUp())
Console.WriteLine("Observer was not notified of term structure change");
flag.lower();
me.setValue(0.005);
if (!flag.isUp())
Console.WriteLine("Observer was not notified of spread change");
}
public void testReferenceChange()
{
// ("Testing term structure against evaluation date change...");
CommonVars vars = new CommonVars();
SimpleQuote flatRate = new SimpleQuote();
Handle<Quote> flatRateHandle = new Handle<Quote>(flatRate);
vars.termStructure = new FlatForward(vars.settlementDays, new NullCalendar(), flatRateHandle, new Actual360());
flatRate.setValue(.03);
int[] days = new int[] { 10, 30, 60, 120, 360, 720 };
Date today = Settings.evaluationDate();
List<double> expected = new InitializedList<double>(days.Length);
for (int i = 0; i < days.Length; i++)
expected[i] = vars.termStructure.discount(today + days[i]);
Settings.setEvaluationDate(today + 30);
List<double> calculated = new InitializedList<double>(days.Length);
for (int i = 0; i < days.Length; i++)
calculated[i] = vars.termStructure.discount(today + 30 + days[i]);
for (int i = 0; i < days.Length; i++)
{
if (!Utils.close(expected[i], calculated[i]))
Console.WriteLine("\n Discount at " + days[i] + " days:\n"
+ " before date change: " + expected[i] + "\n"
+ " after date change: " + calculated[i]);
}
}
static void Main()
{
DateTime timer = DateTime.Now;
/*********************
*** MARKET DATA ***
*********************/
RelinkableHandle<YieldTermStructure> euriborTermStructure = new RelinkableHandle<YieldTermStructure>();
IborIndex euribor3m = new Euribor3M(euriborTermStructure);
Date todaysDate = new Date(23, Month.May, 2006);
Settings.setEvaluationDate(todaysDate);
Calendar calendar = euribor3m.fixingCalendar();
int fixingDays = euribor3m.fixingDays();
Date settlementDate = calendar.advance(todaysDate, fixingDays, TimeUnit.Days);
Console.WriteLine("Today: " + todaysDate.DayOfWeek + ", " + todaysDate);
Console.WriteLine("Settlement date: " + settlementDate.DayOfWeek + ", " + settlementDate);
// 3 month term FRA quotes (index refers to monthsToStart)
double[] threeMonthFraQuote = new double[10];
threeMonthFraQuote[1]=0.030;
threeMonthFraQuote[2]=0.031;
threeMonthFraQuote[3]=0.032;
threeMonthFraQuote[6]=0.033;
threeMonthFraQuote[9]=0.034;
/********************
*** 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.
// FRAs
SimpleQuote fra1x4Rate = new SimpleQuote(threeMonthFraQuote[1]);
SimpleQuote fra2x5Rate = new SimpleQuote(threeMonthFraQuote[2]);
SimpleQuote fra3x6Rate = new SimpleQuote(threeMonthFraQuote[3]);
SimpleQuote fra6x9Rate = new SimpleQuote(threeMonthFraQuote[6]);
SimpleQuote fra9x12Rate = new SimpleQuote(threeMonthFraQuote[9]);
RelinkableHandle<Quote> h1x4 = new RelinkableHandle<Quote>(); h1x4.linkTo(fra1x4Rate);
RelinkableHandle<Quote> h2x5 = new RelinkableHandle<Quote>(); h2x5.linkTo(fra2x5Rate);
RelinkableHandle<Quote> h3x6 = new RelinkableHandle<Quote>(); h3x6.linkTo(fra3x6Rate);
RelinkableHandle<Quote> h6x9 = new RelinkableHandle<Quote>(); h6x9.linkTo(fra6x9Rate);
RelinkableHandle<Quote> h9x12 = new RelinkableHandle<Quote>(); h9x12.linkTo(fra9x12Rate);
/*********************
*** 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.
DayCounter fraDayCounter = euribor3m.dayCounter();
BusinessDayConvention convention = euribor3m.businessDayConvention();
bool endOfMonth = euribor3m.endOfMonth();
RateHelper fra1x4 = new FraRateHelper(h1x4, 1, 4,
fixingDays, calendar, convention,
endOfMonth, fraDayCounter);
RateHelper fra2x5 = new FraRateHelper(h2x5, 2, 5,
fixingDays, calendar, convention,
endOfMonth, fraDayCounter);
RateHelper fra3x6 = new FraRateHelper(h3x6, 3, 6,
fixingDays, calendar, convention,
endOfMonth, fraDayCounter);
RateHelper fra6x9 = new FraRateHelper(h6x9, 6, 9,
fixingDays, calendar, convention,
endOfMonth, fraDayCounter);
RateHelper fra9x12 = new FraRateHelper(h9x12, 9, 12,
fixingDays, calendar, convention,
endOfMonth, fraDayCounter);
/*********************
** 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 FRA curve
List<RateHelper> fraInstruments = new List<RateHelper>();
fraInstruments.Add(fra1x4);
fraInstruments.Add(fra2x5);
fraInstruments.Add(fra3x6);
fraInstruments.Add(fra6x9);
fraInstruments.Add(fra9x12);
YieldTermStructure fraTermStructure = new PiecewiseYieldCurve<Discount,LogLinear>(
settlementDate, fraInstruments, termStructureDayCounter,
new List<Handle<Quote>>(), new List<Date>(), tolerance);
// Term structures used for pricing/discounting
RelinkableHandle<YieldTermStructure> discountingTermStructure = new RelinkableHandle<YieldTermStructure>();
discountingTermStructure.linkTo(fraTermStructure);
/***********************
*** construct FRA's ***
***********************/
Calendar fraCalendar = euribor3m.fixingCalendar();
BusinessDayConvention fraBusinessDayConvention = euribor3m.businessDayConvention();
Position.Type fraFwdType = Position.Type.Long;
double fraNotional = 100.0;
const int FraTermMonths = 3;
int[] monthsToStart = new [] { 1, 2, 3, 6, 9 };
euriborTermStructure.linkTo(fraTermStructure);
Console.WriteLine("\nTest FRA construction, NPV calculation, and FRA purchase\n");
int i;
for (i=0; i<monthsToStart.Length; i++) {
Date fraValueDate = fraCalendar.advance(
settlementDate,monthsToStart[i], TimeUnit.Months,
fraBusinessDayConvention);
Date fraMaturityDate = fraCalendar.advance(
fraValueDate, FraTermMonths, TimeUnit.Months,
fraBusinessDayConvention);
double fraStrikeRate = threeMonthFraQuote[monthsToStart[i]];
ForwardRateAgreement myFRA = new ForwardRateAgreement(fraValueDate, fraMaturityDate,
fraFwdType,fraStrikeRate,
fraNotional, euribor3m,
discountingTermStructure);
Console.WriteLine("3m Term FRA, Months to Start: " + monthsToStart[i]);
Console.WriteLine("strike FRA rate: {0:0.00%}", fraStrikeRate);
Console.WriteLine("FRA 3m forward rate: {0:0.00%}", myFRA.forwardRate());
Console.WriteLine("FRA market quote: {0:0.00%}", threeMonthFraQuote[monthsToStart[i]]);
Console.WriteLine("FRA spot value: " + myFRA.spotValue());
Console.WriteLine("FRA forward value: " + myFRA.forwardValue());
Console.WriteLine("FRA implied Yield: {0:0.00%}",
myFRA.impliedYield(myFRA.spotValue(), myFRA.forwardValue(), settlementDate, Compounding.Simple, fraDayCounter));
Console.WriteLine("market Zero Rate: {0:0.00%}",
discountingTermStructure.link.zeroRate(fraMaturityDate, fraDayCounter, Compounding.Simple));
Console.WriteLine("FRA NPV [should be zero]: {0}\n", myFRA.NPV());
}
Console.WriteLine("\n");
Console.WriteLine("Now take a 100 basis-point upward shift in FRA quotes and examine NPV\n");
const double BpsShift = 0.01;
threeMonthFraQuote[1]=0.030+BpsShift;
threeMonthFraQuote[2]=0.031+BpsShift;
threeMonthFraQuote[3]=0.032+BpsShift;
threeMonthFraQuote[6]=0.033+BpsShift;
threeMonthFraQuote[9]=0.034+BpsShift;
fra1x4Rate.setValue(threeMonthFraQuote[1]);
fra2x5Rate.setValue(threeMonthFraQuote[2]);
fra3x6Rate.setValue(threeMonthFraQuote[3]);
fra6x9Rate.setValue(threeMonthFraQuote[6]);
fra9x12Rate.setValue(threeMonthFraQuote[9]);
for (i=0; i<monthsToStart.Length; i++) {
Date fraValueDate = fraCalendar.advance(
settlementDate, monthsToStart[i], TimeUnit.Months,
fraBusinessDayConvention);
Date fraMaturityDate = fraCalendar.advance(
fraValueDate, FraTermMonths, TimeUnit.Months,
fraBusinessDayConvention);
double fraStrikeRate = threeMonthFraQuote[monthsToStart[i]] - BpsShift;
ForwardRateAgreement myFRA = new ForwardRateAgreement(fraValueDate, fraMaturityDate,
fraFwdType, fraStrikeRate,
fraNotional, euribor3m,
discountingTermStructure);
Console.WriteLine("3m Term FRA, 100 notional, Months to Start: " + monthsToStart[i]);
Console.WriteLine("strike FRA rate: {0:0.00%}", fraStrikeRate);
Console.WriteLine("FRA 3m forward rate: {0:0.00%}", myFRA.forwardRate());
Console.WriteLine("FRA market quote: {0:0.00%}", threeMonthFraQuote[monthsToStart[i]]);
Console.WriteLine("FRA spot value: " + myFRA.spotValue());
Console.WriteLine("FRA forward value: " + myFRA.forwardValue());
Console.WriteLine("FRA implied Yield: {0:0.00%}",
myFRA.impliedYield(myFRA.spotValue(), myFRA.forwardValue(), settlementDate, Compounding.Simple, fraDayCounter));
Console.WriteLine("market Zero Rate: {0:0.00%}",
discountingTermStructure.link.zeroRate(fraMaturityDate, fraDayCounter, Compounding.Simple));
Console.WriteLine("FRA NPV [should be positive]: {0}\n", myFRA.NPV());
}
Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
Console.WriteLine();
Console.Write("Press any key to continue ...");
Console.ReadKey();
}
//void testEngineConsistency(EngineType engine, int binomialSteps, int samples, Dictionary<string,double> tolerance,
// bool testGreeks = false) {
void testEngineConsistency(EngineType engine, int binomialSteps, int samples, Dictionary<string, double> tolerance,
bool testGreeks)
{
//QL_TEST_START_TIMING
Dictionary<string, double> calculated = new Dictionary<string, double>(), expected = new Dictionary<string, double>();
// test options
Option.Type[] types = { Option.Type.Call, Option.Type.Put };
double[] strikes = { 75.0, 100.0, 125.0 };
int[] lengths = { 1 };
// test data
double[] underlyings = { 100.0 };
double[] qRates = { 0.00, 0.05 };
double[] rRates = { 0.01, 0.05, 0.15 };
double[] vols = { 0.11, 0.50, 1.20 };
DayCounter dc = new Actual360();
Date today = Date.Today;
SimpleQuote spot = new SimpleQuote(0.0);
SimpleQuote vol = new SimpleQuote(0.0);
BlackVolTermStructure volTS = Utilities.flatVol(today, vol, dc);
SimpleQuote qRate = new SimpleQuote(0.0);
YieldTermStructure qTS = Utilities.flatRate(today, qRate, dc);
SimpleQuote rRate = new SimpleQuote(0.0);
YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc);
for (int i = 0; i < types.Length; i++)
{
for (int j = 0; j < strikes.Length; j++)
{
for (int k = 0; k < lengths.Length; k++)
{
Date exDate = today + lengths[k] * 360;
Exercise exercise = new EuropeanExercise(exDate);
StrikedTypePayoff payoff = new PlainVanillaPayoff(types[i], strikes[j]);
// reference option
VanillaOption refOption = makeOption(payoff, exercise, spot, qTS, rTS, volTS,
EngineType.Analytic, 0, 0);
// option to check
VanillaOption option = makeOption(payoff, exercise, spot, qTS, rTS, volTS,
engine, binomialSteps, samples);
for (int l = 0; l < underlyings.Length; l++)
{
for (int m = 0; m < qRates.Length; m++)
{
for (int n = 0; n < rRates.Length; n++)
{
for (int p = 0; p < vols.Length; p++)
{
double u = underlyings[l];
double q = qRates[m],
r = rRates[n];
double v = vols[p];
spot.setValue(u);
qRate.setValue(q);
rRate.setValue(r);
vol.setValue(v);
expected.Clear();
calculated.Clear();
// FLOATING_POINT_EXCEPTION
expected.Add("value", refOption.NPV());
calculated.Add("value", option.NPV());
if (testGreeks && option.NPV() > spot.value() * 1.0e-5)
{
expected.Add("delta", refOption.delta());
expected.Add("gamma", refOption.gamma());
expected.Add("theta", refOption.theta());
calculated.Add("delta", option.delta());
calculated.Add("gamma", option.gamma());
calculated.Add("theta", option.theta());
}
foreach (string greek in calculated.Keys)
{
double expct = expected[greek],
calcl = calculated[greek],
tol = tolerance[greek];
double error = Utilities.relativeError(expct, calcl, u);
if (error > tol)
{
REPORT_FAILURE(greek, payoff, exercise,
u, q, r, today, v,
expct, calcl, error, tol);
}
}
}
}
}
}
}
}
}
}
public void testQuoteChanging()
{
// Testing quote update...
CommonVars vars = new CommonVars();
List<Handle<Quote>> spreads = new List<Handle<Quote>>();
SimpleQuote spread1 = new SimpleQuote(0.02);
SimpleQuote spread2 = new SimpleQuote(0.03);
spreads.Add(new Handle<Quote>(spread1));
spreads.Add(new Handle<Quote>(spread2));
List<Date> spreadDates = new List<Date>();
spreadDates.Add(vars.calendar.advance(vars.today, 100, TimeUnit.Days));
spreadDates.Add(vars.calendar.advance(vars.today, 150, TimeUnit.Days));
Date interpolationDate = vars.calendar.advance(vars.today, 120, TimeUnit.Days);
ZeroYieldStructure spreadedTermStructure =
new InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat>(
new Handle<YieldTermStructure>(vars.termStructure),
spreads, spreadDates);
double t = vars.dayCount.yearFraction(vars.settlementDate, interpolationDate);
double interpolatedZeroRate = spreadedTermStructure.zeroRate(t, vars.compounding).value();
double tolerance = 1e-9;
double expectedRate = vars.termStructure.zeroRate(t, vars.compounding).value() +
0.03;
if (Math.Abs(interpolatedZeroRate - expectedRate) > tolerance)
Assert.Fail(
"unable to reproduce interpolated rate\n"
+ " calculated: " + interpolatedZeroRate + "\n"
+ " expected: " + expectedRate);
spread2.setValue(0.025);
interpolatedZeroRate = spreadedTermStructure.zeroRate(t, vars.compounding).value();
expectedRate = vars.termStructure.zeroRate(t, vars.compounding).value() +
0.025;
if (Math.Abs(interpolatedZeroRate - expectedRate) > tolerance)
Assert.Fail(
"unable to reproduce interpolated rate\n"
+ " calculated: " + interpolatedZeroRate + "\n"
+ " expected: " + expectedRate);
}
public void testMCDiscreteArithmeticAverageStrike()
{
//BOOST_MESSAGE("Testing Monte Carlo discrete arithmetic average-strike Asians...");
//QL_TEST_START_TIMING
// data from "Asian Option", Levy, 1997
// in "Exotic Options: The State of the Art",
// edited by Clewlow, Strickland
DiscreteAverageData[] cases5 = {
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 0.0, 11.0/12.0, 2,
0.13, true, 1.51917595129 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 0.0, 11.0/12.0, 4,
0.13, true, 1.67940165674 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 0.0, 11.0/12.0, 8,
0.13, true, 1.75371215251 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 0.0, 11.0/12.0, 12,
0.13, true, 1.77595318693 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 0.0, 11.0/12.0, 26,
0.13, true, 1.81430536630 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 0.0, 11.0/12.0, 52,
0.13, true, 1.82269246898 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 0.0, 11.0/12.0, 100,
0.13, true, 1.83822402464 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 0.0, 11.0/12.0, 250,
0.13, true, 1.83875059026 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 0.0, 11.0/12.0, 500,
0.13, true, 1.83750703638 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 0.0, 11.0/12.0, 1000,
0.13, true, 1.83887181884 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 1.0/12.0, 11.0/12.0, 2,
0.13, true, 1.51154400089 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 1.0/12.0, 11.0/12.0, 4,
0.13, true, 1.67103508506 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 1.0/12.0, 11.0/12.0, 8,
0.13, true, 1.74529684070 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 1.0/12.0, 11.0/12.0, 12,
0.13, true, 1.76667074564 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 1.0/12.0, 11.0/12.0, 26,
0.13, true, 1.80528400613 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 1.0/12.0, 11.0/12.0, 52,
0.13, true, 1.81400883891 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 1.0/12.0, 11.0/12.0, 100,
0.13, true, 1.82922901451 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 1.0/12.0, 11.0/12.0, 250,
0.13, true, 1.82937111773 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 1.0/12.0, 11.0/12.0, 500,
0.13, true, 1.82826193186 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 1.0/12.0, 11.0/12.0, 1000,
0.13, true, 1.82967846654 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 3.0/12.0, 11.0/12.0, 2,
0.13, true, 1.49648170891 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 3.0/12.0, 11.0/12.0, 4,
0.13, true, 1.65443100462 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 3.0/12.0, 11.0/12.0, 8,
0.13, true, 1.72817806731 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 3.0/12.0, 11.0/12.0, 12,
0.13, true, 1.74877367895 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 3.0/12.0, 11.0/12.0, 26,
0.13, true, 1.78733801988 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 3.0/12.0, 11.0/12.0, 52,
0.13, true, 1.79624826757 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 3.0/12.0, 11.0/12.0, 100,
0.13, true, 1.81114186876 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 3.0/12.0, 11.0/12.0, 250,
0.13, true, 1.81101152587 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 3.0/12.0, 11.0/12.0, 500,
0.13, true, 1.81002311939 ),
new DiscreteAverageData(Option.Type.Call, 90.0, 87.0, 0.06, 0.025, 3.0/12.0, 11.0/12.0, 1000,
0.13, true, 1.81145760308 )
};
DayCounter dc = new Actual360();
Date today = Date.Today ;
SimpleQuote spot = new SimpleQuote(100.0);
SimpleQuote qRate = new SimpleQuote(0.03);
YieldTermStructure qTS =Utilities.flatRate(today, qRate, dc);
SimpleQuote rRate = new SimpleQuote(0.06);
YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc);
SimpleQuote vol = new SimpleQuote(0.20);
BlackVolTermStructure volTS = Utilities.flatVol(today, vol, dc);
Average.Type averageType = QLNet.Average.Type.Arithmetic;
double runningSum = 0.0;
int pastFixings = 0;
for (int l=0; l<cases5.Length; l++) {
StrikedTypePayoff payoff =
new PlainVanillaPayoff(cases5[l].type, cases5[l].strike);
double dt = cases5[l].length/(cases5[l].fixings-1);
List<double> timeIncrements = new InitializedList<double>(cases5[l].fixings);
List<Date> fixingDates = new InitializedList<Date>(cases5[l].fixings);
timeIncrements[0] = cases5[l].first;
fixingDates[0] = today + (int)(timeIncrements[0]*360+0.5);
for (int i=1; i<cases5[l].fixings; i++) {
timeIncrements[i] = i*dt + cases5[l].first;
fixingDates[i] = today + (int)(timeIncrements[i]*360+0.5);
}
Exercise exercise = new EuropeanExercise(fixingDates[cases5[l].fixings-1]);
spot.setValue(cases5[l].underlying);
qRate.setValue(cases5[l].dividendYield);
rRate.setValue(cases5[l].riskFreeRate);
vol.setValue(cases5[l].volatility);
BlackScholesMertonProcess stochProcess =
new BlackScholesMertonProcess(new Handle<Quote>(spot),
new Handle<YieldTermStructure>(qTS),
new Handle<YieldTermStructure>(rTS),
new Handle<BlackVolTermStructure>(volTS));
IPricingEngine engine =
new MakeMCDiscreteArithmeticASEngine<LowDiscrepancy,Statistics>(stochProcess)
.withSeed(3456789)
.withSamples(1023)
.value() ;
DiscreteAveragingAsianOption option =
new DiscreteAveragingAsianOption(averageType, runningSum,
pastFixings, fixingDates,
payoff, exercise);
option.setPricingEngine(engine);
double calculated = option.NPV();
double expected = cases5[l].result;
double tolerance = 2.0e-2;
if (Math.Abs(calculated-expected) > tolerance) {
REPORT_FAILURE("value", averageType, runningSum, pastFixings,
fixingDates, payoff, exercise, spot.value(),
qRate.value(), rRate.value(), today,
vol.value(), expected, calculated, tolerance);
}
}
}
public void testMCDiscreteArithmeticAveragePrice()
{
//BOOST_MESSAGE("Testing Monte Carlo discrete arithmetic average-price Asians...");
//QL_TEST_START_TIMING
// data from "Asian Option", Levy, 1997
// in "Exotic Options: The State of the Art",
// edited by Clewlow, Strickland
DiscreteAverageData[] cases4 = {
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 0.0,11.0/12.0, 2,0.13, true, 1.3942835683),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 0.0,11.0/12.0, 4,0.13, true, 1.5852442983),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 0.0,11.0/12.0, 8,0.13, true, 1.66970673),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 0.0,11.0/12.0, 12,0.13, true, 1.6980019214),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 0.0,11.0/12.0, 26,0.13, true, 1.7255070456),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 0.0,11.0/12.0, 52,0.13, true, 1.7401553533),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 0.0,11.0/12.0, 100,0.13, true, 1.7478303712),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 0.0,11.0/12.0, 250,0.13, true, 1.7490291943),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 0.0,11.0/12.0, 500,0.13, true, 1.7515113291),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 0.0,11.0/12.0, 1000,0.13, true, 1.7537344885),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 1.0/12.0,11.0/12.0, 2,0.13, true, 1.8496053697),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 1.0/12.0,11.0/12.0, 4,0.13, true, 2.0111495205),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 1.0/12.0,11.0/12.0, 8,0.13, true, 2.0852138818),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 1.0/12.0,11.0/12.0, 12,0.13, true, 2.1105094397),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 1.0/12.0,11.0/12.0, 26,0.13, true, 2.1346526695),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 1.0/12.0,11.0/12.0, 52,0.13, true, 2.147489651),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 1.0/12.0,11.0/12.0, 100,0.13, true, 2.154728109),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 1.0/12.0,11.0/12.0, 250,0.13, true, 2.1564276565),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 1.0/12.0,11.0/12.0, 500,0.13, true, 2.1594238588),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 1.0/12.0,11.0/12.0, 1000,0.13, true, 2.1595367326),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 3.0/12.0,11.0/12.0, 2,0.13, true, 2.63315092584),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 3.0/12.0,11.0/12.0, 4,0.13, true, 2.76723962361),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 3.0/12.0,11.0/12.0, 8,0.13, true, 2.83124836881),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 3.0/12.0,11.0/12.0, 12,0.13, true, 2.84290301412),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 3.0/12.0,11.0/12.0, 26,0.13, true, 2.88179560417),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 3.0/12.0,11.0/12.0, 52,0.13, true, 2.88447044543),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 3.0/12.0,11.0/12.0, 100,0.13, true, 2.89985329603),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 3.0/12.0,11.0/12.0, 250,0.13, true, 2.90047296063),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 3.0/12.0,11.0/12.0, 500,0.13, true, 2.89813412160),
new DiscreteAverageData(Option.Type.Put, 90.0, 87.0, 0.06, 0.025, 3.0/12.0,11.0/12.0, 1000,0.13, true, 2.89703362437)
};
DayCounter dc = new Actual360();
Date today = Date.Today ;
SimpleQuote spot = new SimpleQuote(100.0);
SimpleQuote qRate = new SimpleQuote(0.03);
YieldTermStructure qTS = Utilities.flatRate(today, qRate, dc);
SimpleQuote rRate = new SimpleQuote(0.06);
YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc);
SimpleQuote vol = new SimpleQuote(0.20);
BlackVolTermStructure volTS = Utilities.flatVol(today, vol, dc);
Average.Type averageType = Average.Type.Arithmetic;
double runningSum = 0.0;
int pastFixings = 0;
for (int l=0; l<cases4.Length ; l++) {
StrikedTypePayoff payoff = new
PlainVanillaPayoff(cases4[l].type, cases4[l].strike);
double dt = cases4[l].length/(cases4[l].fixings-1);
List<double> timeIncrements = new QLNet.InitializedList<double>(cases4[l].fixings);
List<Date> fixingDates = new QLNet.InitializedList<Date>(cases4[l].fixings);
timeIncrements[0] = cases4[l].first;
fixingDates[0] = today + (int)(timeIncrements[0]*360+0.5);
for (int i=1; i<cases4[l].fixings; i++) {
timeIncrements[i] = i*dt + cases4[l].first;
fixingDates[i] = today + (int)(timeIncrements[i]*360+0.5);
}
Exercise exercise = new EuropeanExercise(fixingDates[cases4[l].fixings-1]);
spot.setValue(cases4[l].underlying);
qRate.setValue(cases4[l].dividendYield);
rRate.setValue(cases4[l].riskFreeRate);
vol.setValue(cases4[l].volatility);
BlackScholesMertonProcess stochProcess =
new BlackScholesMertonProcess(new Handle<Quote>(spot),
new Handle<YieldTermStructure>(qTS),
new Handle<YieldTermStructure>(rTS),
new Handle<BlackVolTermStructure>(volTS));
ulong seed=42;
const int nrTrails = 5000;
LowDiscrepancy.icInstance = new InverseCumulativeNormal();
IRNG rsg = (IRNG)new LowDiscrepancy().make_sequence_generator(nrTrails,seed);
new PseudoRandom().make_sequence_generator(nrTrails,seed);
IPricingEngine engine =
new MakeMCDiscreteArithmeticAPEngine<LowDiscrepancy, Statistics>(stochProcess)
.withStepsPerYear(1)
.withSamples(2047)
.withControlVariate()
.value();
DiscreteAveragingAsianOption option=
new DiscreteAveragingAsianOption(averageType, runningSum,
pastFixings, fixingDates,
payoff, exercise);
option.setPricingEngine(engine);
double calculated = option.NPV();
double expected = cases4[l].result;
double tolerance = 2.0e-2;
if (Math.Abs(calculated-expected) > tolerance) {
REPORT_FAILURE("value", averageType, runningSum, pastFixings,
fixingDates, payoff, exercise, spot.value(),
qRate.value(), rRate.value(), today,
vol.value(), expected, calculated, tolerance);
}
}
}
public void testAnalyticDiscreteGeometricAveragePriceGreeks()
{
//BOOST_MESSAGE("Testing discrete-averaging geometric Asian greeks...");
//SavedSettings backup;
Dictionary<string,double> calculated, expected, tolerance;
calculated = new Dictionary<string, double>(6);
expected = new Dictionary<string, double>(6);
tolerance = new Dictionary<string, double>(6);
tolerance["delta"] = 1.0e-5;
tolerance["gamma"] = 1.0e-5;
tolerance["theta"] = 1.0e-5;
tolerance["rho"] = 1.0e-5;
tolerance["divRho"] = 1.0e-5;
tolerance["vega"] = 1.0e-5;
Option.Type[] types = { Option.Type.Call, Option.Type.Put };
double[] underlyings = { 100.0 };
double[] strikes = { 90.0, 100.0, 110.0 };
double[] qRates = { 0.04, 0.05, 0.06 };
double[] rRates = { 0.01, 0.05, 0.15 };
int[] lengths = { 1, 2 };
double[] vols = { 0.11, 0.50, 1.20 };
DayCounter dc = new Actual360();
Date today = Date.Today;
Settings.setEvaluationDate(today);
SimpleQuote spot = new SimpleQuote(0.0);
SimpleQuote qRate = new SimpleQuote(0.0);
Handle<YieldTermStructure> qTS = new Handle<YieldTermStructure>
(Utilities.flatRate(qRate, dc));
SimpleQuote rRate = new SimpleQuote(0.0);
Handle<YieldTermStructure> rTS = new Handle<YieldTermStructure>
(Utilities.flatRate(rRate, dc));
SimpleQuote vol = new SimpleQuote(0.0);
Handle<BlackVolTermStructure> volTS = new Handle<BlackVolTermStructure>
(Utilities.flatVol(vol, dc));
BlackScholesMertonProcess process =
new BlackScholesMertonProcess(new Handle<Quote>(spot), qTS, rTS, volTS);
for (int i=0; i<types.Length ; i++) {
for (int j=0; j<strikes.Length ; j++) {
for (int k=0; k<lengths.Length ; k++) {
EuropeanExercise maturity =
new EuropeanExercise(
today + new Period(lengths[k],TimeUnit.Years));
PlainVanillaPayoff payoff =
new PlainVanillaPayoff(types[i], strikes[j]);
double runningAverage = 120;
int pastFixings = 1;
List<Date> fixingDates = new List<Date>();
for (Date d = today + new Period(3, TimeUnit.Months);
d <= maturity.lastDate();
d += new Period(3, TimeUnit.Months))
fixingDates.Add(d);
IPricingEngine engine =
new AnalyticDiscreteGeometricAveragePriceAsianEngine(process);
DiscreteAveragingAsianOption option =
new DiscreteAveragingAsianOption(Average.Type.Geometric,
runningAverage, pastFixings,
fixingDates, payoff, maturity);
option.setPricingEngine(engine);
for (int l=0; l<underlyings.Length ; l++) {
for (int m=0; m<qRates.Length ; m++) {
for (int n=0; n<rRates.Length ; n++) {
for (int p=0; p<vols.Length ; p++) {
double u = underlyings[l];
double q = qRates[m],
r = rRates[n];
double v = vols[p];
spot.setValue(u);
qRate.setValue(q);
rRate.setValue(r);
vol.setValue(v);
double value = option.NPV();
calculated["delta"] = option.delta();
calculated["gamma"] = option.gamma();
calculated["theta"] = option.theta();
calculated["rho"] = option.rho();
calculated["divRho"] = option.dividendRho();
calculated["vega"] = option.vega();
if (value > spot.value()*1.0e-5) {
// perturb spot and get delta and gamma
double du = u*1.0e-4;
spot.setValue(u+du);
double value_p = option.NPV(),
delta_p = option.delta();
spot.setValue(u-du);
double value_m = option.NPV(),
delta_m = option.delta();
spot.setValue(u);
expected["delta"] = (value_p - value_m)/(2*du);
expected["gamma"] = (delta_p - delta_m)/(2*du);
// perturb rates and get rho and dividend rho
double dr = r*1.0e-4;
rRate.setValue(r+dr);
value_p = option.NPV();
rRate.setValue(r-dr);
value_m = option.NPV();
rRate.setValue(r);
expected["rho"] = (value_p - value_m)/(2*dr);
double dq = q*1.0e-4;
qRate.setValue(q+dq);
value_p = option.NPV();
qRate.setValue(q-dq);
value_m = option.NPV();
qRate.setValue(q);
expected["divRho"] = (value_p - value_m)/(2*dq);
// perturb volatility and get vega
double dv = v*1.0e-4;
vol.setValue(v+dv);
value_p = option.NPV();
vol.setValue(v-dv);
value_m = option.NPV();
vol.setValue(v);
expected["vega"] = (value_p - value_m)/(2*dv);
// perturb date and get theta
double dT = dc.yearFraction(today-1, today+1);
Settings.setEvaluationDate(today-1);
value_m = option.NPV();
Settings.setEvaluationDate(today+1);
value_p = option.NPV();
Settings.setEvaluationDate(today);
expected["theta"] = (value_p - value_m)/dT;
// compare
foreach (KeyValuePair<string, double> kvp in calculated){
string greek = kvp.Key;
double expct = expected[greek],
calcl = calculated[greek],
tol = tolerance [greek];
double error =Utilities.relativeError(expct,calcl,u);
if (error>tol) {
REPORT_FAILURE(greek, Average.Type.Geometric,
runningAverage, pastFixings,
new List<Date>(),
payoff, maturity,
u, q, r, today, v,
expct, calcl, tol);
}
}
}
}
}
}
}
}
}
}
}
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();
}
}
