public void calculate()
{
setupArguments(arguments_);
setGridLimits();
initializeInitialCondition();
initializeOperator();
initializeBoundaryConditions();
var model = new FiniteDifferenceModel <CrankNicolson <TridiagonalOperator> >(finiteDifferenceOperator_, BCs_);
prices_ = (SampledCurve)intrinsicValues_.Clone();
// this is a workaround for pointers to avoid unsafe code
// in the grid calculation Vector temp goes through many operations
object temp = prices_.values();
model.rollback(ref temp, getResidualTime(), 0, timeSteps_);
prices_.setValues((Vector)temp);
results_.value = prices_.valueAtCenter();
results_.delta = prices_.firstDerivativeAtCenter();
results_.gamma = prices_.secondDerivativeAtCenter();
results_.theta = Utils.blackScholesTheta(process_,
results_.value.GetValueOrDefault(),
results_.delta.GetValueOrDefault(),
results_.gamma.GetValueOrDefault());
results_.additionalResults.Add("priceCurve", prices_);
}
public override void calculate()
{
DayCounter rfdc = process_.riskFreeRate().link.dayCounter();
DayCounter divdc = process_.dividendYield().link.dayCounter();
DayCounter voldc = process_.blackVolatility().link.dayCounter();
Calendar volcal = process_.blackVolatility().link.calendar();
double s0 = process_.stateVariable().link.value();
if (!(s0 > 0.0))
{
throw new ApplicationException("negative or null underlying given");
}
double v = process_.blackVolatility().link.blackVol(arguments_.exercise.lastDate(), s0);
Date maturityDate = arguments_.exercise.lastDate();
double r = process_.riskFreeRate().link.zeroRate(maturityDate, rfdc, Compounding.Continuous, Frequency.NoFrequency).rate();
double q = process_.dividendYield().link.zeroRate(maturityDate, divdc, Compounding.Continuous, Frequency.NoFrequency).rate();
Date referenceDate = process_.riskFreeRate().link.referenceDate();
// binomial trees with constant coefficient
var flatRiskFree = new Handle <YieldTermStructure>(new FlatForward(referenceDate, r, rfdc));
var flatDividends = new Handle <YieldTermStructure>(new FlatForward(referenceDate, q, divdc));
var flatVol = new Handle <BlackVolTermStructure>(new BlackConstantVol(referenceDate, volcal, v, voldc));
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
if (payoff == null)
{
throw new ApplicationException("non-plain payoff given");
}
double maturity = rfdc.yearFraction(referenceDate, maturityDate);
StochasticProcess1D bs =
new GeneralizedBlackScholesProcess(process_.stateVariable(), flatDividends, flatRiskFree, flatVol);
TimeGrid grid = new TimeGrid(maturity, timeSteps_);
T tree = new T().factory(bs, maturity, timeSteps_, payoff.strike());
BlackScholesLattice <T> lattice = new BlackScholesLattice <T>(tree, r, maturity, timeSteps_);
DiscretizedVanillaOption option = new DiscretizedVanillaOption(arguments_, process_, grid);
option.initialize(lattice, maturity);
// Partial derivatives calculated from various points in the
// binomial tree (Odegaard)
// Rollback to third-last step, and get underlying price (s2) &
// option values (p2) at this point
option.rollback(grid[2]);
Vector va2 = new Vector(option.values());
if (!(va2.size() == 3))
{
throw new ApplicationException("Expect 3 nodes in grid at second step");
}
double p2h = va2[2]; // high-price
double s2 = lattice.underlying(2, 2); // high price
// Rollback to second-last step, and get option value (p1) at
// this point
option.rollback(grid[1]);
Vector va = new Vector(option.values());
if (!(va.size() == 2))
{
throw new ApplicationException("Expect 2 nodes in grid at first step");
}
double p1 = va[1];
// Finally, rollback to t=0
option.rollback(0.0);
double p0 = option.presentValue();
double s1 = lattice.underlying(1, 1);
// Calculate partial derivatives
double delta0 = (p1 - p0) / (s1 - s0); // dp/ds
double delta1 = (p2h - p1) / (s2 - s1); // dp/ds
// Store results
results_.value = p0;
results_.delta = delta0;
results_.gamma = 2.0 * (delta1 - delta0) / (s2 - s0); //d(delta)/ds
results_.theta = Utils.blackScholesTheta(process_,
results_.value.GetValueOrDefault(),
results_.delta.GetValueOrDefault(),
results_.gamma.GetValueOrDefault());
}
public override void calculate()
{
/* this engine cannot really check for the averageType==Geometric
* since it can be used as control variate for the Arithmetic version
* QL_REQUIRE(arguments_.averageType == Average::Geometric,"not a geometric average option")
*/
Utils.QL_REQUIRE(arguments_.exercise.type() == Exercise.Type.European, () => "not an European Option");
double runningLog;
int pastFixings;
if (arguments_.averageType == Average.Type.Geometric)
{
Utils.QL_REQUIRE(arguments_.runningAccumulator > 0.0, () =>
"positive running product required: " + arguments_.runningAccumulator + " not allowed");
runningLog = Math.Log(arguments_.runningAccumulator.GetValueOrDefault());
pastFixings = arguments_.pastFixings.GetValueOrDefault();
}
else
{ // it is being used as control variate
runningLog = 1.0;
pastFixings = 0;
}
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-plain payoff given");
Date referenceDate = process_.riskFreeRate().link.referenceDate();
DayCounter rfdc = process_.riskFreeRate().link.dayCounter();
DayCounter divdc = process_.dividendYield().link.dayCounter();
DayCounter voldc = process_.blackVolatility().link.dayCounter();
List <double> fixingTimes = new List <double>();
int i;
for (i = 0; i < arguments_.fixingDates.Count; i++)
{
if (arguments_.fixingDates[i] >= referenceDate)
{
double t = voldc.yearFraction(referenceDate, arguments_.fixingDates[i]);
fixingTimes.Add(t);
}
}
int remainingFixings = fixingTimes.Count;
int numberOfFixings = pastFixings + remainingFixings;
double N = numberOfFixings;
double pastWeight = pastFixings / N;
double futureWeight = 1.0 - pastWeight;
double timeSum = 0;
fixingTimes.ForEach((ii, vv) => timeSum += fixingTimes[ii]);
double vola = process_.blackVolatility().link.blackVol(arguments_.exercise.lastDate(), payoff.strike());
double temp = 0.0;
for (i = pastFixings + 1; i < numberOfFixings; i++)
{
temp += fixingTimes[i - pastFixings - 1] * (N - i);
}
double variance = vola * vola / N / N * (timeSum + 2.0 * temp);
double dsigG_dsig = Math.Sqrt((timeSum + 2.0 * temp)) / N;
double sigG = vola * dsigG_dsig;
double dmuG_dsig = -(vola * timeSum) / N;
Date exDate = arguments_.exercise.lastDate();
double dividendRate = process_.dividendYield().link.
zeroRate(exDate, divdc, Compounding.Continuous, Frequency.NoFrequency).rate();
double riskFreeRate = process_.riskFreeRate().link.
zeroRate(exDate, rfdc, Compounding.Continuous, Frequency.NoFrequency).rate();
double nu = riskFreeRate - dividendRate - 0.5 * vola * vola;
double s = process_.stateVariable().link.value();
Utils.QL_REQUIRE(s > 0.0, () => "positive underlying value required");
int M = (pastFixings == 0 ? 1 : pastFixings);
double muG = pastWeight * runningLog / M + futureWeight * Math.Log(s) + nu * timeSum / N;
double forwardPrice = Math.Exp(muG + variance / 2.0);
double riskFreeDiscount = process_.riskFreeRate().link.discount(arguments_.exercise.lastDate());
BlackCalculator black = new BlackCalculator(payoff, forwardPrice, Math.Sqrt(variance), riskFreeDiscount);
results_.value = black.value();
results_.delta = futureWeight * black.delta(forwardPrice) * forwardPrice / s;
results_.gamma = forwardPrice * futureWeight / (s * s)
* (black.gamma(forwardPrice) * futureWeight * forwardPrice
- pastWeight * black.delta(forwardPrice));
double Nx_1, nx_1;
CumulativeNormalDistribution CND = new CumulativeNormalDistribution();
NormalDistribution ND = new NormalDistribution();
if (sigG > Const.QL_EPSILON)
{
double x_1 = (muG - Math.Log(payoff.strike()) + variance) / sigG;
Nx_1 = CND.value(x_1);
nx_1 = ND.value(x_1);
}
else
{
Nx_1 = (muG > Math.Log(payoff.strike()) ? 1.0 : 0.0);
nx_1 = 0.0;
}
results_.vega = forwardPrice * riskFreeDiscount *
((dmuG_dsig + sigG * dsigG_dsig) * Nx_1 + nx_1 * dsigG_dsig);
if (payoff.optionType() == Option.Type.Put)
{
results_.vega -= riskFreeDiscount * forwardPrice *
(dmuG_dsig + sigG * dsigG_dsig);
}
double tRho = rfdc.yearFraction(process_.riskFreeRate().link.referenceDate(),
arguments_.exercise.lastDate());
results_.rho = black.rho(tRho) * timeSum / (N * tRho)
- (tRho - timeSum / N) * results_.value;
double tDiv = divdc.yearFraction(
process_.dividendYield().link.referenceDate(),
arguments_.exercise.lastDate());
results_.dividendRho = black.dividendRho(tDiv) * timeSum / (N * tDiv);
results_.strikeSensitivity = black.strikeSensitivity();
results_.theta = Utils.blackScholesTheta(process_,
results_.value.GetValueOrDefault(),
results_.delta.GetValueOrDefault(),
results_.gamma.GetValueOrDefault());
}
