public override double innerValue(FdmLinearOpIterator iter, double t)
{
Date iterExerciseDate = exerciseDates_.ContainsKey(t) ? exerciseDates_[t] : exerciseDates_.Last().Value;
Vector disRate = getState(disModel_, t, iter);
Vector fwdRate = getState(fwdModel_, t, iter);
if (disTs_.empty() || iterExerciseDate != disTs_.currentLink().referenceDate())
{
Handle <YieldTermStructure> discount
= disModel_.termStructure();
disTs_.linkTo(new FdmAffineModelTermStructure(disRate,
discount.currentLink().calendar(), discount.currentLink().dayCounter(),
iterExerciseDate, discount.currentLink().referenceDate(),
disModel_));
Handle <YieldTermStructure> fwd = fwdModel_.termStructure();
fwdTs_.linkTo(new FdmAffineModelTermStructure(fwdRate,
fwd.currentLink().calendar(), fwd.currentLink().dayCounter(),
iterExerciseDate, fwd.currentLink().referenceDate(),
fwdModel_));
}
else
{
(disTs_.currentLink() as FdmAffineModelTermStructure).setVariable(disRate);
(fwdTs_.currentLink() as FdmAffineModelTermStructure).setVariable(fwdRate);
}
double npv = 0.0;
for (int j = 0; j < 2; j++)
{
for (int i = 0; i < swap_.leg(j).Count; ++i)
{
npv += (swap_.leg(j)[i] as Coupon).accrualStartDate() >= iterExerciseDate
? swap_.leg(j)[i].amount() * disTs_.currentLink().discount(swap_.leg(j)[i].date())
: 0.0;
}
if (j == 0)
{
npv *= -1.0;
}
}
if (swap_.swapType == VanillaSwap.Type.Receiver)
{
npv *= -1.0;
}
return(Math.Max(0.0, npv));
}
public static GeneralizedBlackScholesProcess processHelper(Handle <Quote> s0,
Handle <YieldTermStructure> rTS,
Handle <YieldTermStructure> qTS,
double vol)
{
return(new GeneralizedBlackScholesProcess(
s0, qTS, rTS,
new Handle <BlackVolTermStructure>(
new BlackConstantVol(rTS.currentLink().referenceDate(),
new Calendar(),
vol,
rTS.currentLink().dayCounter()))));
}
public QuantoTermStructure(
Handle <YieldTermStructure> underlyingDividendTS,
Handle <YieldTermStructure> riskFreeTS,
Handle <YieldTermStructure> foreignRiskFreeTS,
Handle <BlackVolTermStructure> underlyingBlackVolTS,
double strike,
Handle <BlackVolTermStructure> exchRateBlackVolTS,
double exchRateATMlevel,
double underlyingExchRateCorrelation)
: base(underlyingDividendTS.currentLink().dayCounter())
{
underlyingDividendTS_ = underlyingDividendTS;
riskFreeTS_ = riskFreeTS;
foreignRiskFreeTS_ = foreignRiskFreeTS;
underlyingBlackVolTS_ = underlyingBlackVolTS;
exchRateBlackVolTS_ = exchRateBlackVolTS;
underlyingExchRateCorrelation_ = underlyingExchRateCorrelation;
strike_ = strike;
exchRateATMlevel_ = exchRateATMlevel;
underlyingDividendTS_.registerWith(update);
riskFreeTS_.registerWith(update);
foreignRiskFreeTS_.registerWith(update);
underlyingBlackVolTS_.registerWith(update);
exchRateBlackVolTS_.registerWith(update);
}
public FdmHestonLocalVolatilityVarianceMesher(int size,
HestonProcess process,
LocalVolTermStructure leverageFct,
double maturity,
int tAvgSteps = 10,
double epsilon = 0.0001)
: base(size)
{
leverageFct_ = leverageFct;
FdmHestonVarianceMesher mesher = new FdmHestonVarianceMesher(size, process, maturity, tAvgSteps, epsilon);
for (int i = 0; i < size; ++i)
{
dplus_[i] = mesher.dplus(i);
dminus_[i] = mesher.dminus(i);
locations_[i] = mesher.location(i);
}
volaEstimate_ = mesher.volaEstimate();
if (leverageFct != null)
{
double s0 = process.s0().currentLink().value();
List <double> acc = new List <double>();
acc.Add(leverageFct.localVol(0.0, s0, true));
Handle <YieldTermStructure> rTS = process.riskFreeRate();
Handle <YieldTermStructure> qTS = process.dividendYield();
for (int l = 1; l <= tAvgSteps; ++l)
{
double t = (maturity * l) / tAvgSteps;
double vol = volaEstimate_ * acc.Average();
double fwd = s0 * qTS.currentLink().discount(t) / rTS.currentLink().discount(t);
int sAvgSteps = 50;
Vector u = new Vector(sAvgSteps), sig = new Vector(sAvgSteps);
for (int i = 0; i < sAvgSteps; ++i)
{
u[i] = epsilon + ((1.0 - 2.0 * epsilon) / (sAvgSteps - 1.0)) * i;
double x = new InverseCumulativeNormal().value(u[i]);
double gf = x * vol * Math.Sqrt(t);
double f = fwd * Math.Exp(gf);
sig[i] = Math.Pow(leverageFct.localVol(t, f, true), 2.0);
}
double leverageAvg = new GaussLobattoIntegral(10000, 1E-4).value(new interpolated_volatility(u, sig).value,
u.First(),
u.Last())
/ (1.0 - 2.0 * epsilon);
acc.Add(leverageAvg);
}
volaEstimate_ *= acc.Average();
}
}
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.Instance.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());
// Vanilla 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
DoubleBarrierOption doubleBarrierOption = new DoubleBarrierOption(
DoubleBarrier.Type.KnockOut,
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 override void calculate()
{
// 1. Term structure
Handle <YieldTermStructure> ts = model_.currentLink().termStructure();
// 2. Mesher
DayCounter dc = ts.currentLink().dayCounter();
Date referenceDate = ts.currentLink().referenceDate();
double maturity = dc.yearFraction(referenceDate,
arguments_.exercise.lastDate());
OrnsteinUhlenbeckProcess process = new OrnsteinUhlenbeckProcess(model_.currentLink().a(), model_.currentLink().sigma());
Fdm1dMesher shortRateMesher =
new FdmSimpleProcess1DMesher(xGrid_, process, maturity, 1, invEps_);
FdmMesher mesher = new FdmMesherComposite(shortRateMesher);
// 3. Inner Value Calculator
List <Date> exerciseDates = arguments_.exercise.dates();
Dictionary <double, Date> t2d = new Dictionary <double, Date>();
for (int i = 0; i < exerciseDates.Count; ++i)
{
double t = dc.yearFraction(referenceDate, exerciseDates[i]);
Utils.QL_REQUIRE(t >= 0, () => "exercise dates must not contain past date");
t2d.Add(t, exerciseDates[i]);
}
Handle <YieldTermStructure> disTs = model_.currentLink().termStructure();
Handle <YieldTermStructure> fwdTs
= arguments_.swap.iborIndex().forwardingTermStructure();
Utils.QL_REQUIRE(fwdTs.currentLink().dayCounter() == disTs.currentLink().dayCounter(),
() => "day counter of forward and discount curve must match");
Utils.QL_REQUIRE(fwdTs.currentLink().referenceDate() == disTs.currentLink().referenceDate(),
() => "reference date of forward and discount curve must match");
HullWhite fwdModel =
new HullWhite(fwdTs, model_.currentLink().a(), model_.currentLink().sigma());
FdmInnerValueCalculator calculator =
new FdmAffineModelSwapInnerValue <HullWhite>(
model_.currentLink(), fwdModel,
arguments_.swap, t2d, mesher, 0);
// 4. Step conditions
FdmStepConditionComposite conditions =
FdmStepConditionComposite.vanillaComposite(
new DividendSchedule(), arguments_.exercise,
mesher, calculator, referenceDate, dc);
// 5. Boundary conditions
FdmBoundaryConditionSet boundaries = new FdmBoundaryConditionSet();
// 6. Solver
FdmSolverDesc solverDesc = new FdmSolverDesc();
solverDesc.mesher = mesher;
solverDesc.bcSet = boundaries;
solverDesc.condition = conditions;
solverDesc.calculator = calculator;
solverDesc.maturity = maturity;
solverDesc.timeSteps = tGrid_;
solverDesc.dampingSteps = dampingSteps_;
FdmHullWhiteSolver solver =
new FdmHullWhiteSolver(model_, solverDesc, schemeDesc_);
results_.value = solver.valueAt(0.0);
}
// Instrument interface
public override void calculate()
{
Utils.QL_REQUIRE(!discountCurve_.empty(), () => "discounting term structure handle is empty");
results_.value = results_.cash = 0;
results_.errorEstimate = null;
Date refDate = discountCurve_.link.referenceDate();
Date settlementDate = settlementDate_;
if (settlementDate_ == null)
{
settlementDate = refDate;
}
else
{
Utils.QL_REQUIRE(settlementDate >= refDate, () =>
"settlement date (" + settlementDate + ") before " +
"discount curve reference date (" + refDate + ")");
}
results_.valuationDate = npvDate_;
if (npvDate_ == null)
{
results_.valuationDate = refDate;
}
else
{
Utils.QL_REQUIRE(npvDate_ >= refDate, () =>
"npv date (" + npvDate_ + ") before " +
"discount curve reference date (" + refDate + ")");
}
results_.npvDateDiscount = discountCurve_.link.discount(results_.valuationDate);
int n = arguments_.legs.Count;
results_.legNPV = new InitializedList <double?>(n);
results_.legBPS = new InitializedList <double?>(n);
results_.startDiscounts = new InitializedList <double?>(n);
results_.endDiscounts = new InitializedList <double?>(n);
bool includeRefDateFlows =
includeSettlementDateFlows_.HasValue ?
includeSettlementDateFlows_.Value :
Settings.Instance.includeReferenceDateEvents;
for (int i = 0; i < n; ++i)
{
try
{
YieldTermStructure discount_ref = discountCurve_.currentLink();
double npv = 0, bps = 0;
CashFlows.npvbps(arguments_.legs[i],
discount_ref,
includeRefDateFlows,
settlementDate,
results_.valuationDate,
out npv,
out bps);
results_.legNPV[i] = npv * arguments_.payer[i];
results_.legBPS[i] = bps * arguments_.payer[i];
if (!arguments_.legs[i].empty())
{
Date d1 = CashFlows.startDate(arguments_.legs[i]);
if (d1 >= refDate)
{
results_.startDiscounts[i] = discountCurve_.link.discount(d1);
}
else
{
results_.startDiscounts[i] = null;
}
Date d2 = CashFlows.maturityDate(arguments_.legs[i]);
if (d2 >= refDate)
{
results_.endDiscounts[i] = discountCurve_.link.discount(d2);
}
else
{
results_.endDiscounts[i] = null;
}
}
else
{
results_.startDiscounts[i] = null;
results_.endDiscounts[i] = null;
}
}
catch (Exception e)
{
Utils.QL_FAIL((i + 1) + " leg: " + e.Message);
}
results_.value += results_.legNPV[i];
}
}
protected override double localVolImpl(double t, double underlyingLevel)
{
double dr = riskFreeTS_.currentLink().discount(t, true);
double dq = dividendTS_.currentLink().discount(t, true);
double forwardValue = underlying_.currentLink().value() * dq / dr;
// strike derivatives
double strike, y, dy, strikep, strikem;
double w, wp, wm, dwdy, d2wdy2;
strike = underlyingLevel;
y = Math.Log(strike / forwardValue);
dy = ((Math.Abs(y) > 0.001) ? y * 0.0001 : 0.000001);
strikep = strike * Math.Exp(dy);
strikem = strike / Math.Exp(dy);
w = blackTS_.link.blackVariance(t, strike, true);
wp = blackTS_.link.blackVariance(t, strikep, true);
wm = blackTS_.link.blackVariance(t, strikem, true);
dwdy = (wp - wm) / (2.0 * dy);
d2wdy2 = (wp - 2.0 * w + wm) / (dy * dy);
// time derivative
double dt, wpt, wmt, dwdt;
if (t.IsEqual(0.0))
{
dt = 0.0001;
double drpt = riskFreeTS_.currentLink().discount(t + dt, true);
double dqpt = dividendTS_.currentLink().discount(t + dt, true);
double strikept = strike * dr * dqpt / (drpt * dq);
wpt = blackTS_.link.blackVariance(t + dt, strikept, true);
Utils.QL_REQUIRE(wpt >= w, () =>
"decreasing variance at strike " + strike + " between time " + t + " and time " + (t + dt));
dwdt = (wpt - w) / dt;
}
else
{
dt = Math.Min(0.0001, t / 2.0);
double drpt = riskFreeTS_.currentLink().discount(t + dt, true);
double drmt = riskFreeTS_.currentLink().discount(t - dt, true);
double dqpt = dividendTS_.currentLink().discount(t + dt, true);
double dqmt = dividendTS_.currentLink().discount(t - dt, true);
double strikept = strike * dr * dqpt / (drpt * dq);
double strikemt = strike * dr * dqmt / (drmt * dq);
wpt = blackTS_.link.blackVariance(t + dt, strikept, true);
wmt = blackTS_.link.blackVariance(t - dt, strikemt, true);
Utils.QL_REQUIRE(wpt >= w, () =>
"decreasing variance at strike " + strike + " between time " + t + " and time " + (t + dt));
Utils.QL_REQUIRE(w >= wmt, () =>
"decreasing variance at strike " + strike + " between time " + (t - dt) + " and time " + t);
dwdt = (wpt - wmt) / (2.0 * dt);
}
if (dwdy.IsEqual(0.0) && d2wdy2.IsEqual(0.0)) // avoid /w where w might be 0.0
{
return(Math.Sqrt(dwdt));
}
else
{
double den1 = 1.0 - y / w * dwdy;
double den2 = 0.25 * (-0.25 - 1.0 / w + y * y / w / w) * dwdy * dwdy;
double den3 = 0.5 * d2wdy2;
double den = den1 + den2 + den3;
double result = dwdt / den;
Utils.QL_REQUIRE(result >= 0.0, () =>
"negative local vol^2 at strike " + strike + " and time " + t + "; the black vol surface is not smooth enough");
return(Math.Sqrt(result));
}
}
public FdmBlackScholesMesher(int size,
GeneralizedBlackScholesProcess process,
double maturity, double strike,
double?xMinConstraint = null,
double?xMaxConstraint = null,
double eps = 0.0001,
double scaleFactor = 1.5,
Pair <double?, double?> cPoint
= null,
DividendSchedule dividendSchedule = null,
FdmQuantoHelper fdmQuantoHelper = null,
double spotAdjustment = 0.0)
: base(size)
{
double S = process.x0();
Utils.QL_REQUIRE(S > 0.0, () => "negative or null underlying given");
dividendSchedule = dividendSchedule == null ? new DividendSchedule() : dividendSchedule;
List <pair_double> intermediateSteps = new List <pair_double>();
for (int i = 0; i < dividendSchedule.Count &&
process.time(dividendSchedule[i].date()) <= maturity; ++i)
{
intermediateSteps.Add(
new pair_double(
process.time(dividendSchedule[i].date()),
dividendSchedule[i].amount()
));
}
int intermediateTimeSteps = (int)Math.Max(2, 24.0 * maturity);
for (int i = 0; i < intermediateTimeSteps; ++i)
{
intermediateSteps.Add(
new pair_double((i + 1) * (maturity / intermediateTimeSteps), 0.0));
}
intermediateSteps.Sort();
Handle <YieldTermStructure> rTS = process.riskFreeRate();
Handle <YieldTermStructure> qTS = fdmQuantoHelper != null
? new Handle <YieldTermStructure>(
new QuantoTermStructure(process.dividendYield(),
process.riskFreeRate(),
new Handle <YieldTermStructure>(fdmQuantoHelper.foreignTermStructure()),
process.blackVolatility(),
strike,
new Handle <BlackVolTermStructure>(fdmQuantoHelper.fxVolatilityTermStructure()),
fdmQuantoHelper.exchRateATMlevel(),
fdmQuantoHelper.equityFxCorrelation()))
: process.dividendYield();
double lastDivTime = 0.0;
double fwd = S + spotAdjustment;
double mi = fwd, ma = fwd;
for (int i = 0; i < intermediateSteps.Count; ++i)
{
double divTime = intermediateSteps[i].first;
double divAmount = intermediateSteps[i].second;
fwd = fwd / rTS.currentLink().discount(divTime) * rTS.currentLink().discount(lastDivTime)
* qTS.currentLink().discount(divTime) / qTS.currentLink().discount(lastDivTime);
mi = Math.Min(mi, fwd); ma = Math.Max(ma, fwd);
fwd -= divAmount;
mi = Math.Min(mi, fwd); ma = Math.Max(ma, fwd);
lastDivTime = divTime;
}
// Set the grid boundaries
double normInvEps = new InverseCumulativeNormal().value(1 - eps);
double sigmaSqrtT
= process.blackVolatility().currentLink().blackVol(maturity, strike)
* Math.Sqrt(maturity);
double?xMin = Math.Log(mi) - sigmaSqrtT * normInvEps * scaleFactor;
double?xMax = Math.Log(ma) + sigmaSqrtT * normInvEps * scaleFactor;
if (xMinConstraint != null)
{
xMin = xMinConstraint;
}
if (xMaxConstraint != null)
{
xMax = xMaxConstraint;
}
Fdm1dMesher helper;
if (cPoint != null &&
cPoint.first != null &&
Math.Log(cPoint.first.Value) >= xMin && Math.Log(cPoint.first.Value) <= xMax)
{
helper = new Concentrating1dMesher(xMin.Value, xMax.Value, size,
new Pair <double?, double?>(Math.Log(cPoint.first.Value), cPoint.second));
}
else
{
helper = new Uniform1dMesher(xMin.Value, xMax.Value, size);
}
locations_ = helper.locations();
for (int i = 0; i < locations_.Count; ++i)
{
dplus_[i] = helper.dplus(i);
dminus_[i] = helper.dminus(i);
}
}
public override void calculate()
{
Utils.QL_REQUIRE(arguments_.barrierType == Barrier.Type.UpIn ||
arguments_.barrierType == Barrier.Type.UpOut ||
arguments_.barrierType == Barrier.Type.DownIn ||
arguments_.barrierType == Barrier.Type.DownOut, () =>
"Invalid barrier type");
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.Instance.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());
// Vanilla 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 barrierType;
if (arguments_.barrierType == Barrier.Type.UpOut)
{
barrierType = arguments_.barrierType;
}
else if (arguments_.barrierType == Barrier.Type.UpIn)
{
barrierType = Barrier.Type.UpOut;
}
else if (arguments_.barrierType == Barrier.Type.DownOut)
{
barrierType = arguments_.barrierType;
}
else
{
barrierType = Barrier.Type.DownOut;
}
BarrierOption barrierOption = new BarrierOption(barrierType,
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;
}
}
