public override void calculate()
{
if (!(arguments_.exercise.type() == Exercise.Type.European))
{
throw new Exception("not an European Option");
}
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
if (payoff == null)
{
throw new Exception("not an European Option");
}
double variance = process_.blackVolatility().link.blackVariance(arguments_.exercise.lastDate(), payoff.strike());
double dividendDiscount = process_.dividendYield().link.discount(arguments_.exercise.lastDate());
double riskFreeDiscount = process_.riskFreeRate().link.discount(arguments_.exercise.lastDate());
double drift = Math.Log(dividendDiscount / riskFreeDiscount) - 0.5 * variance;
Integrand f = new Integrand(arguments_.payoff, process_.stateVariable().link.value(), drift, variance);
SegmentIntegral integrator = new SegmentIntegral(5000);
double infinity = 10.0 * Math.Sqrt(variance);
results_.value = process_.riskFreeRate().link.discount(arguments_.exercise.lastDate()) /
Math.Sqrt(2.0 * Math.PI * variance) * integrator.value(f.value, drift - infinity, drift + infinity);
}
public AmericanPathPricer(Payoff payoff, int polynomOrder, LsmBasisSystem.PolynomType polynomType)
{
scalingValue_ = 1;
payoff_ = payoff;
v_ = LsmBasisSystem.pathBasisSystem(polynomOrder, polynomType);
if (!(polynomType == LsmBasisSystem.PolynomType.Monomial ||
polynomType == LsmBasisSystem.PolynomType.Laguerre ||
polynomType == LsmBasisSystem.PolynomType.Hermite ||
polynomType == LsmBasisSystem.PolynomType.Hyperbolic ||
polynomType == LsmBasisSystem.PolynomType.Chebyshev2th))
{
throw new Exception("insufficient polynom type");
}
// the payoff gives an additional value
v_.Add(this.payoff);
StrikedTypePayoff strikePayoff = payoff_ as StrikedTypePayoff;
if (strikePayoff != null)
{
scalingValue_ /= strikePayoff.strike();
}
}
public void REPORT_FAILURE(string greekName, Average.Type averageType,
double runningAccumulator, int pastFixings,
List<Date> fixingDates, StrikedTypePayoff payoff,
Exercise exercise, double s, double q, double r,
Date today, double v, double expected,
double calculated, double tolerance)
{
Assert.Fail(exercise + " "
+ exercise
+ " Asian option with "
+ averageType + " and "
+ payoff + " payoff:\n"
+ " running variable: "
+ runningAccumulator + "\n"
+ " past fixings: "
+ pastFixings + "\n"
+ " future fixings: " + fixingDates.Count() + "\n"
+ " underlying value: " + s + "\n"
+ " strike: " + payoff.strike() + "\n"
+ " dividend yield: " + q + "\n"
+ " risk-free rate: " + r + "\n"
+ " reference date: " + today + "\n"
+ " maturity: " + exercise.lastDate() + "\n"
+ " volatility: " + v + "\n\n"
+ " expected " + greekName + ": " + expected + "\n"
+ " calculated " + greekName + ": " + calculated + "\n"
+ " error: " + Math.Abs(expected - calculated)
+ "\n"
+ " tolerance: " + tolerance);
}
public void ensureStrikeInGrid()
{
// ensure strike is included in the grid
StrikedTypePayoff striked_payoff = payoff_ as StrikedTypePayoff;
if (striked_payoff == null)
{
return;
}
double requiredGridValue = striked_payoff.strike();
if (sMin_ > requiredGridValue / safetyZoneFactor_)
{
sMin_ = requiredGridValue / safetyZoneFactor_;
// enforce central placement of the underlying
sMax_ = center_ / (sMin_ / center_);
}
if (sMax_ < requiredGridValue * safetyZoneFactor_)
{
sMax_ = requiredGridValue * safetyZoneFactor_;
// enforce central placement of the underlying
sMin_ = center_ / (sMax_ / center_);
}
}
public BlackScholesCalculator(StrikedTypePayoff payoff, double spot, double growth, double stdDev, double discount)
: base(payoff, spot * growth / discount, stdDev, discount)
{
spot_ = spot;
growth_ = growth;
Utils.QL_REQUIRE(spot_ >= 0.0, () => "positive spot value required: " + spot_ + " not allowed");
Utils.QL_REQUIRE(growth_ >= 0.0, () => "positive growth value required: " + growth_ + " not allowed");
}
public override void calculate()
{
if (arguments_.exercise.type() != Exercise.Type.European)
{
throw new ApplicationException("not an European option");
}
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
if (payoff == null)
{
throw new ApplicationException("non-striked payoff given");
}
double variance = process_.blackVolatility().link.blackVariance(arguments_.exercise.lastDate(), payoff.strike());
double dividendDiscount = process_.dividendYield().link.discount(arguments_.exercise.lastDate());
double riskFreeDiscount = process_.riskFreeRate().link.discount(arguments_.exercise.lastDate());
double spot = process_.stateVariable().link.value();
if (!(spot > 0.0))
{
throw new ApplicationException("negative or null underlying given");
}
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);
try {
results_.theta = black.theta(spot, t);
results_.thetaPerDay = black.thetaPerDay(spot, t);
} catch {
results_.theta = null;
results_.thetaPerDay = null;
}
results_.strikeSensitivity = black.strikeSensitivity();
results_.itmCashProbability = black.itmCashProbability();
}
public AnalyticBinaryBarrierEngine_helper(
GeneralizedBlackScholesProcess process,
StrikedTypePayoff payoff,
AmericanExercise exercise,
BarrierOption.Arguments arguments)
{
process_ = process;
payoff_ = payoff;
exercise_ = exercise;
arguments_ = arguments;
}
public override void calculate()
{
Utils.QL_REQUIRE(process_.x0() > 0.0, () => "negative or null underlying given");
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-striked payoff given");
Exercise exercise = arguments_.exercise;
double t = process_.riskFreeRate().link.dayCounter().yearFraction(process_.riskFreeRate().link.referenceDate(),
exercise.lastDate());
double a = model_.link.parameters()[0];
double sigma = model_.link.parameters()[1];
double eta = process_.blackVolatility().link.blackVol(exercise.lastDate(), payoff.strike());
double varianceOffset;
if (a * t > Math.Pow(Const.QL_EPSILON, 0.25))
{
double v = sigma * sigma / (a * a) * (t + 2 / a * Math.Exp(-a * t) - 1 / (2 * a) * Math.Exp(-2 * a * t) - 3 / (2 * a));
double mu = 2 * rho_ * sigma * eta / a * (t - 1 / a * (1 - Math.Exp(-a * t)));
varianceOffset = v + mu;
}
else
{
// low-a algebraic limit
double v = sigma * sigma * t * t * t * (1 / 3.0 - 0.25 * a * t + 7 / 60.0 * a * a * t * t);
double mu = rho_ * sigma * eta * t * t * (1 - a * t / 3.0 + a * a * t * t / 12.0);
varianceOffset = v + mu;
}
Handle <BlackVolTermStructure> volTS = new Handle <BlackVolTermStructure>(
new ShiftedBlackVolTermStructure(varianceOffset, process_.blackVolatility()));
GeneralizedBlackScholesProcess adjProcess =
new GeneralizedBlackScholesProcess(process_.stateVariable(),
process_.dividendYield(),
process_.riskFreeRate(),
volTS);
AnalyticEuropeanEngine bsmEngine = new AnalyticEuropeanEngine(adjProcess);
VanillaOption option = new VanillaOption(payoff, exercise);
option.setupArguments(bsmEngine.getArguments());
bsmEngine.calculate();
results_ = bsmEngine.getResults() as OneAssetOption.Results;
}
public DividendBarrierOption(Barrier.Type barrierType,
double barrier,
double rebate,
StrikedTypePayoff payoff,
Exercise exercise,
List <Date> dividendDates,
List <double> dividends)
: base(barrierType, barrier, rebate, payoff, exercise)
{
cashFlow_ = Utils.DividendVector(dividendDates, dividends);
}
public BlackScholesCalculator(StrikedTypePayoff payoff, double spot, double growth, double stdDev, double discount)
: base(payoff, spot * growth / discount, stdDev, discount)
{
spot_ = spot;
growth_ = growth;
if (!(spot_ >= 0.0))
throw new ApplicationException("positive spot value required: " + spot_ + " not allowed");
if (!(growth_ >= 0.0))
throw new ApplicationException("positive growth value required: " + growth_ + " not allowed");
}
public override void calculate()
{
// 1. Mesher
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
double maturity = process_.time(arguments_.exercise.lastDate());
Fdm1dMesher equityMesher =
new FdmBlackScholesMesher(
xGrid_, process_, maturity, payoff.strike(),
null, null, 0.0001, 1.5,
new Pair <double?, double?>(payoff.strike(), 0.1));
FdmMesher mesher =
new FdmMesherComposite(equityMesher);
// 2. Calculator
FdmInnerValueCalculator calculator = new FdmLogInnerValue(payoff, mesher, 0);
// 3. Step conditions
FdmStepConditionComposite conditions = FdmStepConditionComposite.vanillaComposite(
arguments_.cashFlow, arguments_.exercise,
mesher, calculator,
process_.riskFreeRate().currentLink().referenceDate(),
process_.riskFreeRate().currentLink().dayCounter());
// 4. Boundary conditions
FdmBoundaryConditionSet boundaries = new FdmBoundaryConditionSet();
// 5. Solver
FdmSolverDesc solverDesc = new FdmSolverDesc();
solverDesc.mesher = mesher;
solverDesc.bcSet = boundaries;
solverDesc.condition = conditions;
solverDesc.calculator = calculator;
solverDesc.maturity = maturity;
solverDesc.dampingSteps = dampingSteps_;
solverDesc.timeSteps = tGrid_;
FdmBlackScholesSolver solver =
new FdmBlackScholesSolver(
new Handle <GeneralizedBlackScholesProcess>(process_),
payoff.strike(), solverDesc, schemeDesc_,
localVol_, illegalLocalVolOverwrite_);
double spot = process_.x0();
results_.value = solver.valueAt(spot);
results_.delta = solver.deltaAt(spot);
results_.gamma = solver.gammaAt(spot);
results_.theta = solver.thetaAt(spot);
}
protected override PathPricer <IPath> controlPathPricer()
{
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
Utils.QL_REQUIRE(payoff != null, () => "StrikedTypePayoff needed for control variate");
GeneralizedBlackScholesProcess process = process_ as GeneralizedBlackScholesProcess;
Utils.QL_REQUIRE(process != null, () => "generalized Black-Scholes process required");
return(new EuropeanPathPricer(payoff.optionType(), payoff.strike(),
process.riskFreeRate().link.discount(timeGrid().Last())));
}
private double vanillaEquivalent()
{
// Call KI equates to vanilla - callKO
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
double forwardPrice = underlying() * dividendDiscount() / riskFreeDiscount();
BlackCalculator black = new BlackCalculator(payoff, forwardPrice, stdDeviation(), riskFreeDiscount());
double vanilla = black.value();
if (vanilla < 0.0)
{
vanilla = 0.0;
}
return(vanilla);
}
public BlackScholesCalculator(StrikedTypePayoff payoff, double spot, double growth, double stdDev, double discount)
: base(payoff, spot * growth / discount, stdDev, discount)
{
spot_ = spot;
growth_ = growth;
if (!(spot_ >= 0.0))
{
throw new Exception("positive spot value required: " + spot_ + " not allowed");
}
if (!(growth_ >= 0.0))
{
throw new Exception("positive growth value required: " + growth_ + " not allowed");
}
}
protected void setup()
{
StrikedTypePayoff argumentsPayoff = this.arguments_.payoff as StrikedTypePayoff;
Utils.QL_REQUIRE(argumentsPayoff != null, () => "wrong payoff given");
StrikedTypePayoff payoff = new PlainVanillaPayoff(argumentsPayoff.optionType(),
this.arguments_.moneyness * process_.x0());
// maybe the forward value is "better", in some fashion
// the right level is needed in order to interpolate
// the vol
Handle <Quote> spot = process_.stateVariable();
Utils.QL_REQUIRE(spot.link.value() >= 0.0, () => "negative or null underlting given");
Handle <YieldTermStructure> dividendYield = new Handle <YieldTermStructure>(
new ImpliedTermStructure(process_.dividendYield(), this.arguments_.resetDate));
Handle <YieldTermStructure> riskFreeRate = new Handle <YieldTermStructure>(
new ImpliedTermStructure(process_.riskFreeRate(), this.arguments_.resetDate));
// The following approach is ok if the vol is at most
// time dependant. It is plain wrong if it is asset dependant.
// In the latter case the right solution would be stochastic
// volatility or at least local volatility (which unfortunately
// implies an unrealistic time-decreasing smile)
Handle <BlackVolTermStructure> blackVolatility = new Handle <BlackVolTermStructure>(
new ImpliedVolTermStructure(process_.blackVolatility(), this.arguments_.resetDate));
GeneralizedBlackScholesProcess fwdProcess = new GeneralizedBlackScholesProcess(spot, dividendYield,
riskFreeRate, blackVolatility);
originalEngine_ = getOriginalEngine_(fwdProcess);
originalEngine_.reset();
originalArguments_ = originalEngine_.getArguments() as Option.Arguments;
Utils.QL_REQUIRE(originalArguments_ != null, () => "wrong engine type");
originalResults_ = originalEngine_.getResults() as OneAssetOption.Results;
Utils.QL_REQUIRE(originalResults_ != null, () => "wrong engine type");
originalArguments_.payoff = payoff;
originalArguments_.exercise = this.arguments_.exercise;
originalArguments_.validate();
}
protected override PathPricer <IPath> controlPathPricer()
{
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
if (payoff == null)
{
throw new Exception("StrikedTypePayoff needed for control variate");
}
GeneralizedBlackScholesProcess process = process_ as GeneralizedBlackScholesProcess;
if (process == null)
{
throw new Exception("generalized Black-Scholes process required");
}
return(new EuropeanPathPricer(payoff.optionType(), payoff.strike(),
process.riskFreeRate().link.discount(timeGrid().Last())));
}
// public BlackCalculator(StrikedTypePayoff payoff, double forward, double stdDev, double discount = 1.0) {
public BlackCalculator(StrikedTypePayoff payoff, double forward, double stdDev, double discount) {
strike_ = payoff.strike();
forward_ = forward;
stdDev_ = stdDev;
discount_ = discount;
variance_ = stdDev*stdDev;
if (!(forward>0.0))
throw new ApplicationException("positive forward value required: " + forward + " not allowed");
if (!(stdDev>=0.0))
throw new ApplicationException("non-negative standard deviation required: " + stdDev + " not allowed");
if (!(discount>0.0))
throw new ApplicationException("positive discount required: " + discount + " not allowed");
if (stdDev_>=Const.QL_EPSILON) {
if (strike_==0.0) {
n_d1_ = 0.0;
n_d2_ = 0.0;
cum_d1_ = 1.0;
cum_d2_= 1.0;
} else {
D1_ = Math.Log(forward/strike_)/stdDev_ + 0.5*stdDev_;
D2_ = D1_-stdDev_;
CumulativeNormalDistribution f = new CumulativeNormalDistribution();
cum_d1_ = f.value(D1_);
cum_d2_= f.value(D2_);
n_d1_ = f.derivative(D1_);
n_d2_ = f.derivative(D2_);
}
} else {
if (forward>strike_) {
cum_d1_ = 1.0;
cum_d2_= 1.0;
} else {
cum_d1_ = 0.0;
cum_d2_= 0.0;
}
n_d1_ = 0.0;
n_d2_ = 0.0;
}
X_ = strike_;
DXDstrike_ = 1.0;
// the following one will probably disappear as soon as
// super-share will be properly handled
DXDs_ = 0.0;
// this part is always executed.
// in case of plain-vanilla payoffs, it is also the only part
// which is executed.
switch (payoff.optionType()) {
case Option.Type.Call:
alpha_ = cum_d1_;// N(d1)
DalphaDd1_ = n_d1_;// n(d1)
beta_ = -cum_d2_;// -N(d2)
DbetaDd2_ = - n_d2_;// -n(d2)
break;
case Option.Type.Put:
alpha_ = -1.0+cum_d1_;// -N(-d1)
DalphaDd1_ = n_d1_;// n( d1)
beta_ = 1.0-cum_d2_;// N(-d2)
DbetaDd2_ = - n_d2_;// -n( d2)
break;
default:
throw new ArgumentException("invalid option type");
}
// now dispatch on type.
Calculator calc = new Calculator(this);
payoff.accept(calc);
}
public override void calculate()
{
// 1. Mesher
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
double maturity = process_.time(arguments_.exercise.lastDate());
double?xMin = null;
double?xMax = null;
if (arguments_.barrierType == Barrier.Type.DownIn ||
arguments_.barrierType == Barrier.Type.DownOut)
{
xMin = Math.Log(arguments_.barrier.Value);
}
if (arguments_.barrierType == Barrier.Type.UpIn ||
arguments_.barrierType == Barrier.Type.UpOut)
{
xMax = Math.Log(arguments_.barrier.Value);
}
Fdm1dMesher equityMesher =
new FdmBlackScholesMesher(xGrid_, process_, maturity,
payoff.strike(), xMin, xMax);
FdmMesher mesher =
new FdmMesherComposite(equityMesher);
// 2. Calculator
StrikedTypePayoff rebatePayoff =
new CashOrNothingPayoff(Option.Type.Call, 0.0, arguments_.rebate.Value);
FdmInnerValueCalculator calculator =
new FdmLogInnerValue(rebatePayoff, mesher, 0);
// 3. Step conditions
Utils.QL_REQUIRE(arguments_.exercise.type() == Exercise.Type.European,
() => "only european style option are supported");
FdmStepConditionComposite conditions =
FdmStepConditionComposite.vanillaComposite(
arguments_.cashFlow, arguments_.exercise,
mesher, calculator,
process_.riskFreeRate().currentLink().referenceDate(),
process_.riskFreeRate().currentLink().dayCounter());
// 4. Boundary conditions
FdmBoundaryConditionSet boundaries = new FdmBoundaryConditionSet();
if (arguments_.barrierType == Barrier.Type.DownIn ||
arguments_.barrierType == Barrier.Type.DownOut)
{
boundaries.Add(new FdmDirichletBoundary(mesher, arguments_.rebate.Value, 0,
FdmDirichletBoundary.Side.Lower));
}
if (arguments_.barrierType == Barrier.Type.UpIn ||
arguments_.barrierType == Barrier.Type.UpOut)
{
boundaries.Add(new FdmDirichletBoundary(mesher, arguments_.rebate.Value, 0,
FdmDirichletBoundary.Side.Upper));
}
// 5. Solver
FdmSolverDesc solverDesc = new FdmSolverDesc();
solverDesc.mesher = mesher;
solverDesc.bcSet = boundaries;
solverDesc.condition = conditions;
solverDesc.calculator = calculator;
solverDesc.maturity = maturity;
solverDesc.dampingSteps = dampingSteps_;
solverDesc.timeSteps = tGrid_;
FdmBlackScholesSolver solver =
new FdmBlackScholesSolver(
new Handle <GeneralizedBlackScholesProcess>(process_),
payoff.strike(), solverDesc, schemeDesc_,
localVol_, illegalLocalVolOverwrite_);
double spot = process_.x0();
results_.value = solver.valueAt(spot);
results_.delta = solver.deltaAt(spot);
results_.gamma = solver.gammaAt(spot);
results_.theta = solver.thetaAt(spot);
}
public AmericanPayoffAtHit(double spot, double discount, double dividendDiscount, double variance, StrikedTypePayoff payoff) {
spot_ = spot;
discount_ = discount;
dividendDiscount_ = dividendDiscount;
variance_ = variance;
if (!(spot_ > 0.0))
throw new ApplicationException("positive spot value required");
if (!(discount_ > 0.0))
throw new ApplicationException("positive discount required");
if (!(dividendDiscount_ > 0.0))
throw new ApplicationException("positive dividend discount required");
if (!(variance_ >= 0.0))
throw new ApplicationException("negative variance not allowed");
stdDev_ = Math.Sqrt(variance_);
Option.Type type = payoff.optionType();
strike_ = payoff.strike();
log_H_S_ = Math.Log(strike_ / spot_);
double n_d1;
double n_d2;
double cum_d1_;
double cum_d2_;
if (variance_ >= Const.QL_Epsilon) {
if (discount_ == 0.0 && dividendDiscount_ == 0.0) {
mu_ = -0.5;
lambda_ = 0.5;
} else if (discount_ == 0.0) {
throw new ApplicationException("null discount not handled yet");
} else {
mu_ = Math.Log(dividendDiscount_ / discount_) / variance_ - 0.5;
lambda_ = Math.Sqrt(mu_ * mu_ - 2.0 * Math.Log(discount_) / variance_);
}
D1_ = log_H_S_ / stdDev_ + lambda_ * stdDev_;
D2_ = D1_ - 2.0 * lambda_ * stdDev_;
CumulativeNormalDistribution f = new CumulativeNormalDistribution();
cum_d1_ = f.value(D1_);
cum_d2_ = f.value(D2_);
n_d1 = f.derivative(D1_);
n_d2 = f.derivative(D2_);
} else {
// not tested yet
mu_ = Math.Log(dividendDiscount_ / discount_) / variance_ - 0.5;
lambda_ = Math.Sqrt(mu_ * mu_ - 2.0 * Math.Log(discount_) / variance_);
if (log_H_S_ > 0) {
cum_d1_ = 1.0;
cum_d2_ = 1.0;
} else {
cum_d1_ = 0.0;
cum_d2_ = 0.0;
}
n_d1 = 0.0;
n_d2 = 0.0;
}
switch (type) {
// up-and-in cash-(at-hit)-or-nothing option
// a.k.a. american call with cash-or-nothing payoff
case Option.Type.Call:
if (strike_ > spot_) {
alpha_ = 1.0 - cum_d1_; // N(-d1)
DalphaDd1_ = -n_d1; // -n( d1)
beta_ = 1.0 - cum_d2_; // N(-d2)
DbetaDd2_ = -n_d2; // -n( d2)
} else {
alpha_ = 0.5;
DalphaDd1_ = 0.0;
beta_ = 0.5;
DbetaDd2_ = 0.0;
}
break;
// down-and-in cash-(at-hit)-or-nothing option
// a.k.a. american put with cash-or-nothing payoff
case Option.Type.Put:
if (strike_ < spot_) {
alpha_ = cum_d1_; // N(d1)
DalphaDd1_ = n_d1; // n(d1)
beta_ = cum_d2_; // N(d2)
DbetaDd2_ = n_d2; // n(d2)
} else {
alpha_ = 0.5;
DalphaDd1_ = 0.0;
beta_ = 0.5;
DbetaDd2_ = 0.0;
}
break;
default:
throw new ApplicationException("invalid option type");
}
muPlusLambda_ = mu_ + lambda_;
muMinusLambda_ = mu_ - lambda_;
inTheMoney_ = (type == Option.Type.Call && strike_ < spot_) || (type == Option.Type.Put && strike_ > spot_);
if (inTheMoney_) {
forward_ = 1.0;
X_ = 1.0;
DXDstrike_ = 0.0;
} else {
forward_ = Math.Pow(strike_ / spot_, muPlusLambda_);
X_ = Math.Pow(strike_ / spot_, muMinusLambda_);
// DXDstrike_ = ......;
}
// Binary Cash-Or-Nothing payoff?
CashOrNothingPayoff coo = payoff as CashOrNothingPayoff;
if (coo != null) {
K_ = coo.cashPayoff();
DKDstrike_ = 0.0;
}
// Binary Asset-Or-Nothing payoff?
AssetOrNothingPayoff aoo = payoff as AssetOrNothingPayoff;
if (aoo != null) {
if (inTheMoney_) {
K_ = spot_;
DKDstrike_ = 0.0;
} else {
K_ = aoo.strike();
DKDstrike_ = 1.0;
}
}
}
// critical commodity price
//public static double criticalPrice(StrikedTypePayoff payoff, double riskFreeDiscount, double dividendDiscount,
// double variance, double tolerance = 1e-6);
public static double criticalPrice(StrikedTypePayoff payoff, double riskFreeDiscount, double dividendDiscount,
double variance, double tolerance)
{
// Calculation of seed value, Si
double n= 2.0*Math.Log(dividendDiscount/riskFreeDiscount)/(variance);
double m=-2.0*Math.Log(riskFreeDiscount)/(variance);
double bT = Math.Log(dividendDiscount/riskFreeDiscount);
double qu, Su, h, Si;
switch (payoff.optionType()) {
case Option.Type.Call:
qu = (-(n-1.0) + Math.Sqrt(((n-1.0)*(n-1.0)) + 4.0*m))/2.0;
Su = payoff.strike() / (1.0 - 1.0/qu);
h = -(bT + 2.0*Math.Sqrt(variance)) * payoff.strike() /
(Su - payoff.strike());
Si = payoff.strike() + (Su - payoff.strike()) *
(1.0 - Math.Exp(h));
break;
case Option.Type.Put:
qu = (-(n-1.0) - Math.Sqrt(((n-1.0)*(n-1.0)) + 4.0*m))/2.0;
Su = payoff.strike() / (1.0 - 1.0/qu);
h = (bT - 2.0*Math.Sqrt(variance)) * payoff.strike() /
(payoff.strike() - Su);
Si = Su + (payoff.strike() - Su) * Math.Exp(h);
break;
default:
throw new ArgumentException("unknown option type");
}
// Newton Raphson algorithm for finding critical price Si
double Q, LHS, RHS, bi;
double forwardSi = Si * dividendDiscount / riskFreeDiscount;
double d1 = (Math.Log(forwardSi/payoff.strike()) + 0.5*variance) /
Math.Sqrt(variance);
CumulativeNormalDistribution cumNormalDist = new CumulativeNormalDistribution();
double K = (riskFreeDiscount!=1.0 ? -2.0*Math.Log(riskFreeDiscount)/
(variance*(1.0-riskFreeDiscount)) : 0.0);
double temp = Utils.blackFormula(payoff.optionType(), payoff.strike(),
forwardSi, Math.Sqrt(variance))*riskFreeDiscount;
switch (payoff.optionType()) {
case Option.Type.Call:
Q = (-(n-1.0) + Math.Sqrt(((n-1.0)*(n-1.0)) + 4 * K)) / 2;
LHS = Si - payoff.strike();
RHS = temp + (1 - dividendDiscount * cumNormalDist.value(d1)) * Si / Q;
bi = dividendDiscount * cumNormalDist.value(d1) * (1 - 1 / Q) +
(1 - dividendDiscount *
cumNormalDist.derivative(d1) / Math.Sqrt(variance)) / Q;
while (Math.Abs(LHS - RHS)/payoff.strike() > tolerance) {
Si = (payoff.strike() + RHS - bi * Si) / (1 - bi);
forwardSi = Si * dividendDiscount / riskFreeDiscount;
d1 = (Math.Log(forwardSi/payoff.strike())+0.5*variance)
/Math.Sqrt(variance);
LHS = Si - payoff.strike();
double temp2 = Utils.blackFormula(payoff.optionType(), payoff.strike(),
forwardSi, Math.Sqrt(variance))*riskFreeDiscount;
RHS = temp2 + (1 - dividendDiscount * cumNormalDist.value(d1)) * Si / Q;
bi = dividendDiscount * cumNormalDist.value(d1) * (1 - 1 / Q)
+ (1 - dividendDiscount *
cumNormalDist.derivative(d1) / Math.Sqrt(variance))
/ Q;
}
break;
case Option.Type.Put:
Q = (-(n-1.0) - Math.Sqrt(((n-1.0)*(n-1.0)) + 4 * K)) / 2;
LHS = payoff.strike() - Si;
RHS = temp - (1 - dividendDiscount * cumNormalDist.value(-d1)) * Si / Q;
bi = -dividendDiscount * cumNormalDist.value(-d1) * (1 - 1 / Q)
- (1 + dividendDiscount * cumNormalDist.derivative(-d1)
/ Math.Sqrt(variance)) / Q;
while (Math.Abs(LHS - RHS)/payoff.strike() > tolerance) {
Si = (payoff.strike() - RHS + bi * Si) / (1 + bi);
forwardSi = Si * dividendDiscount / riskFreeDiscount;
d1 = (Math.Log(forwardSi/payoff.strike())+0.5*variance)
/Math.Sqrt(variance);
LHS = payoff.strike() - Si;
double temp2 = Utils.blackFormula(payoff.optionType(), payoff.strike(),
forwardSi, Math.Sqrt(variance))*riskFreeDiscount;
RHS = temp2 - (1 - dividendDiscount * cumNormalDist.value(-d1)) * Si / Q;
bi = -dividendDiscount * cumNormalDist.value(-d1) * (1 - 1 / Q)
- (1 + dividendDiscount * cumNormalDist.derivative(-d1)
/ Math.Sqrt(variance)) / Q;
}
break;
default:
throw new ArgumentException("unknown option type");
}
return Si;
}
public ContinuousAveragingAsianOption(Average.Type averageType, StrikedTypePayoff payoff, Exercise exercise) : base(payoff, exercise)
{
averageType_ = averageType;
}
// public BlackCalculator(StrikedTypePayoff payoff, double forward, double stdDev, double discount = 1.0) {
public BlackCalculator(StrikedTypePayoff payoff, double forward, double stdDev, double discount)
{
strike_ = payoff.strike();
forward_ = forward;
stdDev_ = stdDev;
discount_ = discount;
variance_ = stdDev * stdDev;
if (!(forward > 0.0))
{
throw new ApplicationException("positive forward value required: " + forward + " not allowed");
}
if (!(stdDev >= 0.0))
{
throw new ApplicationException("non-negative standard deviation required: " + stdDev + " not allowed");
}
if (!(discount > 0.0))
{
throw new ApplicationException("positive discount required: " + discount + " not allowed");
}
if (stdDev_ >= Const.QL_Epsilon)
{
if (strike_ == 0.0)
{
n_d1_ = 0.0;
n_d2_ = 0.0;
cum_d1_ = 1.0;
cum_d2_ = 1.0;
}
else
{
D1_ = Math.Log(forward / strike_) / stdDev_ + 0.5 * stdDev_;
D2_ = D1_ - stdDev_;
CumulativeNormalDistribution f = new CumulativeNormalDistribution();
cum_d1_ = f.value(D1_);
cum_d2_ = f.value(D2_);
n_d1_ = f.derivative(D1_);
n_d2_ = f.derivative(D2_);
}
}
else
{
if (forward > strike_)
{
cum_d1_ = 1.0;
cum_d2_ = 1.0;
}
else
{
cum_d1_ = 0.0;
cum_d2_ = 0.0;
}
n_d1_ = 0.0;
n_d2_ = 0.0;
}
X_ = strike_;
DXDstrike_ = 1.0;
// the following one will probably disappear as soon as
// super-share will be properly handled
DXDs_ = 0.0;
// this part is always executed.
// in case of plain-vanilla payoffs, it is also the only part
// which is executed.
switch (payoff.optionType())
{
case Option.Type.Call:
alpha_ = cum_d1_; // N(d1)
DalphaDd1_ = n_d1_; // n(d1)
beta_ = -cum_d2_; // -N(d2)
DbetaDd2_ = -n_d2_; // -n(d2)
break;
case Option.Type.Put:
alpha_ = -1.0 + cum_d1_; // -N(-d1)
DalphaDd1_ = n_d1_; // n( d1)
beta_ = 1.0 - cum_d2_; // N(-d2)
DbetaDd2_ = -n_d2_; // -n( d2)
break;
default:
throw new ArgumentException("invalid option type");
}
// now dispatch on type.
Calculator calc = new Calculator(this);
payoff.accept(calc);
}
public VanillaOption(StrikedTypePayoff payoff, Exercise exercise) : base(payoff, exercise)
{
}
public override void calculate()
{
AmericanExercise ex = arguments_.exercise as AmericanExercise;
Utils.QL_REQUIRE(ex != null, () => "non-American exercise given");
Utils.QL_REQUIRE(ex.payoffAtExpiry(), () => "payoff must be at expiry");
Utils.QL_REQUIRE(ex.dates()[0] <= process_.blackVolatility().link.referenceDate(), () =>
"American option with window exercise not handled yet");
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-striked payoff given");
double spot = process_.stateVariable().link.value();
Utils.QL_REQUIRE(spot > 0.0, () => "negative or null underlying given");
double variance = process_.blackVolatility().link.blackVariance(ex.lastDate(), payoff.strike());
double?barrier = arguments_.barrier;
Utils.QL_REQUIRE(barrier > 0.0, () => "positive barrier value required");
Barrier.Type barrierType = arguments_.barrierType;
// KO degenerate cases
if ((barrierType == Barrier.Type.DownOut && spot <= barrier) ||
(barrierType == Barrier.Type.UpOut && spot >= barrier))
{
// knocked out, no value
results_.value = 0;
results_.delta = 0;
results_.gamma = 0;
results_.vega = 0;
results_.theta = 0;
results_.rho = 0;
results_.dividendRho = 0;
return;
}
// KI degenerate cases
if ((barrierType == Barrier.Type.DownIn && spot <= barrier) ||
(barrierType == Barrier.Type.UpIn && spot >= barrier))
{
// knocked in - is a digital european
Exercise exercise = new EuropeanExercise(arguments_.exercise.lastDate());
IPricingEngine engine = new AnalyticEuropeanEngine(process_);
VanillaOption opt = new VanillaOption(payoff, exercise);
opt.setPricingEngine(engine);
results_.value = opt.NPV();
results_.delta = opt.delta();
results_.gamma = opt.gamma();
results_.vega = opt.vega();
results_.theta = opt.theta();
results_.rho = opt.rho();
results_.dividendRho = opt.dividendRho();
return;
}
double riskFreeDiscount = process_.riskFreeRate().link.discount(ex.lastDate());
AnalyticBinaryBarrierEngine_helper helper = new AnalyticBinaryBarrierEngine_helper(
process_, payoff, ex, arguments_);
results_.value = helper.payoffAtExpiry(spot, variance, riskFreeDiscount);
}
public override void calculate()
{
double sigmaShift_vega = 0.001;
double sigmaShift_volga = 0.0001;
double spotShift_delta = 0.0001 * spotFX_.link.value();
double sigmaShift_vanna = 0.0001;
Utils.QL_REQUIRE(arguments_.barrierType == DoubleBarrier.Type.KnockIn ||
arguments_.barrierType == DoubleBarrier.Type.KnockOut, () =>
"Only same type barrier supported");
Handle <Quote> x0Quote = new Handle <Quote>(new SimpleQuote(spotFX_.link.value()));
Handle <Quote> atmVolQuote = new Handle <Quote>(new SimpleQuote(atmVol_.link.value()));
BlackVolTermStructure blackVolTS = new BlackConstantVol(Settings.evaluationDate(),
new NullCalendar(), atmVolQuote, new Actual365Fixed());
BlackScholesMertonProcess stochProcess = new BlackScholesMertonProcess(x0Quote, foreignTS_, domesticTS_,
new Handle <BlackVolTermStructure>(blackVolTS));
IPricingEngine engineBS = getOriginalEngine_(stochProcess, series_);
BlackDeltaCalculator blackDeltaCalculatorAtm = new BlackDeltaCalculator(
Option.Type.Call, atmVol_.link.deltaType(), x0Quote.link.value(),
domesticTS_.link.discount(T_), foreignTS_.link.discount(T_),
atmVol_.link.value() * Math.Sqrt(T_));
double atmStrike = blackDeltaCalculatorAtm.atmStrike(atmVol_.link.atmType());
double call25Vol = vol25Call_.link.value();
double put25Vol = vol25Put_.link.value();
BlackDeltaCalculator blackDeltaCalculatorPut25 = new BlackDeltaCalculator(
Option.Type.Put, vol25Put_.link.deltaType(), x0Quote.link.value(),
domesticTS_.link.discount(T_), foreignTS_.link.discount(T_),
put25Vol * Math.Sqrt(T_));
double put25Strike = blackDeltaCalculatorPut25.strikeFromDelta(-0.25);
BlackDeltaCalculator blackDeltaCalculatorCall25 = new BlackDeltaCalculator(
Option.Type.Call, vol25Call_.link.deltaType(), x0Quote.link.value(),
domesticTS_.link.discount(T_), foreignTS_.link.discount(T_),
call25Vol * Math.Sqrt(T_));
double call25Strike = blackDeltaCalculatorCall25.strikeFromDelta(0.25);
//here use vanna volga interpolated smile to price vanilla
List <double> strikes = new List <double>();
List <double> vols = new List <double>();
strikes.Add(put25Strike);
vols.Add(put25Vol);
strikes.Add(atmStrike);
vols.Add(atmVol_.link.value());
strikes.Add(call25Strike);
vols.Add(call25Vol);
VannaVolga vannaVolga = new VannaVolga(x0Quote.link.value(), foreignTS_.link.discount(T_),
foreignTS_.link.discount(T_), T_);
Interpolation interpolation = vannaVolga.interpolate(strikes, strikes.Count, vols);
interpolation.enableExtrapolation();
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
Utils.QL_REQUIRE(payoff != null, () => "invalid payoff");
double strikeVol = interpolation.value(payoff.strike());
//vannila option price
double vanillaOption = Utils.blackFormula(payoff.optionType(), payoff.strike(),
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
strikeVol * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
//already out
if ((x0Quote.link.value() > arguments_.barrier_hi || x0Quote.link.value() < arguments_.barrier_lo) &&
arguments_.barrierType == DoubleBarrier.Type.KnockOut)
{
results_.value = 0.0;
results_.additionalResults["VanillaPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierInPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierOutPrice"] = 0.0;
}
//already in
else if ((x0Quote.link.value() > arguments_.barrier_hi || x0Quote.link.value() < arguments_.barrier_lo) &&
arguments_.barrierType == DoubleBarrier.Type.KnockIn)
{
results_.value = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["VanillaPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierInPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierOutPrice"] = 0.0;
}
else
{
//set up BS barrier option pricing
//only calculate out barrier option price
// in barrier price = vanilla - out barrier
//StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
DoubleBarrierOption doubleBarrierOption = new DoubleBarrierOption(
arguments_.barrierType,
arguments_.barrier_lo.GetValueOrDefault(),
arguments_.barrier_hi.GetValueOrDefault(),
arguments_.rebate.GetValueOrDefault(),
payoff,
arguments_.exercise);
doubleBarrierOption.setPricingEngine(engineBS);
//BS price
double priceBS = doubleBarrierOption.NPV();
double priceAtmCallBS = Utils.blackFormula(Option.Type.Call, atmStrike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
atmVol_.link.value() * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
double price25CallBS = Utils.blackFormula(Option.Type.Call, call25Strike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
atmVol_.link.value() * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
double price25PutBS = Utils.blackFormula(Option.Type.Put, put25Strike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
atmVol_.link.value() * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
//market price
double priceAtmCallMkt = Utils.blackFormula(Option.Type.Call, atmStrike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
atmVol_.link.value() * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
double price25CallMkt = Utils.blackFormula(Option.Type.Call, call25Strike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
call25Vol * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
double price25PutMkt = Utils.blackFormula(Option.Type.Put, put25Strike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
put25Vol * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
//Analytical Black Scholes formula
NormalDistribution norm = new NormalDistribution();
double d1atm = (Math.Log(x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_) / atmStrike)
+ 0.5 * Math.Pow(atmVolQuote.link.value(), 2.0) * T_) / (atmVolQuote.link.value() * Math.Sqrt(T_));
double vegaAtm_Analytical = x0Quote.link.value() * norm.value(d1atm) * Math.Sqrt(T_) * foreignTS_.link.discount(T_);
double vannaAtm_Analytical = vegaAtm_Analytical / x0Quote.link.value() * (1.0 - d1atm / (atmVolQuote.link.value() * Math.Sqrt(T_)));
double volgaAtm_Analytical = vegaAtm_Analytical * d1atm * (d1atm - atmVolQuote.link.value() * Math.Sqrt(T_)) / atmVolQuote.link.value();
double d125call = (Math.Log(x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_) / call25Strike)
+ 0.5 * Math.Pow(atmVolQuote.link.value(), 2.0) * T_) / (atmVolQuote.link.value() * Math.Sqrt(T_));
double vega25Call_Analytical = x0Quote.link.value() * norm.value(d125call) * Math.Sqrt(T_) * foreignTS_.link.discount(T_);
double vanna25Call_Analytical = vega25Call_Analytical / x0Quote.link.value() * (1.0 - d125call / (atmVolQuote.link.value() * Math.Sqrt(T_)));
double volga25Call_Analytical = vega25Call_Analytical * d125call * (d125call - atmVolQuote.link.value() * Math.Sqrt(T_)) / atmVolQuote.link.value();
double d125Put = (Math.Log(x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_) / put25Strike)
+ 0.5 * Math.Pow(atmVolQuote.link.value(), 2.0) * T_) / (atmVolQuote.link.value() * Math.Sqrt(T_));
double vega25Put_Analytical = x0Quote.link.value() * norm.value(d125Put) * Math.Sqrt(T_) * foreignTS_.link.discount(T_);
double vanna25Put_Analytical = vega25Put_Analytical / x0Quote.link.value() * (1.0 - d125Put / (atmVolQuote.link.value() * Math.Sqrt(T_)));
double volga25Put_Analytical = vega25Put_Analytical * d125Put * (d125Put - atmVolQuote.link.value() * Math.Sqrt(T_)) / atmVolQuote.link.value();
//BS vega
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() + sigmaShift_vega);
doubleBarrierOption.recalculate();
double vegaBarBS = (doubleBarrierOption.NPV() - priceBS) / sigmaShift_vega;
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() - sigmaShift_vega);//setback
//BS volga
//vegaBar2
//base NPV
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() + sigmaShift_volga);
doubleBarrierOption.recalculate();
double priceBS2 = doubleBarrierOption.NPV();
//shifted npv
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() + sigmaShift_vega);
doubleBarrierOption.recalculate();
double vegaBarBS2 = (doubleBarrierOption.NPV() - priceBS2) / sigmaShift_vega;
double volgaBarBS = (vegaBarBS2 - vegaBarBS) / sigmaShift_volga;
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value()
- sigmaShift_volga
- sigmaShift_vega); //setback
//BS Delta
//base delta
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() + spotShift_delta);//shift forth
doubleBarrierOption.recalculate();
double priceBS_delta1 = doubleBarrierOption.NPV();
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() - 2 * spotShift_delta);//shift back
doubleBarrierOption.recalculate();
double priceBS_delta2 = doubleBarrierOption.NPV();
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() + spotShift_delta);//set back
double deltaBar1 = (priceBS_delta1 - priceBS_delta2) / (2.0 * spotShift_delta);
//shifted vanna
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() + sigmaShift_vanna); //shift sigma
//shifted delta
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() + spotShift_delta); //shift forth
doubleBarrierOption.recalculate();
priceBS_delta1 = doubleBarrierOption.NPV();
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() - 2 * spotShift_delta);//shift back
doubleBarrierOption.recalculate();
priceBS_delta2 = doubleBarrierOption.NPV();
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() + spotShift_delta);//set back
double deltaBar2 = (priceBS_delta1 - priceBS_delta2) / (2.0 * spotShift_delta);
double vannaBarBS = (deltaBar2 - deltaBar1) / sigmaShift_vanna;
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() - sigmaShift_vanna);//set back
//Matrix
Matrix A = new Matrix(3, 3, 0.0);
//analytical
A[0, 0] = vegaAtm_Analytical;
A[0, 1] = vega25Call_Analytical;
A[0, 2] = vega25Put_Analytical;
A[1, 0] = vannaAtm_Analytical;
A[1, 1] = vanna25Call_Analytical;
A[1, 2] = vanna25Put_Analytical;
A[2, 0] = volgaAtm_Analytical;
A[2, 1] = volga25Call_Analytical;
A[2, 2] = volga25Put_Analytical;
Vector b = new Vector(3, 0.0);
b[0] = vegaBarBS;
b[1] = vannaBarBS;
b[2] = volgaBarBS;
Vector q = Matrix.inverse(A) * b;
double H = arguments_.barrier_hi.GetValueOrDefault();
double L = arguments_.barrier_lo.GetValueOrDefault();
double theta_tilt_minus = ((domesticTS_.link.zeroRate(T_, Compounding.Continuous).value() -
foreignTS_.link.zeroRate(T_, Compounding.Continuous).value()) /
atmVol_.link.value() - atmVol_.link.value() / 2.0) * Math.Sqrt(T_);
double h = 1.0 / atmVol_.link.value() * Math.Log(H / x0Quote.link.value()) / Math.Sqrt(T_);
double l = 1.0 / atmVol_.link.value() * Math.Log(L / x0Quote.link.value()) / Math.Sqrt(T_);
CumulativeNormalDistribution cnd = new CumulativeNormalDistribution();
double doubleNoTouch = 0.0;
for (int j = -series_; j < series_; j++)
{
double e_minus = 2 * j * (h - l) - theta_tilt_minus;
doubleNoTouch += Math.Exp(-2.0 * j * theta_tilt_minus * (h - l)) * (cnd.value(h + e_minus) - cnd.value(l + e_minus))
- Math.Exp(-2.0 * j * theta_tilt_minus * (h - l) + 2.0 * theta_tilt_minus * h) *
(cnd.value(h - 2.0 * h + e_minus) - cnd.value(l - 2.0 * h + e_minus));
}
double p_survival = doubleNoTouch;
double lambda = p_survival;
double adjust = q[0] * (priceAtmCallMkt - priceAtmCallBS)
+ q[1] * (price25CallMkt - price25CallBS)
+ q[2] * (price25PutMkt - price25PutBS);
double outPrice = priceBS + lambda * adjust;//
double inPrice;
//adapt Vanilla delta
if (adaptVanDelta_ == true)
{
outPrice += lambda * (bsPriceWithSmile_ - vanillaOption);
//capfloored by (0, vanilla)
outPrice = Math.Max(0.0, Math.Min(bsPriceWithSmile_, outPrice));
inPrice = bsPriceWithSmile_ - outPrice;
}
else
{
//capfloored by (0, vanilla)
outPrice = Math.Max(0.0, Math.Min(vanillaOption, outPrice));
inPrice = vanillaOption - outPrice;
}
if (arguments_.barrierType == DoubleBarrier.Type.KnockOut)
{
results_.value = outPrice;
}
else
{
results_.value = inPrice;
}
results_.additionalResults["VanillaPrice"] = vanillaOption;
results_.additionalResults["BarrierInPrice"] = inPrice;
results_.additionalResults["BarrierOutPrice"] = outPrice;
results_.additionalResults["lambda"] = lambda;
}
}
public EuropeanOption(StrikedTypePayoff payoff, Exercise exercise) : base(payoff, exercise)
{
}
VanillaOption makeOption(StrikedTypePayoff payoff, Exercise exercise, Quote u, YieldTermStructure q,
YieldTermStructure r, BlackVolTermStructure vol, EngineType engineType, int binomialSteps, int samples)
{
GeneralizedBlackScholesProcess stochProcess = makeProcess(u, q, r, vol);
IPricingEngine engine;
switch (engineType)
{
case EngineType.Analytic:
engine = new AnalyticEuropeanEngine(stochProcess);
break;
case EngineType.JR:
engine = new BinomialVanillaEngine<JarrowRudd>(stochProcess, binomialSteps);
break;
case EngineType.CRR:
engine = new BinomialVanillaEngine<CoxRossRubinstein>(stochProcess, binomialSteps);
break;
case EngineType.EQP:
engine = new BinomialVanillaEngine<AdditiveEQPBinomialTree>(stochProcess, binomialSteps);
break;
case EngineType.TGEO:
engine = new BinomialVanillaEngine<Trigeorgis>(stochProcess, binomialSteps);
break;
case EngineType.TIAN:
engine = new BinomialVanillaEngine<Tian>(stochProcess, binomialSteps);
break;
case EngineType.LR:
engine = new BinomialVanillaEngine<LeisenReimer>(stochProcess, binomialSteps);
break;
case EngineType.JOSHI:
engine = new BinomialVanillaEngine<Joshi4>(stochProcess, binomialSteps);
break;
case EngineType.FiniteDifferences:
engine = new FDEuropeanEngine(stochProcess, binomialSteps, samples);
break;
case EngineType.Integral:
engine = new IntegralEngine(stochProcess);
break;
//case EngineType.PseudoMonteCarlo:
// engine = MakeMCEuropeanEngine<PseudoRandom>(stochProcess)
// .withSteps(1)
// .withSamples(samples)
// .withSeed(42);
// break;
//case EngineType.QuasiMonteCarlo:
// engine = MakeMCEuropeanEngine<LowDiscrepancy>(stochProcess)
// .withSteps(1)
// .withSamples(samples);
// break;
default:
throw new ArgumentException("unknown engine type");
}
VanillaOption option = new EuropeanOption(payoff, exercise);
option.setPricingEngine(engine);
return option;
}
//private double DXDstrike_;
public AmericanPayoffAtExpiry(double spot, double discount, double dividendDiscount, double variance, StrikedTypePayoff payoff) {
spot_ = spot;
discount_ = discount;
dividendDiscount_ = dividendDiscount;
variance_ = variance;
if (!(spot_ > 0.0))
throw new ApplicationException("positive spot_ value required");
forward_ = spot_ * dividendDiscount_ / discount_;
if (!(discount_ > 0.0))
throw new ApplicationException("positive discount required");
if (!(dividendDiscount_ > 0.0))
throw new ApplicationException("positive dividend discount_ required");
if (!(variance_ >= 0.0))
throw new ApplicationException("negative variance_ not allowed");
stdDev_ = Math.Sqrt(variance_);
Option.Type type = payoff.optionType();
strike_ = payoff.strike();
mu_ = Math.Log(dividendDiscount_ / discount_) / variance_ - 0.5;
// binary cash-or-nothing payoff?
CashOrNothingPayoff coo = payoff as CashOrNothingPayoff;
if (coo != null) {
K_ = coo.cashPayoff();
//DKDstrike_ = 0.0;
}
// binary asset-or-nothing payoff?
AssetOrNothingPayoff aoo = payoff as AssetOrNothingPayoff;
if (aoo != null) {
K_ = forward_;
//DKDstrike_ = 0.0;
mu_ += 1.0;
}
log_H_S_ = Math.Log(strike_ / spot_);
double n_d1;
double n_d2;
double cum_d1_;
double cum_d2_;
if (variance_ >= Const.QL_EPSILON) {
D1_ = log_H_S_ / stdDev_ + mu_ * stdDev_;
D2_ = D1_ - 2.0 * mu_ * stdDev_;
CumulativeNormalDistribution f = new CumulativeNormalDistribution();
cum_d1_ = f.value(D1_);
cum_d2_ = f.value(D2_);
n_d1 = f.derivative(D1_);
n_d2 = f.derivative(D2_);
} else {
if (log_H_S_ > 0) {
cum_d1_ = 1.0;
cum_d2_ = 1.0;
} else {
cum_d1_ = 0.0;
cum_d2_ = 0.0;
}
n_d1 = 0.0;
n_d2 = 0.0;
}
switch (type) {
// up-and-in cash-(at-hit)-or-nothing option
// a.k.a. american call with cash-or-nothing payoff
case Option.Type.Call:
if (strike_ > spot_) {
alpha_ = 1.0 - cum_d2_; // N(-d2)
DalphaDd1_ = -n_d2; // -n( d2)
beta_ = 1.0 - cum_d1_; // N(-d1)
DbetaDd2_ = -n_d1; // -n( d1)
} else {
alpha_ = 0.5;
DalphaDd1_ = 0.0;
beta_ = 0.5;
DbetaDd2_ = 0.0;
}
break;
// down-and-in cash-(at-hit)-or-nothing option
// a.k.a. american put with cash-or-nothing payoff
case Option.Type.Put:
if (strike_ < spot_) {
alpha_ = cum_d2_; // N(d2)
DalphaDd1_ = n_d2; // n(d2)
beta_ = cum_d1_; // N(d1)
DbetaDd2_ = n_d1; // n(d1)
} else {
alpha_ = 0.5;
DalphaDd1_ = 0.0;
beta_ = 0.5;
DbetaDd2_ = 0.0;
}
break;
default:
throw new ApplicationException("invalid option type");
}
inTheMoney_ = (type == Option.Type.Call && strike_ < spot_) || (type == Option.Type.Put && strike_ > spot_);
if (inTheMoney_) {
Y_ = 1.0;
X_ = 1.0;
//DYDstrike_ = 0.0;
//DXDstrike_ = 0.0;
} else {
Y_ = 1.0;
X_ = Math.Pow((double)(strike_ / spot_), (double)(2.0 * mu_));
// DXDstrike_ = ......;
}
}
public DiscreteAveragingAsianOption(Average.Type averageType, double?runningAccumulator, int?pastFixings, List <Date> fixingDates, StrikedTypePayoff payoff, Exercise exercise)
: base(payoff, exercise)
{
averageType_ = averageType;
runningAccumulator_ = runningAccumulator;
pastFixings_ = pastFixings;
fixingDates_ = fixingDates;
fixingDates_.Sort();
}
void REPORT_FAILURE(string greekName, StrikedTypePayoff payoff, Exercise exercise, double s, double q, double r,
Date today, double v, double expected, double calculated, double error, double tolerance)
{
Assert.Fail(exercise + " "
+ payoff.optionType() + " option with "
+ payoff + " payoff:\n"
+ " spot value: " + s + "\n"
+ " strike: " + payoff.strike() + "\n"
+ " dividend yield: " + q + "\n"
+ " risk-free rate: " + r + "\n"
+ " reference date: " + today + "\n"
+ " maturity: " + exercise.lastDate() + "\n"
+ " volatility: " + v + "\n\n"
+ " expected " + greekName + ": " + expected + "\n"
+ " calculated " + greekName + ": " + calculated + "\n"
+ " error: " + error + "\n"
+ " tolerance: " + tolerance);
}
public override void calculate(IPricingEngineResults r)
{
OneAssetOption.Results results = r as OneAssetOption.Results;
setGridLimits();
initializeInitialCondition();
initializeOperator();
initializeBoundaryConditions();
initializeStepCondition();
List <IOperator> operatorSet = new List <IOperator>();
List <Vector> arraySet = new List <Vector>();
BoundaryConditionSet bcSet = new BoundaryConditionSet();
StepConditionSet <Vector> conditionSet = new StepConditionSet <Vector>();
prices_ = (SampledCurve)intrinsicValues_.Clone();
controlPrices_ = (SampledCurve)intrinsicValues_.Clone();
controlOperator_ = (TridiagonalOperator)finiteDifferenceOperator_.Clone();
controlBCs_[0] = BCs_[0];
controlBCs_[1] = BCs_[1];
operatorSet.Add(finiteDifferenceOperator_);
operatorSet.Add(controlOperator_);
arraySet.Add(prices_.values());
arraySet.Add(controlPrices_.values());
bcSet.Add(BCs_);
bcSet.Add(controlBCs_);
conditionSet.Add(stepCondition_);
conditionSet.Add(new NullCondition <Vector>());
var model = new FiniteDifferenceModel <ParallelEvolver <CrankNicolson <TridiagonalOperator> > >(operatorSet, bcSet);
object temp = arraySet;
model.rollback(ref temp, getResidualTime(), 0.0, timeSteps_, conditionSet);
arraySet = (List <Vector>)temp;
prices_.setValues(arraySet[0]);
controlPrices_.setValues(arraySet[1]);
StrikedTypePayoff striked_payoff = payoff_ as StrikedTypePayoff;
Utils.QL_REQUIRE(striked_payoff != null, () => "non-striked payoff given");
double variance = process_.blackVolatility().link.blackVariance(exerciseDate_, striked_payoff.strike());
double dividendDiscount = process_.dividendYield().link.discount(exerciseDate_);
double riskFreeDiscount = process_.riskFreeRate().link.discount(exerciseDate_);
double spot = process_.stateVariable().link.value();
double forwardPrice = spot * dividendDiscount / riskFreeDiscount;
BlackCalculator black = new BlackCalculator(striked_payoff, forwardPrice, Math.Sqrt(variance), riskFreeDiscount);
results.value = prices_.valueAtCenter()
- controlPrices_.valueAtCenter()
+ black.value();
results.delta = prices_.firstDerivativeAtCenter()
- controlPrices_.firstDerivativeAtCenter()
+ black.delta(spot);
results.gamma = prices_.secondDerivativeAtCenter()
- controlPrices_.secondDerivativeAtCenter()
+ black.gamma(spot);
results.additionalResults["priceCurve"] = prices_;
}
public override void calculate()
{
Utils.QL_REQUIRE(arguments_.exercise.type() == Exercise.Type.American, () => "not an American Option");
AmericanExercise ex = arguments_.exercise as AmericanExercise;
Utils.QL_REQUIRE(ex != null, () => "non-American exercise given");
Utils.QL_REQUIRE(!ex.payoffAtExpiry(), () => "payoff at expiry not handled");
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-striked 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();
Utils.QL_REQUIRE(spot > 0.0, () => "negative or null underlying given");
double forwardPrice = spot * dividendDiscount / riskFreeDiscount;
BlackCalculator black = new BlackCalculator(payoff, forwardPrice, Math.Sqrt(variance), riskFreeDiscount);
if (dividendDiscount >= 1.0 && payoff.optionType() == Option.Type.Call)
{
// early exercise never optimal
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
CumulativeNormalDistribution cumNormalDist = new CumulativeNormalDistribution();
NormalDistribution normalDist = new NormalDistribution();
double tolerance = 1e-6;
double Sk = BaroneAdesiWhaleyApproximationEngine.criticalPrice(payoff, riskFreeDiscount, dividendDiscount,
variance, tolerance);
double forwardSk = Sk * dividendDiscount / riskFreeDiscount;
double alpha = -2.0 * Math.Log(riskFreeDiscount) / (variance);
double beta = 2.0 * Math.Log(dividendDiscount / riskFreeDiscount) / (variance);
double h = 1 - riskFreeDiscount;
double phi = 0;
switch (payoff.optionType())
{
case Option.Type.Call:
phi = 1;
break;
case Option.Type.Put:
phi = -1;
break;
default:
Utils.QL_FAIL("invalid option type");
break;
}
//it can throw: to be fixed
// FLOATING_POINT_EXCEPTION
double temp_root = Math.Sqrt((beta - 1) * (beta - 1) + (4 * alpha) / h);
double lambda = (-(beta - 1) + phi * temp_root) / 2;
double lambda_prime = -phi * alpha / (h * h * temp_root);
double black_Sk = Utils.blackFormula(payoff.optionType(), payoff.strike(), forwardSk, Math.Sqrt(variance)) *
riskFreeDiscount;
double hA = phi * (Sk - payoff.strike()) - black_Sk;
double d1_Sk = (Math.Log(forwardSk / payoff.strike()) + 0.5 * variance) / Math.Sqrt(variance);
double d2_Sk = d1_Sk - Math.Sqrt(variance);
double part1 = forwardSk * normalDist.value(d1_Sk) / (alpha * Math.Sqrt(variance));
double part2 = -phi *forwardSk *cumNormalDist.value(phi *d1_Sk) * Math.Log(dividendDiscount) /
Math.Log(riskFreeDiscount);
double part3 = +phi *payoff.strike() * cumNormalDist.value(phi * d2_Sk);
double V_E_h = part1 + part2 + part3;
double b = (1 - h) * alpha * lambda_prime / (2 * (2 * lambda + beta - 1));
double c = -((1 - h) * alpha / (2 * lambda + beta - 1)) *
(V_E_h / (hA) + 1 / h + lambda_prime / (2 * lambda + beta - 1));
double temp_spot_ratio = Math.Log(spot / Sk);
double chi = temp_spot_ratio * (b * temp_spot_ratio + c);
if (phi * (Sk - spot) > 0)
{
results_.value = black.value() + hA * Math.Pow((spot / Sk), lambda) / (1 - chi);
}
else
{
results_.value = phi * (spot - payoff.strike());
}
double temp_chi_prime = (2 * b / spot) * Math.Log(spot / Sk);
double chi_prime = temp_chi_prime + c / spot;
double chi_double_prime = 2 * b / (spot * spot) - temp_chi_prime / spot - c / (spot * spot);
results_.delta = phi * dividendDiscount * cumNormalDist.value(phi * d1_Sk) +
(lambda / (spot * (1 - chi)) + chi_prime / ((1 - chi) * (1 - chi))) *
(phi * (Sk - payoff.strike()) - black_Sk) * Math.Pow((spot / Sk), lambda);
results_.gamma = phi * dividendDiscount * normalDist.value(phi * d1_Sk) / (spot * Math.Sqrt(variance)) +
(2 * lambda * chi_prime / (spot * (1 - chi) * (1 - chi)) +
2 * chi_prime * chi_prime / ((1 - chi) * (1 - chi) * (1 - chi)) +
chi_double_prime / ((1 - chi) * (1 - chi)) +
lambda * (1 - lambda) / (spot * spot * (1 - chi))) *
(phi * (Sk - payoff.strike()) - black_Sk) * Math.Pow((spot / Sk), lambda);
} // end of "early exercise can be optimal"
}
//private double DXDstrike_;
public AmericanPayoffAtExpiry(double spot, double discount, double dividendDiscount, double variance, StrikedTypePayoff payoff)
{
spot_ = spot;
discount_ = discount;
dividendDiscount_ = dividendDiscount;
variance_ = variance;
if (!(spot_ > 0.0))
{
throw new ApplicationException("positive spot_ value required");
}
forward_ = spot_ * dividendDiscount_ / discount_;
if (!(discount_ > 0.0))
{
throw new ApplicationException("positive discount required");
}
if (!(dividendDiscount_ > 0.0))
{
throw new ApplicationException("positive dividend discount_ required");
}
if (!(variance_ >= 0.0))
{
throw new ApplicationException("negative variance_ not allowed");
}
stdDev_ = Math.Sqrt(variance_);
Option.Type type = payoff.optionType();
strike_ = payoff.strike();
mu_ = Math.Log(dividendDiscount_ / discount_) / variance_ - 0.5;
// binary cash-or-nothing payoff?
CashOrNothingPayoff coo = payoff as CashOrNothingPayoff;
if (coo != null)
{
K_ = coo.cashPayoff();
//DKDstrike_ = 0.0;
}
// binary asset-or-nothing payoff?
AssetOrNothingPayoff aoo = payoff as AssetOrNothingPayoff;
if (aoo != null)
{
K_ = forward_;
//DKDstrike_ = 0.0;
mu_ += 1.0;
}
log_H_S_ = Math.Log(strike_ / spot_);
double n_d1;
double n_d2;
double cum_d1_;
double cum_d2_;
if (variance_ >= Const.QL_Epsilon)
{
D1_ = log_H_S_ / stdDev_ + mu_ * stdDev_;
D2_ = D1_ - 2.0 * mu_ * stdDev_;
CumulativeNormalDistribution f = new CumulativeNormalDistribution();
cum_d1_ = f.value(D1_);
cum_d2_ = f.value(D2_);
n_d1 = f.derivative(D1_);
n_d2 = f.derivative(D2_);
}
else
{
if (log_H_S_ > 0)
{
cum_d1_ = 1.0;
cum_d2_ = 1.0;
}
else
{
cum_d1_ = 0.0;
cum_d2_ = 0.0;
}
n_d1 = 0.0;
n_d2 = 0.0;
}
switch (type)
{
// up-and-in cash-(at-hit)-or-nothing option
// a.k.a. american call with cash-or-nothing payoff
case Option.Type.Call:
if (strike_ > spot_)
{
alpha_ = 1.0 - cum_d2_; // N(-d2)
DalphaDd1_ = -n_d2; // -n( d2)
beta_ = 1.0 - cum_d1_; // N(-d1)
DbetaDd2_ = -n_d1; // -n( d1)
}
else
{
alpha_ = 0.5;
DalphaDd1_ = 0.0;
beta_ = 0.5;
DbetaDd2_ = 0.0;
}
break;
// down-and-in cash-(at-hit)-or-nothing option
// a.k.a. american put with cash-or-nothing payoff
case Option.Type.Put:
if (strike_ < spot_)
{
alpha_ = cum_d2_; // N(d2)
DalphaDd1_ = n_d2; // n(d2)
beta_ = cum_d1_; // N(d1)
DbetaDd2_ = n_d1; // n(d1)
}
else
{
alpha_ = 0.5;
DalphaDd1_ = 0.0;
beta_ = 0.5;
DbetaDd2_ = 0.0;
}
break;
default:
throw new ApplicationException("invalid option type");
}
inTheMoney_ = (type == Option.Type.Call && strike_ < spot_) || (type == Option.Type.Put && strike_ > spot_);
if (inTheMoney_)
{
Y_ = 1.0;
X_ = 1.0;
//DYDstrike_ = 0.0;
//DXDstrike_ = 0.0;
}
else
{
Y_ = 1.0;
X_ = Math.Pow((double)(strike_ / spot_), (double)(2.0 * mu_));
// DXDstrike_ = ......;
}
}
public VanillaOption(StrikedTypePayoff payoff, Exercise exercise) : base(payoff, exercise) {}
public AmericanPayoffAtExpiry(double spot, double discount, double dividendDiscount, double variance,
StrikedTypePayoff payoff, bool knock_in = true)
{
spot_ = spot;
discount_ = discount;
dividendDiscount_ = dividendDiscount;
variance_ = variance;
knock_in_ = knock_in;
Utils.QL_REQUIRE(spot_ > 0.0, () => "positive spot value required");
Utils.QL_REQUIRE(discount_ > 0.0, () => "positive discount required");
Utils.QL_REQUIRE(dividendDiscount_ > 0.0, () => "positive dividend discount required");
Utils.QL_REQUIRE(variance_ >= 0.0, () => "negative variance not allowed");
stdDev_ = Math.Sqrt(variance_);
Option.Type type = payoff.optionType();
strike_ = payoff.strike();
forward_ = spot_ * dividendDiscount_ / discount_;
mu_ = Math.Log(dividendDiscount_ / discount_) / variance_ - 0.5;
// binary cash-or-nothing payoff?
CashOrNothingPayoff coo = payoff as CashOrNothingPayoff;
if (coo != null)
{
K_ = coo.cashPayoff();
}
// binary asset-or-nothing payoff?
AssetOrNothingPayoff aoo = payoff as AssetOrNothingPayoff;
if (aoo != null)
{
K_ = forward_;
mu_ += 1.0;
}
log_H_S_ = Math.Log(strike_ / spot_);
double log_S_H_ = Math.Log(spot_ / strike_);
double eta = 0.0;
double phi = 0.0;
switch (type)
{
case Option.Type.Call:
if (knock_in_)
{
// up-and-in cash-(at-expiry)-or-nothing option
// a.k.a. american call with cash-or-nothing payoff
eta = -1.0;
phi = 1.0;
}
else
{
// up-and-out cash-(at-expiry)-or-nothing option
eta = -1.0;
phi = -1.0;
}
break;
case Option.Type.Put:
if (knock_in_)
{
// down-and-in cash-(at-expiry)-or-nothing option
// a.k.a. american put with cash-or-nothing payoff
eta = 1.0;
phi = -1.0;
}
else
{
// down-and-out cash-(at-expiry)-or-nothing option
eta = 1.0;
phi = 1.0;
}
break;
default:
Utils.QL_FAIL("invalid option type");
break;
}
if (variance_ >= Const.QL_EPSILON)
{
D1_ = phi * (log_S_H_ / stdDev_ + mu_ * stdDev_);
D2_ = eta * (log_H_S_ / stdDev_ + mu_ * stdDev_);
CumulativeNormalDistribution f = new CumulativeNormalDistribution();
cum_d1_ = f.value(D1_);
cum_d2_ = f.value(D2_);
n_d1_ = f.derivative(D1_);
n_d2_ = f.derivative(D2_);
}
else
{
if (log_S_H_ * phi > 0)
{
cum_d1_ = 1.0;
}
else
{
cum_d1_ = 0.0;
}
if (log_H_S_ * eta > 0)
{
cum_d2_ = 1.0;
}
else
{
cum_d2_ = 0.0;
}
n_d1_ = 0.0;
n_d2_ = 0.0;
}
switch (type)
{
case Option.Type.Call:
if (strike_ <= spot_)
{
if (knock_in_)
{
// up-and-in cash-(at-expiry)-or-nothing option
// a.k.a. american call with cash-or-nothing payoff
cum_d1_ = 0.5;
cum_d2_ = 0.5;
}
else
{
// up-and-out cash-(at-expiry)-or-nothing option
// already knocked out
cum_d1_ = 0.0;
cum_d2_ = 0.0;
}
n_d1_ = 0.0;
n_d2_ = 0.0;
}
break;
case Option.Type.Put:
if (strike_ >= spot_)
{
if (knock_in_)
{
// down-and-in cash-(at-expiry)-or-nothing option
// a.k.a. american put with cash-or-nothing payoff
cum_d1_ = 0.5;
cum_d2_ = 0.5;
}
else
{
// down-and-out cash-(at-expiry)-or-nothing option
// already knocked out
cum_d1_ = 0.0;
cum_d2_ = 0.0;
}
n_d1_ = 0.0;
n_d2_ = 0.0;
}
break;
default:
Utils.QL_FAIL("invalid option type");
break;
}
inTheMoney_ = (type == Option.Type.Call && strike_ < spot_) ||
(type == Option.Type.Put && strike_ > spot_);
if (inTheMoney_)
{
X_ = 1.0;
Y_ = 1.0;
}
else
{
X_ = 1.0;
if (cum_d2_ == 0.0)
{
Y_ = 0.0; // check needed on some extreme cases
}
else
{
Y_ = Math.Pow((strike_ / spot_), (2.0 * mu_));
}
}
if (!knock_in_)
{
Y_ *= -1.0;
}
}
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();
Utils.QL_REQUIRE(s0 > 0.0, () => "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).value();
double q = process_.dividendYield().link.zeroRate(maturityDate, divdc, Compounding.Continuous, Frequency.NoFrequency).value();
Date referenceDate = process_.riskFreeRate().link.referenceDate();
// binomial trees with constant coefficient
Handle <YieldTermStructure> flatRiskFree = new Handle <YieldTermStructure>(new FlatForward(referenceDate, r, rfdc));
Handle <YieldTermStructure> flatDividends = new Handle <YieldTermStructure>(new FlatForward(referenceDate, q, divdc));
Handle <BlackVolTermStructure> flatVol = new Handle <BlackVolTermStructure>(new BlackConstantVol(referenceDate, volcal, v, voldc));
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-striked payoff given");
double maturity = rfdc.yearFraction(referenceDate, maturityDate);
StochasticProcess1D bs = new GeneralizedBlackScholesProcess(process_.stateVariable(),
flatDividends, flatRiskFree, flatVol);
// correct timesteps to ensure a (local) minimum, using Boyle and Lau
// approach. See Journal of Derivatives, 1/1994,
// "Bumping up against the barrier with the binomial method"
// Note: this approach works only for CoxRossRubinstein lattices, so
// is disabled if T is not a CoxRossRubinstein or derived from it.
int optimum_steps = timeSteps_;
if (maxTimeSteps_ > timeSteps_ && s0 > 0 && arguments_.barrier > 0) // boost::is_base_of<CoxRossRubinstein, T>::value &&
{
double divisor;
if (s0 > arguments_.barrier)
{
divisor = Math.Pow(Math.Log(s0 / arguments_.barrier.Value), 2);
}
else
{
divisor = Math.Pow(Math.Log(arguments_.barrier.Value / s0), 2);
}
if (!Utils.close(divisor, 0))
{
for (int i = 1; i < timeSteps_; ++i)
{
int optimum = (int)((i * i * v * v * maturity) / divisor);
if (timeSteps_ < optimum)
{
optimum_steps = optimum;
break; // found first minimum with iterations>=timesteps
}
}
}
if (optimum_steps > maxTimeSteps_)
{
optimum_steps = maxTimeSteps_; // too high, limit
}
}
TimeGrid grid = new TimeGrid(maturity, optimum_steps);
ITree tree = getTree_(bs, maturity, optimum_steps, payoff.strike());
BlackScholesLattice <ITree> lattice = new BlackScholesLattice <ITree>(tree, r, maturity, optimum_steps);
DiscretizedAsset option = getAsset_(arguments_, process_, grid);
option.initialize(lattice, maturity);
// Partial derivatives calculated from various points in the
// binomial tree
// (see J.C.Hull, "Options, Futures and other derivatives", 6th edition, pp 397/398)
// Rollback to third-last step, and get underlying prices (s2) &
// option values (p2) at this point
option.rollback(grid[2]);
Vector va2 = new Vector(option.values());
Utils.QL_REQUIRE(va2.size() == 3, () => "Expect 3 nodes in grid at second step");
double p2u = va2[2]; // up
double p2m = va2[1]; // mid
double p2d = va2[0]; // down (low)
double s2u = lattice.underlying(2, 2); // up price
double s2m = lattice.underlying(2, 1); // middle price
double s2d = lattice.underlying(2, 0); // down (low) price
// calculate gamma by taking the first derivate of the two deltas
double delta2u = (p2u - p2m) / (s2u - s2m);
double delta2d = (p2m - p2d) / (s2m - s2d);
double gamma = (delta2u - delta2d) / ((s2u - s2d) / 2);
// Rollback to second-last step, and get option values (p1) at
// this point
option.rollback(grid[1]);
Vector va = new Vector(option.values());
Utils.QL_REQUIRE(va.size() == 2, () => "Expect 2 nodes in grid at first step");
double p1u = va[1];
double p1d = va[0];
double s1u = lattice.underlying(1, 1); // up (high) price
double s1d = lattice.underlying(1, 0); // down (low) price
double delta = (p1u - p1d) / (s1u - s1d);
// Finally, rollback to t=0
option.rollback(0.0);
double p0 = option.presentValue();
// Store results
results_.value = p0;
results_.delta = delta;
results_.gamma = gamma;
// theta can be approximated by calculating the numerical derivative
// between mid value at third-last step and at t0. The underlying price
// is the same, only time varies.
results_.theta = (p2m - p0) / grid[2];
}
public EuropeanOption(StrikedTypePayoff payoff, Exercise exercise)
: base(payoff, exercise)
{
}
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");
}
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
if (payoff == null)
{
throw new ApplicationException("non-striked 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 forwardPrice = spot * dividendDiscount / riskFreeDiscount;
BlackCalculator black = new BlackCalculator(payoff, forwardPrice, Math.Sqrt(variance), riskFreeDiscount);
if (dividendDiscount >= 1.0 && payoff.optionType() == Option.Type.Call)
{
// early exercise never optimal
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
CumulativeNormalDistribution cumNormalDist = new CumulativeNormalDistribution();
double tolerance = 1e-6;
double Sk = criticalPrice(payoff, riskFreeDiscount,
dividendDiscount, variance, tolerance);
double forwardSk = Sk * dividendDiscount / riskFreeDiscount;
double d1 = (Math.Log(forwardSk / payoff.strike()) + 0.5 * variance)
/ Math.Sqrt(variance);
double n = 2.0 * Math.Log(dividendDiscount / riskFreeDiscount) / variance;
double K = -2.0 * Math.Log(riskFreeDiscount) /
(variance * (1.0 - riskFreeDiscount));
double Q, a;
switch (payoff.optionType())
{
case Option.Type.Call:
Q = (-(n - 1.0) + Math.Sqrt(((n - 1.0) * (n - 1.0)) + 4.0 * K)) / 2.0;
a = (Sk / Q) * (1.0 - dividendDiscount * cumNormalDist.value(d1));
if (spot < Sk)
{
results_.value = black.value() +
a * Math.Pow((spot / Sk), Q);
}
else
{
results_.value = spot - payoff.strike();
}
break;
case Option.Type.Put:
Q = (-(n - 1.0) - Math.Sqrt(((n - 1.0) * (n - 1.0)) + 4.0 * K)) / 2.0;
a = -(Sk / Q) *
(1.0 - dividendDiscount * cumNormalDist.value(-d1));
if (spot > Sk)
{
results_.value = black.value() +
a * Math.Pow((spot / Sk), Q);
}
else
{
results_.value = payoff.strike() - spot;
}
break;
default:
throw new ApplicationException("unknown option type");
}
} // end of "early exercise can be optimal"
}
public override void calculate()
{
double sigmaShift_vega = 0.0001;
double sigmaShift_volga = 0.0001;
double spotShift_delta = 0.0001 * spotFX_.link.value();
double sigmaShift_vanna = 0.0001;
Handle <Quote> x0Quote = new Handle <Quote>(new SimpleQuote(spotFX_.link.value())); //used for shift
Handle <Quote> atmVolQuote = new Handle <Quote>(new SimpleQuote(atmVol_.link.value())); //used for shift
BlackVolTermStructure blackVolTS = new BlackConstantVol(Settings.evaluationDate(),
new NullCalendar(), atmVolQuote, new Actual365Fixed());
BlackScholesMertonProcess stochProcess = new BlackScholesMertonProcess(x0Quote, foreignTS_, domesticTS_,
new Handle <BlackVolTermStructure>(blackVolTS));
IPricingEngine engineBS = new AnalyticBarrierEngine(stochProcess);
BlackDeltaCalculator blackDeltaCalculatorAtm = new BlackDeltaCalculator(
Option.Type.Call, atmVol_.link.deltaType(), x0Quote.link.value(),
domesticTS_.link.discount(T_), foreignTS_.link.discount(T_),
atmVol_.link.value() * Math.Sqrt(T_));
double atmStrike = blackDeltaCalculatorAtm.atmStrike(atmVol_.link.atmType());
double call25Vol = vol25Call_.link.value();
double put25Vol = vol25Put_.link.value();
BlackDeltaCalculator blackDeltaCalculatorPut25 = new BlackDeltaCalculator(
Option.Type.Put, vol25Put_.link.deltaType(), x0Quote.link.value(),
domesticTS_.link.discount(T_), foreignTS_.link.discount(T_),
put25Vol * Math.Sqrt(T_));
double put25Strike = blackDeltaCalculatorPut25.strikeFromDelta(-0.25);
BlackDeltaCalculator blackDeltaCalculatorCall25 = new BlackDeltaCalculator(
Option.Type.Call, vol25Call_.link.deltaType(), x0Quote.link.value(),
domesticTS_.link.discount(T_), foreignTS_.link.discount(T_),
call25Vol * Math.Sqrt(T_));
double call25Strike = blackDeltaCalculatorCall25.strikeFromDelta(0.25);
//here use vanna volga interpolated smile to price vanilla
List <double> strikes = new List <double>();
List <double> vols = new List <double>();
strikes.Add(put25Strike);
vols.Add(put25Vol);
strikes.Add(atmStrike);
vols.Add(atmVol_.link.value());
strikes.Add(call25Strike);
vols.Add(call25Vol);
VannaVolga vannaVolga = new VannaVolga(x0Quote.link.value(), domesticTS_.link.discount(T_),
foreignTS_.link.discount(T_), T_);
Interpolation interpolation = vannaVolga.interpolate(strikes, strikes.Count, vols);
interpolation.enableExtrapolation();
StrikedTypePayoff payoff = arguments_.payoff as StrikedTypePayoff;
double strikeVol = interpolation.value(payoff.strike());
//vannila option price
double vanillaOption = Utils.blackFormula(payoff.optionType(), payoff.strike(),
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
strikeVol * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
//spot > barrier up&out 0
if (x0Quote.link.value() >= arguments_.barrier && arguments_.barrierType == Barrier.Type.UpOut)
{
results_.value = 0.0;
results_.additionalResults["VanillaPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierInPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierOutPrice"] = 0.0;
}
//spot > barrier up&in vanilla
else if (x0Quote.link.value() >= arguments_.barrier && arguments_.barrierType == Barrier.Type.UpIn)
{
results_.value = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["VanillaPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierInPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierOutPrice"] = 0.0;
}
//spot < barrier down&out 0
else if (x0Quote.link.value() <= arguments_.barrier && arguments_.barrierType == Barrier.Type.DownOut)
{
results_.value = 0.0;
results_.additionalResults["VanillaPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierInPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierOutPrice"] = 0.0;
}
//spot < barrier down&in vanilla
else if (x0Quote.link.value() <= arguments_.barrier && arguments_.barrierType == Barrier.Type.DownIn)
{
results_.value = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["VanillaPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierInPrice"] = adaptVanDelta_? bsPriceWithSmile_ : vanillaOption;
results_.additionalResults["BarrierOutPrice"] = 0.0;
}
else
{
//set up BS barrier option pricing
//only calculate out barrier option price
// in barrier price = vanilla - out barrier
Barrier.Type barrierTyp;
if (arguments_.barrierType == Barrier.Type.UpOut)
{
barrierTyp = arguments_.barrierType;
}
else if (arguments_.barrierType == Barrier.Type.UpIn)
{
barrierTyp = Barrier.Type.UpOut;
}
else if (arguments_.barrierType == Barrier.Type.DownOut)
{
barrierTyp = arguments_.barrierType;
}
else
{
barrierTyp = Barrier.Type.DownOut;
}
BarrierOption barrierOption = new BarrierOption(barrierTyp,
arguments_.barrier.GetValueOrDefault(),
arguments_.rebate.GetValueOrDefault(),
(StrikedTypePayoff)arguments_.payoff,
arguments_.exercise);
barrierOption.setPricingEngine(engineBS);
//BS price with atm vol
double priceBS = barrierOption.NPV();
double priceAtmCallBS = Utils.blackFormula(Option.Type.Call, atmStrike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
atmVol_.link.value() * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
double price25CallBS = Utils.blackFormula(Option.Type.Call, call25Strike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
atmVol_.link.value() * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
double price25PutBS = Utils.blackFormula(Option.Type.Put, put25Strike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
atmVol_.link.value() * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
//market price
double priceAtmCallMkt = Utils.blackFormula(Option.Type.Call, atmStrike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
atmVol_.link.value() * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
double price25CallMkt = Utils.blackFormula(Option.Type.Call, call25Strike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
call25Vol * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
double price25PutMkt = Utils.blackFormula(Option.Type.Put, put25Strike,
x0Quote.link.value() * foreignTS_.link.discount(T_) / domesticTS_.link.discount(T_),
put25Vol * Math.Sqrt(T_),
domesticTS_.link.discount(T_));
//Analytical Black Scholes formula for vanilla option
NormalDistribution norm = new NormalDistribution();
double d1atm = (Math.Log(x0Quote.link.value() * foreignTS_.link.discount(T_) /
domesticTS_.link.discount(T_) / atmStrike)
+ 0.5 * Math.Pow(atmVolQuote.link.value(), 2.0) * T_) /
(atmVolQuote.link.value() * Math.Sqrt(T_));
double vegaAtm_Analytical = x0Quote.link.value() * norm.value(d1atm) * Math.Sqrt(T_) *
foreignTS_.link.discount(T_);
double vannaAtm_Analytical = vegaAtm_Analytical / x0Quote.link.value() *
(1.0 - d1atm / (atmVolQuote.link.value() * Math.Sqrt(T_)));
double volgaAtm_Analytical = vegaAtm_Analytical * d1atm * (d1atm - atmVolQuote.link.value() * Math.Sqrt(T_)) /
atmVolQuote.link.value();
double d125call = (Math.Log(x0Quote.link.value() * foreignTS_.link.discount(T_) /
domesticTS_.link.discount(T_) / call25Strike)
+ 0.5 * Math.Pow(atmVolQuote.link.value(), 2.0) * T_) / (atmVolQuote.link.value() * Math.Sqrt(T_));
double vega25Call_Analytical = x0Quote.link.value() * norm.value(d125call) * Math.Sqrt(T_) *
foreignTS_.link.discount(T_);
double vanna25Call_Analytical = vega25Call_Analytical / x0Quote.link.value() *
(1.0 - d125call / (atmVolQuote.link.value() * Math.Sqrt(T_)));
double volga25Call_Analytical = vega25Call_Analytical * d125call *
(d125call - atmVolQuote.link.value() * Math.Sqrt(T_)) / atmVolQuote.link.value();
double d125Put = (Math.Log(x0Quote.link.value() * foreignTS_.link.discount(T_) /
domesticTS_.link.discount(T_) / put25Strike)
+ 0.5 * Math.Pow(atmVolQuote.link.value(), 2.0) * T_) / (atmVolQuote.link.value() * Math.Sqrt(T_));
double vega25Put_Analytical = x0Quote.link.value() * norm.value(d125Put) * Math.Sqrt(T_) *
foreignTS_.link.discount(T_);
double vanna25Put_Analytical = vega25Put_Analytical / x0Quote.link.value() *
(1.0 - d125Put / (atmVolQuote.link.value() * Math.Sqrt(T_)));
double volga25Put_Analytical = vega25Put_Analytical * d125Put *
(d125Put - atmVolQuote.link.value() * Math.Sqrt(T_)) / atmVolQuote.link.value();
//BS vega
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() + sigmaShift_vega);
barrierOption.recalculate();
double vegaBarBS = (barrierOption.NPV() - priceBS) / sigmaShift_vega;
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() - sigmaShift_vega);//setback
//BS volga
//vegaBar2
//base NPV
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() + sigmaShift_volga);
barrierOption.recalculate();
double priceBS2 = barrierOption.NPV();
//shifted npv
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() + sigmaShift_vega);
barrierOption.recalculate();
double vegaBarBS2 = (barrierOption.NPV() - priceBS2) / sigmaShift_vega;
double volgaBarBS = (vegaBarBS2 - vegaBarBS) / sigmaShift_volga;
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value()
- sigmaShift_volga
- sigmaShift_vega); //setback
//BS Delta
//base delta
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() + spotShift_delta);//shift forth
barrierOption.recalculate();
double priceBS_delta1 = barrierOption.NPV();
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() - 2 * spotShift_delta);//shift back
barrierOption.recalculate();
double priceBS_delta2 = barrierOption.NPV();
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() + spotShift_delta);//set back
double deltaBar1 = (priceBS_delta1 - priceBS_delta2) / (2.0 * spotShift_delta);
//shifted delta
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() + sigmaShift_vanna); //shift sigma
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() + spotShift_delta); //shift forth
barrierOption.recalculate();
priceBS_delta1 = barrierOption.NPV();
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() - 2 * spotShift_delta);//shift back
barrierOption.recalculate();
priceBS_delta2 = barrierOption.NPV();
((SimpleQuote)x0Quote.currentLink()).setValue(x0Quote.link.value() + spotShift_delta);//set back
double deltaBar2 = (priceBS_delta1 - priceBS_delta2) / (2.0 * spotShift_delta);
double vannaBarBS = (deltaBar2 - deltaBar1) / sigmaShift_vanna;
((SimpleQuote)atmVolQuote.currentLink()).setValue(atmVolQuote.link.value() - sigmaShift_vanna);//set back
//Matrix
Matrix A = new Matrix(3, 3, 0.0);
//analytical
A[0, 0] = vegaAtm_Analytical;
A[0, 1] = vega25Call_Analytical;
A[0, 2] = vega25Put_Analytical;
A[1, 0] = vannaAtm_Analytical;
A[1, 1] = vanna25Call_Analytical;
A[1, 2] = vanna25Put_Analytical;
A[2, 0] = volgaAtm_Analytical;
A[2, 1] = volga25Call_Analytical;
A[2, 2] = volga25Put_Analytical;
Vector b = new Vector(3, 0.0);
b[0] = vegaBarBS;
b[1] = vannaBarBS;
b[2] = volgaBarBS;
//Vector q = inverse(A) * b; TODO implements transpose
Vector q = Matrix.inverse(A) * b;
//touch probability
CumulativeNormalDistribution cnd = new CumulativeNormalDistribution();
double mu = domesticTS_.link.zeroRate(T_, Compounding.Continuous).value() -
foreignTS_.link.zeroRate(T_, Compounding.Continuous).value() -
Math.Pow(atmVol_.link.value(), 2.0) / 2.0;
double h2 = (Math.Log(arguments_.barrier.GetValueOrDefault() / x0Quote.link.value()) + mu * T_) /
(atmVol_.link.value() * Math.Sqrt(T_));
double h2Prime = (Math.Log(x0Quote.link.value() / arguments_.barrier.GetValueOrDefault()) + mu * T_) /
(atmVol_.link.value() * Math.Sqrt(T_));
double probTouch = 0.0;
if (arguments_.barrierType == Barrier.Type.UpIn || arguments_.barrierType == Barrier.Type.UpOut)
{
probTouch = cnd.value(h2Prime) + Math.Pow(arguments_.barrier.GetValueOrDefault() / x0Quote.link.value(),
2.0 * mu / Math.Pow(atmVol_.link.value(), 2.0)) * cnd.value(-h2);
}
else
{
probTouch = cnd.value(-h2Prime) + Math.Pow(arguments_.barrier.GetValueOrDefault() / x0Quote.link.value(),
2.0 * mu / Math.Pow(atmVol_.link.value(), 2.0)) * cnd.value(h2);
}
double p_survival = 1.0 - probTouch;
double lambda = p_survival;
double adjust = q[0] * (priceAtmCallMkt - priceAtmCallBS)
+ q[1] * (price25CallMkt - price25CallBS)
+ q[2] * (price25PutMkt - price25PutBS);
double outPrice = priceBS + lambda * adjust;//
double inPrice;
//adapt Vanilla delta
if (adaptVanDelta_ == true)
{
outPrice += lambda * (bsPriceWithSmile_ - vanillaOption);
//capfloored by (0, vanilla)
outPrice = Math.Max(0.0, Math.Min(bsPriceWithSmile_, outPrice));
inPrice = bsPriceWithSmile_ - outPrice;
}
else
{
//capfloored by (0, vanilla)
outPrice = Math.Max(0.0, Math.Min(vanillaOption, outPrice));
inPrice = vanillaOption - outPrice;
}
if (arguments_.barrierType == Barrier.Type.DownOut || arguments_.barrierType == Barrier.Type.UpOut)
{
results_.value = outPrice;
}
else
{
results_.value = inPrice;
}
results_.additionalResults["VanillaPrice"] = vanillaOption;
results_.additionalResults["BarrierInPrice"] = inPrice;
results_.additionalResults["BarrierOutPrice"] = outPrice;
results_.additionalResults["lambda"] = lambda;
}
}
// critical commodity price
//public static double criticalPrice(StrikedTypePayoff payoff, double riskFreeDiscount, double dividendDiscount,
// double variance, double tolerance = 1e-6);
public static double criticalPrice(StrikedTypePayoff payoff, double riskFreeDiscount, double dividendDiscount,
double variance, double tolerance)
{
// Calculation of seed value, Si
double n = 2.0 * Math.Log(dividendDiscount / riskFreeDiscount) / (variance);
double m = -2.0 * Math.Log(riskFreeDiscount) / (variance);
double bT = Math.Log(dividendDiscount / riskFreeDiscount);
double qu, Su, h, Si;
switch (payoff.optionType())
{
case Option.Type.Call:
qu = (-(n - 1.0) + Math.Sqrt(((n - 1.0) * (n - 1.0)) + 4.0 * m)) / 2.0;
Su = payoff.strike() / (1.0 - 1.0 / qu);
h = -(bT + 2.0 * Math.Sqrt(variance)) * payoff.strike() /
(Su - payoff.strike());
Si = payoff.strike() + (Su - payoff.strike()) *
(1.0 - Math.Exp(h));
break;
case Option.Type.Put:
qu = (-(n - 1.0) - Math.Sqrt(((n - 1.0) * (n - 1.0)) + 4.0 * m)) / 2.0;
Su = payoff.strike() / (1.0 - 1.0 / qu);
h = (bT - 2.0 * Math.Sqrt(variance)) * payoff.strike() /
(payoff.strike() - Su);
Si = Su + (payoff.strike() - Su) * Math.Exp(h);
break;
default:
throw new ArgumentException("unknown option type");
}
// Newton Raphson algorithm for finding critical price Si
double Q, LHS, RHS, bi;
double forwardSi = Si * dividendDiscount / riskFreeDiscount;
double d1 = (Math.Log(forwardSi / payoff.strike()) + 0.5 * variance) /
Math.Sqrt(variance);
CumulativeNormalDistribution cumNormalDist = new CumulativeNormalDistribution();
double K = (riskFreeDiscount != 1.0 ? -2.0 * Math.Log(riskFreeDiscount) /
(variance * (1.0 - riskFreeDiscount)) : 0.0);
double temp = Utils.blackFormula(payoff.optionType(), payoff.strike(),
forwardSi, Math.Sqrt(variance)) * riskFreeDiscount;
switch (payoff.optionType())
{
case Option.Type.Call:
Q = (-(n - 1.0) + Math.Sqrt(((n - 1.0) * (n - 1.0)) + 4 * K)) / 2;
LHS = Si - payoff.strike();
RHS = temp + (1 - dividendDiscount * cumNormalDist.value(d1)) * Si / Q;
bi = dividendDiscount * cumNormalDist.value(d1) * (1 - 1 / Q) +
(1 - dividendDiscount *
cumNormalDist.derivative(d1) / Math.Sqrt(variance)) / Q;
while (Math.Abs(LHS - RHS) / payoff.strike() > tolerance)
{
Si = (payoff.strike() + RHS - bi * Si) / (1 - bi);
forwardSi = Si * dividendDiscount / riskFreeDiscount;
d1 = (Math.Log(forwardSi / payoff.strike()) + 0.5 * variance)
/ Math.Sqrt(variance);
LHS = Si - payoff.strike();
double temp2 = Utils.blackFormula(payoff.optionType(), payoff.strike(),
forwardSi, Math.Sqrt(variance)) * riskFreeDiscount;
RHS = temp2 + (1 - dividendDiscount * cumNormalDist.value(d1)) * Si / Q;
bi = dividendDiscount * cumNormalDist.value(d1) * (1 - 1 / Q)
+ (1 - dividendDiscount *
cumNormalDist.derivative(d1) / Math.Sqrt(variance))
/ Q;
}
break;
case Option.Type.Put:
Q = (-(n - 1.0) - Math.Sqrt(((n - 1.0) * (n - 1.0)) + 4 * K)) / 2;
LHS = payoff.strike() - Si;
RHS = temp - (1 - dividendDiscount * cumNormalDist.value(-d1)) * Si / Q;
bi = -dividendDiscount *cumNormalDist.value(-d1) * (1 - 1 / Q)
- (1 + dividendDiscount * cumNormalDist.derivative(-d1)
/ Math.Sqrt(variance)) / Q;
while (Math.Abs(LHS - RHS) / payoff.strike() > tolerance)
{
Si = (payoff.strike() - RHS + bi * Si) / (1 + bi);
forwardSi = Si * dividendDiscount / riskFreeDiscount;
d1 = (Math.Log(forwardSi / payoff.strike()) + 0.5 * variance)
/ Math.Sqrt(variance);
LHS = payoff.strike() - Si;
double temp2 = Utils.blackFormula(payoff.optionType(), payoff.strike(),
forwardSi, Math.Sqrt(variance)) * riskFreeDiscount;
RHS = temp2 - (1 - dividendDiscount * cumNormalDist.value(-d1)) * Si / Q;
bi = -dividendDiscount *cumNormalDist.value(-d1) * (1 - 1 / Q)
- (1 + dividendDiscount * cumNormalDist.derivative(-d1)
/ Math.Sqrt(variance)) / Q;
}
break;
default:
throw new ArgumentException("unknown option type");
}
return(Si);
}