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 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()
{
if (!(arguments_.exercise.type() == Exercise.Type.American))
{
throw new ApplicationException("not an American Option");
}
AmericanExercise ex = arguments_.exercise as AmericanExercise;
if (ex == null)
{
throw new ApplicationException("non-American exercise given");
}
if (ex.payoffAtExpiry())
{
throw new ApplicationException("payoff at expiry not handled");
}
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
if (payoff == null)
{
throw new ApplicationException("non-plain payoff given");
}
double variance = process_.blackVolatility().link.blackVariance(ex.lastDate(), payoff.strike());
double dividendDiscount = process_.dividendYield().link.discount(ex.lastDate());
double riskFreeDiscount = process_.riskFreeRate().link.discount(ex.lastDate());
double spot = process_.stateVariable().link.value();
if (!(spot > 0.0))
{
throw new ApplicationException("negative or null underlying given");
}
double strike = payoff.strike();
if (payoff.optionType() == Option.Type.Put)
{
// use put-call simmetry
Utils.swap <double>(ref spot, ref strike);
Utils.swap <double>(ref riskFreeDiscount, ref dividendDiscount);
payoff = new PlainVanillaPayoff(Option.Type.Call, strike);
}
if (dividendDiscount >= 1.0)
{
// early exercise is never optimal - use Black formula
double forwardPrice = spot * dividendDiscount / riskFreeDiscount;
BlackCalculator black = new BlackCalculator(payoff, forwardPrice, Math.Sqrt(variance), riskFreeDiscount);
results_.value = black.value();
results_.delta = black.delta(spot);
results_.deltaForward = black.deltaForward();
results_.elasticity = black.elasticity(spot);
results_.gamma = black.gamma(spot);
DayCounter rfdc = process_.riskFreeRate().link.dayCounter();
DayCounter divdc = process_.dividendYield().link.dayCounter();
DayCounter voldc = process_.blackVolatility().link.dayCounter();
double t = rfdc.yearFraction(process_.riskFreeRate().link.referenceDate(), arguments_.exercise.lastDate());
results_.rho = black.rho(t);
t = divdc.yearFraction(process_.dividendYield().link.referenceDate(), arguments_.exercise.lastDate());
results_.dividendRho = black.dividendRho(t);
t = voldc.yearFraction(process_.blackVolatility().link.referenceDate(), arguments_.exercise.lastDate());
results_.vega = black.vega(t);
results_.theta = black.theta(spot, t);
results_.thetaPerDay = black.thetaPerDay(spot, t);
results_.strikeSensitivity = black.strikeSensitivity();
results_.itmCashProbability = black.itmCashProbability();
}
else
{
// early exercise can be optimal - use approximation
results_.value = americanCallApproximation(spot, strike, riskFreeDiscount, dividendDiscount, variance);
}
}
public override void calculate()
{
/* this engine cannot really check for the averageType==Geometric
* since it can be used as control variate for the Arithmetic version
* QL_REQUIRE(arguments_.averageType == Average::Geometric,"not a geometric average option")
*/
Utils.QL_REQUIRE(arguments_.exercise.type() == Exercise.Type.European, () => "not an European Option");
double runningLog;
int pastFixings;
if (arguments_.averageType == Average.Type.Geometric)
{
Utils.QL_REQUIRE(arguments_.runningAccumulator > 0.0, () =>
"positive running product required: " + arguments_.runningAccumulator + " not allowed");
runningLog = Math.Log(arguments_.runningAccumulator.GetValueOrDefault());
pastFixings = arguments_.pastFixings.GetValueOrDefault();
}
else
{
// it is being used as control variate
runningLog = 1.0;
pastFixings = 0;
}
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-plain payoff given");
Date referenceDate = process_.riskFreeRate().link.referenceDate();
DayCounter rfdc = process_.riskFreeRate().link.dayCounter();
DayCounter divdc = process_.dividendYield().link.dayCounter();
DayCounter voldc = process_.blackVolatility().link.dayCounter();
List <double> fixingTimes = new List <double>();
int i;
for (i = 0; i < arguments_.fixingDates.Count; i++)
{
if (arguments_.fixingDates[i] >= referenceDate)
{
double t = voldc.yearFraction(referenceDate, arguments_.fixingDates[i]);
fixingTimes.Add(t);
}
}
int remainingFixings = fixingTimes.Count;
int numberOfFixings = pastFixings + remainingFixings;
double N = numberOfFixings;
double pastWeight = pastFixings / N;
double futureWeight = 1.0 - pastWeight;
double timeSum = 0;
fixingTimes.ForEach((ii, vv) => timeSum += fixingTimes[ii]);
double vola = process_.blackVolatility().link.blackVol(arguments_.exercise.lastDate(), payoff.strike());
double temp = 0.0;
for (i = pastFixings + 1; i < numberOfFixings; i++)
{
temp += fixingTimes[i - pastFixings - 1] * (N - i);
}
double variance = vola * vola / N / N * (timeSum + 2.0 * temp);
double dsigG_dsig = Math.Sqrt((timeSum + 2.0 * temp)) / N;
double sigG = vola * dsigG_dsig;
double dmuG_dsig = -(vola * timeSum) / N;
Date exDate = arguments_.exercise.lastDate();
double dividendRate = process_.dividendYield().link.
zeroRate(exDate, divdc, Compounding.Continuous, Frequency.NoFrequency).rate();
double riskFreeRate = process_.riskFreeRate().link.
zeroRate(exDate, rfdc, Compounding.Continuous, Frequency.NoFrequency).rate();
double nu = riskFreeRate - dividendRate - 0.5 * vola * vola;
double s = process_.stateVariable().link.value();
Utils.QL_REQUIRE(s > 0.0, () => "positive underlying value required");
int M = (pastFixings == 0 ? 1 : pastFixings);
double muG = pastWeight * runningLog / M + futureWeight * Math.Log(s) + nu * timeSum / N;
double forwardPrice = Math.Exp(muG + variance / 2.0);
double riskFreeDiscount = process_.riskFreeRate().link.discount(arguments_.exercise.lastDate());
BlackCalculator black = new BlackCalculator(payoff, forwardPrice, Math.Sqrt(variance), riskFreeDiscount);
results_.value = black.value();
results_.delta = futureWeight * black.delta(forwardPrice) * forwardPrice / s;
results_.gamma = forwardPrice * futureWeight / (s * s)
* (black.gamma(forwardPrice) * futureWeight * forwardPrice
- pastWeight * black.delta(forwardPrice));
double Nx_1, nx_1;
CumulativeNormalDistribution CND = new CumulativeNormalDistribution();
NormalDistribution ND = new NormalDistribution();
if (sigG > Const.QL_EPSILON)
{
double x_1 = (muG - Math.Log(payoff.strike()) + variance) / sigG;
Nx_1 = CND.value(x_1);
nx_1 = ND.value(x_1);
}
else
{
Nx_1 = (muG > Math.Log(payoff.strike()) ? 1.0 : 0.0);
nx_1 = 0.0;
}
results_.vega = forwardPrice * riskFreeDiscount *
((dmuG_dsig + sigG * dsigG_dsig) * Nx_1 + nx_1 * dsigG_dsig);
if (payoff.optionType() == Option.Type.Put)
{
results_.vega -= riskFreeDiscount * forwardPrice *
(dmuG_dsig + sigG * dsigG_dsig);
}
double tRho = rfdc.yearFraction(process_.riskFreeRate().link.referenceDate(),
arguments_.exercise.lastDate());
results_.rho = black.rho(tRho) * timeSum / (N * tRho)
- (tRho - timeSum / N) * results_.value;
double tDiv = divdc.yearFraction(
process_.dividendYield().link.referenceDate(),
arguments_.exercise.lastDate());
results_.dividendRho = black.dividendRho(tDiv) * timeSum / (N * tDiv);
results_.strikeSensitivity = black.strikeSensitivity();
results_.theta = Utils.blackScholesTheta(process_,
results_.value.GetValueOrDefault(),
results_.delta.GetValueOrDefault(),
results_.gamma.GetValueOrDefault());
}
public EuropeanPathPricer(Option.Type type, double strike, double discount)
{
payoff_ = new PlainVanillaPayoff(type, strike);
discount_ = discount;
Utils.QL_REQUIRE(strike >= 0.0, () => "strike less than zero not allowed");
}
public override void calculate()
{
Utils.QL_REQUIRE(arguments_.accruedCoupon == null &&
arguments_.lastFixing == null, () =>
"this engine cannot price options already started");
Utils.QL_REQUIRE(arguments_.localCap == null &&
arguments_.localFloor == null &&
arguments_.globalCap == null &&
arguments_.globalFloor == null, () =>
"this engine cannot price capped/floored options");
Utils.QL_REQUIRE(arguments_.exercise.type() == Exercise.Type.European, () => "not an European option");
PercentageStrikePayoff moneyness = arguments_.payoff as PercentageStrikePayoff;
Utils.QL_REQUIRE(moneyness != null, () => "wrong payoff given");
List <Date> resetDates = arguments_.resetDates;
resetDates.Add(arguments_.exercise.lastDate());
double underlying = process_.stateVariable().link.value();
Utils.QL_REQUIRE(underlying > 0.0, () => "negative or null underlying");
StrikedTypePayoff payoff = new PlainVanillaPayoff(moneyness.optionType(), 1.0);
results_.value = 0.0;
results_.delta = results_.gamma = 0.0;
results_.theta = 0.0;
results_.rho = results_.dividendRho = 0.0;
results_.vega = 0.0;
for (int i = 1; i < resetDates.Count; i++)
{
double discount = process_.riskFreeRate().link.discount(resetDates[i - 1]);
double rDiscount = process_.riskFreeRate().link.discount(resetDates[i]) /
process_.riskFreeRate().link.discount(resetDates[i - 1]);
double qDiscount = process_.dividendYield().link.discount(resetDates[i]) /
process_.dividendYield().link.discount(resetDates[i - 1]);
double forward = (1.0 / moneyness.strike()) * qDiscount / rDiscount;
double variance = process_.blackVolatility().link.blackForwardVariance(
resetDates[i - 1], resetDates[i],
underlying * moneyness.strike());
BlackCalculator black = new BlackCalculator(payoff, forward, Math.Sqrt(variance), rDiscount);
DayCounter rfdc = process_.riskFreeRate().link.dayCounter();
DayCounter divdc = process_.dividendYield().link.dayCounter();
DayCounter voldc = process_.blackVolatility().link.dayCounter();
results_.value += discount * moneyness.strike() * black.value();
results_.delta += 0.0;
results_.gamma += 0.0;
results_.theta += process_.riskFreeRate().link.forwardRate(
resetDates[i - 1], resetDates[i], rfdc, Compounding.Continuous, Frequency.NoFrequency).value() *
discount * moneyness.strike() * black.value();
double dt = rfdc.yearFraction(resetDates[i - 1], resetDates[i]);
double t = rfdc.yearFraction(process_.riskFreeRate().link.referenceDate(), resetDates[i - 1]);
results_.rho += discount * moneyness.strike() * (black.rho(dt) - t * black.value());
dt = divdc.yearFraction(resetDates[i - 1], resetDates[i]);
results_.dividendRho += discount * moneyness.strike() * black.dividendRho(dt);
dt = voldc.yearFraction(resetDates[i - 1], resetDates[i]);
results_.vega += discount * moneyness.strike() * black.vega(dt);
}
}
public void visit(PlainVanillaPayoff p)
{
}
public void testAnalyticContinuousGeometricAveragePrice()
{
//("Testing analytic continuous geometric average-price Asians...");
// data from "Option Pricing Formulas", Haug, pag.96-97
DayCounter dc = new Actual360();
Date today = Date.Today;
SimpleQuote spot = new SimpleQuote(80.0);
SimpleQuote qRate = new SimpleQuote(-0.03);
YieldTermStructure qTS = Utilities.flatRate(today, qRate, dc);
SimpleQuote rRate = new SimpleQuote(0.05);
YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc);
SimpleQuote vol = new SimpleQuote(0.20);
BlackVolTermStructure volTS = Utilities.flatVol(today, vol, dc);
BlackScholesMertonProcess stochProcess = new
BlackScholesMertonProcess(new Handle<Quote>(spot),
new Handle<YieldTermStructure>(qTS),
new Handle<YieldTermStructure>(rTS),
new Handle<BlackVolTermStructure>(volTS));
IPricingEngine engine = new
AnalyticContinuousGeometricAveragePriceAsianEngine(stochProcess);
Average.Type averageType = Average.Type.Geometric;
Option.Type type = Option.Type.Put;
double strike = 85.0;
Date exerciseDate = today + 90;
int pastFixings = 0; //Null<int>();
double runningAccumulator = 0.0; //Null<Real>();
StrikedTypePayoff payoff = new PlainVanillaPayoff(type, strike);
Exercise exercise = new EuropeanExercise(exerciseDate);
ContinuousAveragingAsianOption option =
new ContinuousAveragingAsianOption(averageType, payoff, exercise);
option.setPricingEngine(engine);
double calculated = option.NPV();
double expected = 4.6922;
double tolerance = 1.0e-4;
if (Math.Abs(calculated - expected) > tolerance)
{
REPORT_FAILURE("value", averageType, runningAccumulator, pastFixings,
new List<Date>(), payoff, exercise, spot.value(),
qRate.value(), rRate.value(), today,
vol.value(), expected, calculated, tolerance);
}
// trying to approximate the continuous version with the discrete version
runningAccumulator = 1.0;
pastFixings = 0;
List<Date> fixingDates = new InitializedList<Date>(exerciseDate - today + 1);
for (int i = 0; i < fixingDates.Count; i++)
{
fixingDates[i] = today + i;
}
IPricingEngine engine2 = new
AnalyticDiscreteGeometricAveragePriceAsianEngine(stochProcess);
DiscreteAveragingAsianOption option2 =
new DiscreteAveragingAsianOption(averageType,
runningAccumulator, pastFixings,
fixingDates,
payoff,
exercise);
option2.setPricingEngine(engine2);
calculated = option2.NPV();
tolerance = 3.0e-3;
/*if (Math.Abs(calculated - expected) > tolerance)
{
REPORT_FAILURE("value", averageType, runningAccumulator, pastFixings,
fixingDates, payoff, exercise, spot.value(),
qRate.value(), rRate.value(), today,
vol.value(), expected, calculated, tolerance);
}*/
}
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 override void calculate()
{
// this is an european option pricer
Utils.QL_REQUIRE(arguments_.exercise.type() == Exercise.Type.European, () => "not an European option");
// plain vanilla
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-striked payoff given");
double v0 = model_.link.v0();
double spotPrice = model_.link.s0();
Utils.QL_REQUIRE(spotPrice > 0.0, () => "negative or null underlying given");
double strike = payoff.strike();
double term = model_.link.riskFreeRate().link.dayCounter().yearFraction(
model_.link.riskFreeRate().link.referenceDate(), arguments_.exercise.lastDate());
double riskFreeDiscount = model_.link.riskFreeRate().link.discount(arguments_.exercise.lastDate());
double dividendDiscount = model_.link.dividendYield().link.discount(arguments_.exercise.lastDate());
//average values
TimeGrid timeGrid = model_.link.timeGrid();
int n = timeGrid.size() - 1;
double kappaAvg = 0.0, thetaAvg = 0.0, sigmaAvg = 0.0, rhoAvg = 0.0;
for (int i = 1; i <= n; ++i)
{
double t = 0.5 * (timeGrid[i - 1] + timeGrid[i]);
kappaAvg += model_.link.kappa(t);
thetaAvg += model_.link.theta(t);
sigmaAvg += model_.link.sigma(t);
rhoAvg += model_.link.rho(t);
}
kappaAvg /= n;
thetaAvg /= n;
sigmaAvg /= n;
rhoAvg /= n;
double c_inf = Math.Min(10.0, Math.Max(0.0001,
Math.Sqrt(1.0 - Math.Pow(rhoAvg, 2)) / sigmaAvg)) * (v0 + kappaAvg * thetaAvg * term);
double p1 = integration_.calculate(c_inf,
new Fj_Helper(model_, term, strike, 1).value) / Const.M_PI;
double p2 = integration_.calculate(c_inf,
new Fj_Helper(model_, term, strike, 2).value) / Const.M_PI;
switch (payoff.optionType())
{
case Option.Type.Call:
results_.value = spotPrice * dividendDiscount * (p1 + 0.5)
- strike * riskFreeDiscount * (p2 + 0.5);
break;
case Option.Type.Put:
results_.value = spotPrice * dividendDiscount * (p1 - 0.5)
- strike * riskFreeDiscount * (p2 - 0.5);
break;
default:
Utils.QL_FAIL("unknown option type");
break;
}
}
//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 override void calculate()
{
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-plain payoff given");
Utils.QL_REQUIRE(payoff.strike() > 0.0, () => "strike must be positive");
double strike = payoff.strike();
double spot = process_.x0();
Utils.QL_REQUIRE(spot >= 0.0, () => "negative or null underlying given");
Utils.QL_REQUIRE(!triggered(spot), () => "barrier touched");
Barrier.Type barrierType = arguments_.barrierType;
switch (payoff.optionType())
{
case Option.Type.Call:
switch (barrierType)
{
case Barrier.Type.DownIn:
if (strike >= barrier())
{
results_.value = C(1, 1) + E(1);
}
else
{
results_.value = A(1) - B(1) + D(1, 1) + E(1);
}
break;
case Barrier.Type.UpIn:
if (strike >= barrier())
{
results_.value = A(1) + E(-1);
}
else
{
results_.value = B(1) - C(-1, 1) + D(-1, 1) + E(-1);
}
break;
case Barrier.Type.DownOut:
if (strike >= barrier())
{
results_.value = A(1) - C(1, 1) + F(1);
}
else
{
results_.value = B(1) - D(1, 1) + F(1);
}
break;
case Barrier.Type.UpOut:
if (strike >= barrier())
{
results_.value = F(-1);
}
else
{
results_.value = A(1) - B(1) + C(-1, 1) - D(-1, 1) + F(-1);
}
break;
}
break;
case Option.Type.Put:
switch (barrierType)
{
case Barrier.Type.DownIn:
if (strike >= barrier())
{
results_.value = B(-1) - C(1, -1) + D(1, -1) + E(1);
}
else
{
results_.value = A(-1) + E(1);
}
break;
case Barrier.Type.UpIn:
if (strike >= barrier())
{
results_.value = A(-1) - B(-1) + D(-1, -1) + E(-1);
}
else
{
results_.value = C(-1, -1) + E(-1);
}
break;
case Barrier.Type.DownOut:
if (strike >= barrier())
{
results_.value = A(-1) - B(-1) + C(1, -1) - D(1, -1) + F(1);
}
else
{
results_.value = F(1);
}
break;
case Barrier.Type.UpOut:
if (strike >= barrier())
{
results_.value = B(-1) - D(-1, -1) + F(-1);
}
else
{
results_.value = A(-1) - C(-1, -1) + F(-1);
}
break;
}
break;
default:
Utils.QL_FAIL("unknown type");
break;
}
}
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 override void calculate(Excel_instrumentViewModel excel_inst)
//{
// //#region Setting
// //Excel_compositeOptionViewModel compOptionVM = excel_interface as Excel_compositeOptionViewModel;
// //if (compOptionVM == null)
// //{
// // //error
// //}
// //Calendar calendar = new TARGET();
// //Date todaysDate = todaysDate = ProgramVariable.ReferenceDate_;
// //Date settlementDate = todaysDate;
// //Settings.setEvaluationDate(todaysDate);
// //DayCounter dayCounter = new Actual365Fixed();
// //if (this.Excel_underlyingCalcInfo_paraViewModel_.Excel_underlyingInfo_paraViewModel_.Count == 0)
// //{
// // //error
// //}
// //Excel_geometricBMViewModel gbm = this.Excel_underlyingCalcInfo_paraViewModel_.Excel_underlyingInfo_paraViewModel_[0].Excel_underlyingModel_paraViewModel_ as Excel_geometricBMViewModel;
// //double currentValue = Convert.ToDouble(gbm.CurrentValue_);
// //SimpleQuote quote = new SimpleQuote(currentValue);
// //Handle<Quote> underlyingH = new Handle<Quote>(quote);
// //double drift = Convert.ToDouble(gbm.Drift_);
// //double dividendYield = Convert.ToDouble(gbm.Dividend_);
// //double volatility = Convert.ToDouble(gbm.Volatility_);
// //SimpleQuote volQuote = new SimpleQuote(volatility);
// //Handle<Quote> volH = new Handle<Quote>(volQuote);
// //var flatTermStructure = new Handle<YieldTermStructure>(new FlatForward(settlementDate, drift, dayCounter));
// //var flatDividendTS = new Handle<YieldTermStructure>(new FlatForward(settlementDate, dividendYield, dayCounter));
// //Handle<BlackVolTermStructure> flatVolTS = new Handle<BlackVolTermStructure>(new BlackConstantVol(settlementDate, calendar, volH, dayCounter));
// //BlackScholesMertonProcess bsmProcess = new BlackScholesMertonProcess(underlyingH, flatDividendTS, flatTermStructure, flatVolTS);
// //double value = 0.0;
// //DateTime exDate = compOptionVM.ExerciseDate_;
// //List<QLNet.OneAssetOption> optionList = new List<QLNet.OneAssetOption>();
// //foreach (Excel_compositeOption_subtypeViewModel item in compOptionVM.Excel_compositeOption_subtypeViewModelList_)
// //{
// // optionList.Add(this.option(item, bsmProcess, exDate));
// //}
// ////------------------------------------------------
// //foreach (var item in optionList)
// //{
// // value = value + item.NPV();
// //}
// //if (this.Separable_)
// //{
// // double matrutiryPayAmt = 0.0;
// // Excel_yieldCurveViewModel e_ycvm
// // = this.Excel_discountCurve_paraViewModel_.discountYieldCurve("KRW");
// // QLNet.YieldTermStructure yts = e_ycvm.yieldCurve();
// // value += matrutiryPayAmt;
// //}
// //#endregion
// //#region Calculation
// //quote.setValue(currentValue*1.01);
// //double sup = optionList[0].NPV();
// //quote.setValue(currentValue * 0.99);
// //double sdown = optionList[0].NPV();
// //double delta = (sup - sdown) / (currentValue * 0.02);
// //double gamma = (sup * sup - 2 * value + sdown * sdown) / (currentValue * 0.01 * currentValue * 0.01);
// //quote.setValue(currentValue);
// //volQuote.setValue(volatility - 0.01);
// //double voldown = optionList[0].NPV();
// //volQuote.setValue(volatility + 0.01);
// //double volup = optionList[0].NPV();
// //double vega = (volup - voldown) / 2;
// //#endregion
// //#region Result
// //this.Excel_resultViewModel_.Price_ = value.ToString();
// //double baseUnderlyingValue = Convert.ToDouble(
// // excel_interface.Excel_underlyingCalcInfoViewModel_.Excel_underlyingInfoViewModel_[0].BasePrice_);
// //this.Excel_resultViewModel_.PercentPrice_ = (100 * value / baseUnderlyingValue).ToString();
// //double notional = Convert.ToDouble(excel_interface.Excel_issueInfoViewModel_.Notional_);
// //this.Excel_resultViewModel_.EvalAmount_ = ( notional * ( value / baseUnderlyingValue) ).ToString();
// //#endregion
// //double gamma = optionList[0].gamma();
// //double vega = optionList[0].vega();
//}
private QLNet.OneAssetOption option(Excel_compositeOption_subtypeViewModel compositeOptionVM,
BlackScholesMertonProcess bsmProcess,
DateTime exDate)
{
Date exerciseDate = new Date(exDate);
if (compositeOptionVM.Excel_Type_.ToUpper() == "EXCEL_VANILLACALLPUT")
{
Excel_vanillaCallPutViewModel e_vcpvm = compositeOptionVM as Excel_vanillaCallPutViewModel;
QLNet.PlainVanillaPayoff payoff = new PlainVanillaPayoff(Option.Type.Call, e_vcpvm.StrikeValue_);
QLNet.EuropeanExercise ex = new EuropeanExercise(exerciseDate);
QLNet.VanillaOption vanillaOption = new VanillaOption(payoff, ex);
return vanillaOption;
}
else if (compositeOptionVM.Excel_Type_.ToUpper() == "EXCEL_UPINOUTCALL" ||
compositeOptionVM.Excel_Type_.ToUpper() == "EXCEL_DOWNINOUTCALL" )
{
Excel_upInOutCallViewModel e_uiocvm = compositeOptionVM as Excel_upInOutCallViewModel;
Barrier.Type type = Barrier.Type.UpOut;
if (e_uiocvm.InOut_.ToString() == "IN")
{
type = Barrier.Type.UpIn;
}
double strikeValue = e_uiocvm.StrikeValue_;
double barrierValue = e_uiocvm.BarrierValue_;
double partiRate = Convert.ToDouble(e_uiocvm.PartiRate_)/100.0;
double rebateValue = Convert.ToDouble(e_uiocvm.RebateCouponValue_);
QLNet.PlainVanillaPayoff payoff = new PlainVanillaPayoff(Option.Type.Call, strikeValue);
QLNet.EuropeanExercise ex = new EuropeanExercise(exerciseDate);
QLNet.BarrierOption barrierOption = new QLNet.BarrierOption(type, barrierValue, partiRate, rebateValue, payoff, ex);
QLNet.AnalyticBarrierWithPartiRateEngine engine = new AnalyticBarrierWithPartiRateEngine(bsmProcess);
barrierOption.setPricingEngine(engine);
return barrierOption;
}
else if (compositeOptionVM.Excel_Type_.ToUpper() == "")
{
Barrier.Type type = Barrier.Type.DownOut;
QLNet.PlainVanillaPayoff payoff = new PlainVanillaPayoff(Option.Type.Call, 261.4);
QLNet.EuropeanExercise ex = new EuropeanExercise(exerciseDate);
QLNet.BarrierOption barrierOption = new QLNet.BarrierOption(type, 313.68, 0.32, 0.0, payoff, ex);
QLNet.AnalyticBarrierWithPartiRateEngine engine = new AnalyticBarrierWithPartiRateEngine(bsmProcess);
barrierOption.setPricingEngine(engine);
return barrierOption;
}
else
{
throw new Exception("unknown compositeOptionType");
}
}
public static double bachelierBlackFormula(PlainVanillaPayoff payoff, double forward, double stdDev, double discount)
{
return(bachelierBlackFormula(payoff.optionType(), payoff.strike(), forward, stdDev, discount));
}
public static double bachelierBlackFormula( PlainVanillaPayoff payoff,
double forward,
double stdDev,
double discount)
{
return bachelierBlackFormula( payoff.optionType(),
payoff.strike(), forward, stdDev, discount );
}
public override void calculate()
{
Utils.QL_REQUIRE(arguments_.exercise.type() == Exercise.Type.European, () => "not an European Option");
EuropeanExercise exercise = arguments_.exercise as EuropeanExercise;
Utils.QL_REQUIRE(exercise != null, () => "not an European Option");
BasketPayoff basket_payoff = arguments_.payoff as BasketPayoff;
MinBasketPayoff min_basket = arguments_.payoff as MinBasketPayoff;
MaxBasketPayoff max_basket = arguments_.payoff as MaxBasketPayoff;
Utils.QL_REQUIRE(min_basket != null || max_basket != null, () => "unknown basket type");
PlainVanillaPayoff payoff = basket_payoff.basePayoff() as PlainVanillaPayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-plain payoff given");
double strike = payoff.strike();
double variance1 = process1_.blackVolatility().link.blackVariance(exercise.lastDate(), strike);
double variance2 = process2_.blackVolatility().link.blackVariance(exercise.lastDate(), strike);
double riskFreeDiscount = process1_.riskFreeRate().link.discount(exercise.lastDate());
// cannot handle non zero dividends, so don't believe this...
double dividendDiscount1 = process1_.dividendYield().link.discount(exercise.lastDate());
double dividendDiscount2 = process2_.dividendYield().link.discount(exercise.lastDate());
double forward1 = process1_.stateVariable().link.value() * dividendDiscount1 / riskFreeDiscount;
double forward2 = process2_.stateVariable().link.value() * dividendDiscount2 / riskFreeDiscount;
if (max_basket != null)
{
switch (payoff.optionType())
{
// euro call on a two asset max basket
case Option.Type.Call:
results_.value = euroTwoAssetMaxBasketCall(forward1, forward2, strike,
riskFreeDiscount,
variance1, variance2,
rho_);
break;
// euro put on a two asset max basket
case Option.Type.Put:
results_.value = strike * riskFreeDiscount -
euroTwoAssetMaxBasketCall(forward1, forward2, 0.0,
riskFreeDiscount,
variance1, variance2, rho_) +
euroTwoAssetMaxBasketCall(forward1, forward2, strike,
riskFreeDiscount,
variance1, variance2, rho_);
break;
default:
Utils.QL_FAIL("unknown option type");
break;
}
}
else if (min_basket != null)
{
switch (payoff.optionType())
{
// euro call on a two asset min basket
case Option.Type.Call:
results_.value = euroTwoAssetMinBasketCall(forward1, forward2, strike,
riskFreeDiscount,
variance1, variance2,
rho_);
break;
// euro put on a two asset min basket
case Option.Type.Put:
results_.value = strike * riskFreeDiscount -
euroTwoAssetMinBasketCall(forward1, forward2, 0.0,
riskFreeDiscount,
variance1, variance2, rho_) +
euroTwoAssetMinBasketCall(forward1, forward2, strike,
riskFreeDiscount,
variance1, variance2, rho_);
break;
default:
Utils.QL_FAIL("unknown option type");
break;
}
}
else
{
Utils.QL_FAIL("unknown type");
}
}
public override void calculate()
{
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
if (payoff == null)
{
throw new ApplicationException("non-plain payoff given");
}
if (!(payoff.strike() > 0.0))
{
throw new ApplicationException("strike must be positive");
}
// 추가된 부분.. 2014-07-23
this.partiRate_ = arguments_.partiRate;
double strike = payoff.strike();
double spot = process_.x0();
if (!(spot >= 0.0))
{
throw new ApplicationException("negative or null underlying given");
}
if (triggered(spot))
{
throw new ApplicationException("barrier touched");
}
Barrier.Type barrierType = arguments_.barrierType;
switch (payoff.optionType())
{
case Option.Type.Call:
switch (barrierType)
{
case Barrier.Type.DownIn:
if (strike >= barrier())
{
results_.value = C(1, 1) + E(1);
}
else
{
results_.value = A(1) - B(1) + D(1, 1) + E(1);
}
break;
case Barrier.Type.UpIn:
if (strike >= barrier())
{
results_.value = A(1) + E(-1);
}
else
{
results_.value = B(1) - C(-1, 1) + D(-1, 1) + E(-1);
}
break;
case Barrier.Type.DownOut:
if (strike >= barrier())
{
results_.value = A(1) - C(1, 1) + F(1);
}
else
{
results_.value = B(1) - D(1, 1) + F(1);
}
break;
case Barrier.Type.UpOut:
if (strike >= barrier())
{
results_.value = F(-1);
}
else
{
results_.value = A(1) - B(1) + C(-1, 1) - D(-1, 1) + F(-1);
}
break;
}
break;
case Option.Type.Put:
switch (barrierType)
{
case Barrier.Type.DownIn:
if (strike >= barrier())
{
results_.value = B(-1) - C(1, -1) + D(1, -1) + E(1);
}
else
{
results_.value = A(-1) + E(1);
}
break;
case Barrier.Type.UpIn:
if (strike >= barrier())
{
results_.value = A(-1) - B(-1) + D(-1, -1) + E(-1);
}
else
{
results_.value = C(-1, -1) + E(-1);
}
break;
case Barrier.Type.DownOut:
if (strike >= barrier())
{
results_.value = A(-1) - B(-1) + C(1, -1) - D(1, -1) + F(1);
}
else
{
results_.value = F(1);
}
break;
case Barrier.Type.UpOut:
if (strike >= barrier())
{
results_.value = B(-1) - D(-1, -1) + F(-1);
}
else
{
results_.value = A(-1) - C(-1, -1) + F(-1);
}
break;
}
break;
default:
throw new ApplicationException("unknown type");
}
}
public override void calculate()
{
DayCounter rfdc = process_.riskFreeRate().link.dayCounter();
DayCounter divdc = process_.dividendYield().link.dayCounter();
DayCounter voldc = process_.blackVolatility().link.dayCounter();
Calendar volcal = process_.blackVolatility().link.calendar();
double s0 = process_.stateVariable().link.value();
if (!(s0 > 0.0))
{
throw new ApplicationException("negative or null underlying given");
}
double v = process_.blackVolatility().link.blackVol(arguments_.exercise.lastDate(), s0);
Date maturityDate = arguments_.exercise.lastDate();
double r = process_.riskFreeRate().link.zeroRate(maturityDate, rfdc, Compounding.Continuous, Frequency.NoFrequency).rate();
double q = process_.dividendYield().link.zeroRate(maturityDate, divdc, Compounding.Continuous, Frequency.NoFrequency).rate();
Date referenceDate = process_.riskFreeRate().link.referenceDate();
// binomial trees with constant coefficient
var flatRiskFree = new Handle <YieldTermStructure>(new FlatForward(referenceDate, r, rfdc));
var flatDividends = new Handle <YieldTermStructure>(new FlatForward(referenceDate, q, divdc));
var flatVol = new Handle <BlackVolTermStructure>(new BlackConstantVol(referenceDate, volcal, v, voldc));
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
if (payoff == null)
{
throw new ApplicationException("non-plain payoff given");
}
double maturity = rfdc.yearFraction(referenceDate, maturityDate);
StochasticProcess1D bs =
new GeneralizedBlackScholesProcess(process_.stateVariable(), flatDividends, flatRiskFree, flatVol);
TimeGrid grid = new TimeGrid(maturity, timeSteps_);
T tree = new T().factory(bs, maturity, timeSteps_, payoff.strike());
BlackScholesLattice <T> lattice = new BlackScholesLattice <T>(tree, r, maturity, timeSteps_);
DiscretizedVanillaOption option = new DiscretizedVanillaOption(arguments_, process_, grid);
option.initialize(lattice, maturity);
// Partial derivatives calculated from various points in the
// binomial tree (Odegaard)
// Rollback to third-last step, and get underlying price (s2) &
// option values (p2) at this point
option.rollback(grid[2]);
Vector va2 = new Vector(option.values());
if (!(va2.size() == 3))
{
throw new ApplicationException("Expect 3 nodes in grid at second step");
}
double p2h = va2[2]; // high-price
double s2 = lattice.underlying(2, 2); // high price
// Rollback to second-last step, and get option value (p1) at
// this point
option.rollback(grid[1]);
Vector va = new Vector(option.values());
if (!(va.size() == 2))
{
throw new ApplicationException("Expect 2 nodes in grid at first step");
}
double p1 = va[1];
// Finally, rollback to t=0
option.rollback(0.0);
double p0 = option.presentValue();
double s1 = lattice.underlying(1, 1);
// Calculate partial derivatives
double delta0 = (p1 - p0) / (s1 - s0); // dp/ds
double delta1 = (p2h - p1) / (s2 - s1); // dp/ds
// Store results
results_.value = p0;
results_.delta = delta0;
results_.gamma = 2.0 * (delta1 - delta0) / (s2 - s0); //d(delta)/ds
results_.theta = Utils.blackScholesTheta(process_,
results_.value.GetValueOrDefault(),
results_.delta.GetValueOrDefault(),
results_.gamma.GetValueOrDefault());
}
public void visit(PlainVanillaPayoff p)
{
// Nothing to do here
}
public override void calculate()
{
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-plain payoff given");
Utils.QL_REQUIRE(payoff.strike() > 0.0, () => "strike must be positive");
double K = payoff.strike();
double S = process_.x0();
Utils.QL_REQUIRE(S >= 0.0, () => "negative or null underlying given");
Utils.QL_REQUIRE(!triggered(S), () => "barrier touched");
DoubleBarrier.Type barrierType = arguments_.barrierType;
Utils.QL_REQUIRE(barrierType == DoubleBarrier.Type.KnockOut ||
barrierType == DoubleBarrier.Type.KnockIn, () =>
"only KnockIn and KnockOut options supported");
double L = arguments_.barrier_lo.GetValueOrDefault();
double H = arguments_.barrier_hi.GetValueOrDefault();
double K_up = Math.Min(H, K);
double K_down = Math.Max(L, K);
double T = residualTime();
double rd = riskFreeRate();
double dd = riskFreeDiscount();
double rf = dividendYield();
double df = dividendDiscount();
double vol = volatility();
double mu = rd - rf - vol * vol / 2.0;
double sgn = mu > 0 ? 1.0 :(mu < 0 ? -1.0: 0.0);
//rebate
double R_L = arguments_.rebate.GetValueOrDefault();
double R_H = arguments_.rebate.GetValueOrDefault();
//european option
EuropeanOption europeanOption = new EuropeanOption(payoff, arguments_.exercise);
IPricingEngine analyticEuropeanEngine = new AnalyticEuropeanEngine(process_);
europeanOption.setPricingEngine(analyticEuropeanEngine);
double european = europeanOption.NPV();
double barrierOut = 0;
double rebateIn = 0;
for (int n = -series_; n < series_; n++)
{
double d1 = D(S / H * Math.Pow(L / H, 2.0 * n), vol * vol + mu, vol, T);
double d2 = d1 - vol * Math.Sqrt(T);
double g1 = D(H / S * Math.Pow(L / H, 2.0 * n - 1.0), vol * vol + mu, vol, T);
double g2 = g1 - vol * Math.Sqrt(T);
double h1 = D(S / H * Math.Pow(L / H, 2.0 * n - 1.0), vol * vol + mu, vol, T);
double h2 = h1 - vol * Math.Sqrt(T);
double k1 = D(L / S * Math.Pow(L / H, 2.0 * n - 1.0), vol * vol + mu, vol, T);
double k2 = k1 - vol * Math.Sqrt(T);
double d1_down = D(S / K_down * Math.Pow(L / H, 2.0 * n), vol * vol + mu, vol, T);
double d2_down = d1_down - vol * Math.Sqrt(T);
double d1_up = D(S / K_up * Math.Pow(L / H, 2.0 * n), vol * vol + mu, vol, T);
double d2_up = d1_up - vol * Math.Sqrt(T);
double k1_down = D((H * H) / (K_down * S) * Math.Pow(L / H, 2.0 * n), vol * vol + mu, vol, T);
double k2_down = k1_down - vol * Math.Sqrt(T);
double k1_up = D((H * H) / (K_up * S) * Math.Pow(L / H, 2.0 * n), vol * vol + mu, vol, T);
double k2_up = k1_up - vol * Math.Sqrt(T);
if (payoff.optionType() == Option.Type.Call)
{
barrierOut += Math.Pow(L / H, 2.0 * n * mu / (vol * vol)) *
(df * S * Math.Pow(L / H, 2.0 * n) * (f_.value(d1_down) - f_.value(d1))
- dd * K * (f_.value(d2_down) - f_.value(d2))
- df * Math.Pow(L / H, 2.0 * n) * H * H / S * Math.Pow(H / S, 2.0 * mu / (vol * vol)) * (f_.value(k1_down) - f_.value(k1))
+ dd * K * Math.Pow(H / S, 2.0 * mu / (vol * vol)) * (f_.value(k2_down) - f_.value(k2)));
}
else if (payoff.optionType() == Option.Type.Put)
{
barrierOut += Math.Pow(L / H, 2.0 * n * mu / (vol * vol)) *
(dd * K * (f_.value(h2) - f_.value(d2_up))
- df * S * Math.Pow(L / H, 2.0 * n) * (f_.value(h1) - f_.value(d1_up))
- dd * K * Math.Pow(H / S, 2.0 * mu / (vol * vol)) * (f_.value(g2) - f_.value(k2_up))
+ df * Math.Pow(L / H, 2.0 * n) * H * H / S * Math.Pow(H / S, 2.0 * mu / (vol * vol)) * (f_.value(g1) - f_.value(k1_up)));
}
else
{
Utils.QL_FAIL("option type not recognized");
}
double v1 = D(H / S * Math.Pow(H / L, 2.0 * n), -mu, vol, T);
double v2 = D(H / S * Math.Pow(H / L, 2.0 * n), mu, vol, T);
double v3 = D(S / L * Math.Pow(H / L, 2.0 * n), -mu, vol, T);
double v4 = D(S / L * Math.Pow(H / L, 2.0 * n), mu, vol, T);
rebateIn += dd * R_H * sgn * (Math.Pow(L / H, 2.0 * n * mu / (vol * vol)) * f_.value(sgn * v1) - Math.Pow(H / S, 2.0 * mu / (vol * vol)) * f_.value(-sgn * v2))
+ dd * R_L * sgn * (Math.Pow(L / S, 2.0 * mu / (vol * vol)) * f_.value(-sgn * v3) - Math.Pow(H / L, 2.0 * n * mu / (vol * vol)) * f_.value(sgn * v4));
}
//rebate paid at maturity
if (barrierType == DoubleBarrier.Type.KnockOut)
{
results_.value = barrierOut;
}
else
{
results_.value = european - barrierOut;
}
results_.additionalResults["vanilla"] = european;
results_.additionalResults["barrierOut"] = barrierOut;
results_.additionalResults["barrierIn"] = european - barrierOut;
}
public override void calculate()
{
Utils.QL_REQUIRE(arguments_.averageType == Average.Type.Geometric, () =>
"not a geometric average option");
Utils.QL_REQUIRE(arguments_.exercise.type() == Exercise.Type.European, () =>
"not an European option");
Utils.QL_REQUIRE(arguments_.runningAccumulator > 0.0, () =>
"positive running product required: " + arguments_.runningAccumulator + "not allowed");
double runningLog = Math.Log(arguments_.runningAccumulator.GetValueOrDefault());
int? pastFixings = arguments_.pastFixings;
Utils.QL_REQUIRE(pastFixings == 0, () => "past fixings currently not managed");
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-plain payoff given");
DayCounter rfdc = process_.riskFreeRate().link.dayCounter();
DayCounter divdc = process_.dividendYield().link.dayCounter();
DayCounter voldc = process_.blackVolatility().link.dayCounter();
List <double> fixingTimes = new List <double>();
for (int i = 0; i < arguments_.fixingDates.Count; i++)
{
if (arguments_.fixingDates[i] >= arguments_.fixingDates[0])
{
double t = voldc.yearFraction(arguments_.fixingDates[0], arguments_.fixingDates[i]);
fixingTimes.Add(t);
}
}
int remainingFixings = fixingTimes.Count;
int numberOfFixings = pastFixings.GetValueOrDefault() + remainingFixings;
double N = (double)(numberOfFixings);
double pastWeight = pastFixings.GetValueOrDefault() / N;
double futureWeight = 1.0 - pastWeight;
double timeSum = 0;
fixingTimes.ForEach((ii, vv) => timeSum += fixingTimes[ii]);
double residualTime = rfdc.yearFraction(arguments_.fixingDates[pastFixings.GetValueOrDefault()],
arguments_.exercise.lastDate());
double underlying = process_.stateVariable().link.value();
Utils.QL_REQUIRE(underlying > 0.0, () => "positive underlying value required");
double volatility = process_.blackVolatility().link.blackVol(arguments_.exercise.lastDate(), underlying);
Date exDate = arguments_.exercise.lastDate();
double dividendRate = process_.dividendYield().link.zeroRate(exDate, divdc,
Compounding.Continuous, Frequency.NoFrequency).value();
double riskFreeRate = process_.riskFreeRate().link.zeroRate(exDate, rfdc,
Compounding.Continuous, Frequency.NoFrequency).value();
double nu = riskFreeRate - dividendRate - 0.5 * volatility * volatility;
double temp = 0.0;
for (int i = pastFixings.GetValueOrDefault() + 1; i < numberOfFixings; i++)
{
temp += fixingTimes[i - pastFixings.GetValueOrDefault() - 1] * (N - i);
}
double variance = volatility * volatility / N / N * (timeSum + 2.0 * temp);
double covarianceTerm = volatility * volatility / N * timeSum;
double sigmaSum_2 = variance + volatility * volatility * residualTime - 2.0 * covarianceTerm;
int M = (pastFixings.GetValueOrDefault() == 0 ? 1 : pastFixings.GetValueOrDefault());
double runningLogAverage = runningLog / M;
double muG = pastWeight * runningLogAverage +
futureWeight * Math.Log(underlying) +
nu * timeSum / N;
CumulativeNormalDistribution f = new CumulativeNormalDistribution();
double y1 = (Math.Log(underlying) +
(riskFreeRate - dividendRate) * residualTime -
muG - variance / 2.0 + sigmaSum_2 / 2.0)
/ Math.Sqrt(sigmaSum_2);
double y2 = y1 - Math.Sqrt(sigmaSum_2);
switch (payoff.optionType())
{
case Option.Type.Call:
results_.value = underlying * Math.Exp(-dividendRate * residualTime)
* f.value(y1) - Math.Exp(muG + variance / 2.0 - riskFreeRate * residualTime) * f.value(y2);
break;
case Option.Type.Put:
results_.value = -underlying *Math.Exp(-dividendRate *residualTime)
* f.value(-y1) + Math.Exp(muG + variance / 2.0 - riskFreeRate * residualTime) * f.value(-y2);
break;
default:
Utils.QL_FAIL("invalid option type");
break;
}
}
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);
}
}
}
}
}
}
}
}
}
}
}
//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 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 override void calculate()
{
Utils.QL_REQUIRE(arguments_.exercise.type() == Exercise.Type.European, () =>
"this engine handles only european options");
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-plain payoff given");
double strike = payoff.strike();
Utils.QL_REQUIRE(strike > 0.0, () => "strike must be positive");
double spot = underlying();
Utils.QL_REQUIRE(spot >= 0.0, () => "negative or null underlying given");
Utils.QL_REQUIRE(!triggered(spot), () => "barrier(s) already touched");
DoubleBarrier.Type barrierType = arguments_.barrierType;
if (triggered(spot))
{
if (barrierType == DoubleBarrier.Type.KnockIn)
{
results_.value = vanillaEquivalent(); // knocked in
}
else
{
results_.value = 0.0; // knocked out
}
}
else
{
switch (payoff.optionType())
{
case Option.Type.Call:
switch (barrierType)
{
case DoubleBarrier.Type.KnockIn:
results_.value = callKI();
break;
case DoubleBarrier.Type.KnockOut:
results_.value = callKO();
break;
case DoubleBarrier.Type.KIKO:
case DoubleBarrier.Type.KOKI:
Utils.QL_FAIL("unsupported double-barrier type: " + barrierType);
break;
default:
Utils.QL_FAIL("unknown double-barrier type: " + barrierType);
break;
}
break;
case Option.Type.Put:
switch (barrierType)
{
case DoubleBarrier.Type.KnockIn:
results_.value = putKI();
break;
case DoubleBarrier.Type.KnockOut:
results_.value = putKO();
break;
case DoubleBarrier.Type.KIKO:
case DoubleBarrier.Type.KOKI:
Utils.QL_FAIL("unsupported double-barrier type: " + barrierType);
break;
default:
Utils.QL_FAIL("unknown double-barrier type: " + barrierType);
break;
}
break;
default:
Utils.QL_FAIL("unknown type");
break;
}
}
}
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 override void calculate()
{
if (arguments_.averageType != Average.Type.Geometric)
{
throw new ApplicationException("not a geometric average option");
}
if (arguments_.exercise.type() != Exercise.Type.European)
{
throw new ApplicationException("not an European Option");
}
Date exercise = arguments_.exercise.lastDate();
PlainVanillaPayoff payoff = (PlainVanillaPayoff)(arguments_.payoff);
if (payoff == null)
{
throw new ApplicationException("non-plain payoff given");
}
double volatility =
process_.blackVolatility().link.blackVol(exercise, payoff.strike());
double variance =
process_.blackVolatility().link.blackVariance(exercise,
payoff.strike());
double riskFreeDiscount =
process_.riskFreeRate().link.discount(exercise);
DayCounter rfdc = process_.riskFreeRate().link.dayCounter();
DayCounter divdc = process_.dividendYield().link.dayCounter();
DayCounter voldc = process_.blackVolatility().link.dayCounter();
double dividendYield = 0.5 * (
process_.riskFreeRate().link.zeroRate(exercise, rfdc,
Compounding.Continuous,
Frequency.NoFrequency).rate() +
process_.dividendYield().link.zeroRate(exercise, divdc,
Compounding.Continuous,
Frequency.NoFrequency).rate() +
volatility * volatility / 6.0);
double t_q = divdc.yearFraction(
process_.dividendYield().link.referenceDate(), exercise);
double dividendDiscount = Math.Exp(-dividendYield * t_q);
double spot = process_.stateVariable().link.value();
if (!(spot > 0.0))
{
throw new ApplicationException("negative or null underlying");
}
double forward = spot * dividendDiscount / riskFreeDiscount;
BlackCalculator black = new BlackCalculator(payoff,
forward,
Math.Sqrt(variance / 3.0),
riskFreeDiscount);
results_.value = black.value();
results_.delta = black.delta(spot);
results_.gamma = black.gamma(spot);
results_.dividendRho = black.dividendRho(t_q) / 2.0;
double t_r = rfdc.yearFraction(process_.riskFreeRate().link.referenceDate(),
arguments_.exercise.lastDate());
results_.rho = black.rho(t_r) + 0.5 * black.dividendRho(t_q);
double t_v = voldc.yearFraction(
process_.blackVolatility().link.referenceDate(),
arguments_.exercise.lastDate());
results_.vega = black.vega(t_v) / Math.Sqrt(3.0) +
black.dividendRho(t_q) * volatility / 6.0;
try{
results_.theta = black.theta(spot, t_v);
}
catch (System.Exception e /*Error*/) {
results_.theta = double.NaN; //Null<Real>();
}
}
public void testMCDiscreteGeometricAveragePrice()
{
//BOOST_MESSAGE("Testing Monte Carlo discrete geometric average-price Asians...");
// data from "Implementing Derivatives Model",
// Clewlow, Strickland, p.118-123
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);
BlackScholesMertonProcess stochProcess =
new BlackScholesMertonProcess(new Handle<Quote>(spot),
new Handle<YieldTermStructure>(qTS),
new Handle<YieldTermStructure>(rTS),
new Handle<BlackVolTermStructure>(volTS));
double tolerance = 4.0e-3;
IPricingEngine engine =
new MakeMCDiscreteGeometricAPEngine
<LowDiscrepancy,Statistics>(stochProcess)
.withStepsPerYear(1)
.withSamples(8191)
.value();
Average.Type averageType = Average.Type.Geometric;
double runningAccumulator = 1.0;
int pastFixings = 0;
int futureFixings = 10;
Option.Type type = Option.Type.Call;
double strike = 100.0;
StrikedTypePayoff payoff = new PlainVanillaPayoff(type, strike);
Date exerciseDate = today + 360;
Exercise exercise = new EuropeanExercise(exerciseDate);
List<Date> fixingDates = new InitializedList<Date>(futureFixings);
int dt = (int)(360/futureFixings+0.5);
fixingDates[0] = today + dt;
for (int j=1; j<futureFixings; j++)
fixingDates[j] = fixingDates[j-1] + dt;
DiscreteAveragingAsianOption option =
new DiscreteAveragingAsianOption(averageType, runningAccumulator,
pastFixings, fixingDates,
payoff, exercise);
option.setPricingEngine(engine);
double calculated = option.NPV();
IPricingEngine engine2 =
new AnalyticDiscreteGeometricAveragePriceAsianEngine(stochProcess);
option.setPricingEngine(engine2);
double expected = option.NPV();
if (Math.Abs(calculated-expected) > tolerance) {
REPORT_FAILURE("value", averageType, runningAccumulator, pastFixings,
fixingDates, payoff, exercise, spot.value(),
qRate.value(), rRate.value(), today,
vol.value(), expected, calculated, tolerance);
}
}
public override void calculate() {
if (!(arguments_.exercise.type() == Exercise.Type.American))
throw new ApplicationException("not an American Option");
AmericanExercise ex = arguments_.exercise as AmericanExercise;
if(ex == null) throw new ApplicationException("non-American exercise given");
if(ex.payoffAtExpiry()) throw new ApplicationException("payoff at expiry not handled");
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
if(payoff == null) throw new ApplicationException("non-plain payoff given");
double variance = process_.blackVolatility().link.blackVariance(ex.lastDate(), payoff.strike());
double dividendDiscount = process_.dividendYield().link.discount(ex.lastDate());
double riskFreeDiscount = process_.riskFreeRate().link.discount(ex.lastDate());
double spot = process_.stateVariable().link.value();
if (!(spot > 0.0)) throw new ApplicationException("negative or null underlying given");
double strike = payoff.strike();
if (payoff.optionType()==Option.Type.Put) {
// use put-call simmetry
Utils.swap<double>(ref spot, ref strike);
Utils.swap<double>(ref riskFreeDiscount, ref dividendDiscount);
payoff = new PlainVanillaPayoff(Option.Type.Call, strike);
}
if (dividendDiscount>=1.0) {
// early exercise is never optimal - use Black formula
double forwardPrice = spot * dividendDiscount / riskFreeDiscount;
BlackCalculator black = new BlackCalculator(payoff, forwardPrice, Math.Sqrt(variance), riskFreeDiscount);
results_.value = black.value();
results_.delta = black.delta(spot);
results_.deltaForward = black.deltaForward();
results_.elasticity = black.elasticity(spot);
results_.gamma = black.gamma(spot);
DayCounter rfdc = process_.riskFreeRate().link.dayCounter();
DayCounter divdc = process_.dividendYield().link.dayCounter();
DayCounter voldc = process_.blackVolatility().link.dayCounter();
double t = rfdc.yearFraction(process_.riskFreeRate().link.referenceDate(), arguments_.exercise.lastDate());
results_.rho = black.rho(t);
t = divdc.yearFraction(process_.dividendYield().link.referenceDate(), arguments_.exercise.lastDate());
results_.dividendRho = black.dividendRho(t);
t = voldc.yearFraction(process_.blackVolatility().link.referenceDate(), arguments_.exercise.lastDate());
results_.vega = black.vega(t);
results_.theta = black.theta(spot, t);
results_.thetaPerDay = black.thetaPerDay(spot, t);
results_.strikeSensitivity = black.strikeSensitivity();
results_.itmCashProbability = black.itmCashProbability();
} else {
// early exercise can be optimal - use approximation
results_.value = americanCallApproximation(spot, strike, riskFreeDiscount, dividendDiscount, variance);
}
}
public void testPastFixings()
{
//BOOST_MESSAGE("Testing use of past fixings in Asian options...");
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);
StrikedTypePayoff payoff = new PlainVanillaPayoff(Option.Type.Put, 100.0);
Exercise exercise = new EuropeanExercise(today + new Period(1,TimeUnit.Years));
BlackScholesMertonProcess stochProcess =
new BlackScholesMertonProcess(new Handle<Quote>(spot),
new Handle<YieldTermStructure>(qTS),
new Handle<YieldTermStructure>(rTS),
new Handle<BlackVolTermStructure>(volTS));
// MC arithmetic average-price
double runningSum = 0.0;
int pastFixings = 0;
List<Date> fixingDates1 = new InitializedList<Date>();
for (int i=0; i<=12; ++i)
fixingDates1.Add(today + new Period(i,TimeUnit.Months));
DiscreteAveragingAsianOption option1 =
new DiscreteAveragingAsianOption(Average.Type.Arithmetic, runningSum,
pastFixings, fixingDates1,
payoff, exercise);
pastFixings = 2;
runningSum = pastFixings * spot.value() * 0.8;
List<Date> fixingDates2 = new InitializedList<Date>();
for (int i=-2; i<=12; ++i)
fixingDates2.Add(today + new Period(i,TimeUnit.Months));
DiscreteAveragingAsianOption option2 =
new DiscreteAveragingAsianOption(Average.Type.Arithmetic, runningSum,
pastFixings, fixingDates2,
payoff, exercise);
IPricingEngine engine =
new MakeMCDiscreteArithmeticAPEngine<LowDiscrepancy,Statistics>(stochProcess)
.withStepsPerYear(1)
.withSamples(2047)
.value() ;
option1.setPricingEngine(engine);
option2.setPricingEngine(engine);
double price1 = option1.NPV();
double price2 = option2.NPV();
if (Utils.close(price1, price2)) {
Assert.Fail(
"past fixings had no effect on arithmetic average-price option"
+ "\n without fixings: " + price1
+ "\n with fixings: " + price2);
}
// MC arithmetic average-strike
engine = new MakeMCDiscreteArithmeticASEngine<LowDiscrepancy,Statistics>(stochProcess)
.withSamples(2047)
.value();
option1.setPricingEngine(engine);
option2.setPricingEngine(engine);
price1 = option1.NPV();
price2 = option2.NPV();
if (Utils.close(price1, price2)) {
Assert.Fail(
"past fixings had no effect on arithmetic average-strike option"
+ "\n without fixings: " + price1
+ "\n with fixings: " + price2);
}
// analytic geometric average-price
double runningProduct = 1.0;
pastFixings = 0;
DiscreteAveragingAsianOption option3 =
new DiscreteAveragingAsianOption(Average.Type.Geometric, runningProduct,
pastFixings, fixingDates1,
payoff, exercise);
pastFixings = 2;
runningProduct = spot.value() * spot.value();
DiscreteAveragingAsianOption option4 =
new DiscreteAveragingAsianOption(Average.Type.Geometric, runningProduct,
pastFixings, fixingDates2,
payoff, exercise);
engine = new AnalyticDiscreteGeometricAveragePriceAsianEngine(stochProcess);
option3.setPricingEngine(engine);
option4.setPricingEngine(engine);
double price3 = option3.NPV();
double price4 = option4.NPV();
if (Utils.close(price3, price4)) {
Assert.Fail(
"past fixings had no effect on geometric average-price option"
+ "\n without fixings: " + price3
+ "\n with fixings: " + price4);
}
// MC geometric average-price
engine = new MakeMCDiscreteGeometricAPEngine<LowDiscrepancy,Statistics>(stochProcess)
.withStepsPerYear(1)
.withSamples(2047)
.value();
option3.setPricingEngine(engine);
option4.setPricingEngine(engine);
price3 = option3.NPV();
price4 = option4.NPV();
if (Utils.close(price3, price4)) {
Assert.Fail(
"past fixings had no effect on geometric average-price option"
+ "\n without fixings: " + price3
+ "\n with fixings: " + price4);
}
}
public void visit(PlainVanillaPayoff p) { }
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();
}
}