public void applyTo(object o, double t)
{
Vector a = (Vector)o;
if (exerciseTimes_.BinarySearch(t) >= 0)
{
FdmLinearOpLayout layout = mesher_.layout();
FdmLinearOpIterator endIter = layout.end();
int dims = layout.dim().Count;
Vector locations = new Vector(dims);
for (FdmLinearOpIterator iter = layout.begin();
iter != endIter;
++iter)
{
for (int i = 0; i < dims; ++i)
{
locations[i] = mesher_.location(iter, i);
}
double innerValue = calculator_.innerValue(iter, t);
if (innerValue > a[iter.index()])
{
a[iter.index()] = innerValue;
}
}
}
}
public SecondDerivativeOp(int direction, FdmMesher mesher)
: base(direction, mesher)
{
FdmLinearOpLayout layout = mesher.layout();
FdmLinearOpIterator endIter = layout.end();
for (FdmLinearOpIterator iter = layout.begin(); iter != endIter; ++iter)
{
int i = iter.index();
double?hm = mesher.dminus(iter, direction_);
double?hp = mesher.dplus(iter, direction_);
double?zetam1 = hm * (hm + hp);
double?zeta0 = hm * hp;
double?zetap1 = hp * (hm + hp);
int co = iter.coordinates()[direction_];
if (co == 0 || co == layout.dim()[direction] - 1)
{
lower_[i] = diag_[i] = upper_[i] = 0.0;
}
else
{
lower_[i] = 2.0 / zetam1.Value;
diag_[i] = -2.0 / zeta0.Value;
upper_[i] = 2.0 / zetap1.Value;
}
}
}
public int neighbourhood(FdmLinearOpIterator iterator,
int i1, int offset1,
int i2, int offset2)
{
int myIndex = iterator.index()
- iterator.coordinates()[i1] * spacing_[i1]
- iterator.coordinates()[i2] * spacing_[i2];
int coorOffset1 = iterator.coordinates()[i1] + offset1;
if (coorOffset1 < 0)
{
coorOffset1 = -coorOffset1;
}
else if (coorOffset1 >= dim_[i1])
{
coorOffset1 = 2 * (dim_[i1] - 1) - coorOffset1;
}
int coorOffset2 = iterator.coordinates()[i2] + offset2;
if (coorOffset2 < 0)
{
coorOffset2 = -coorOffset2;
}
else if (coorOffset2 >= dim_[i2])
{
coorOffset2 = 2 * (dim_[i2] - 1) - coorOffset2;
}
return(myIndex + coorOffset1 * spacing_[i1] + coorOffset2 * spacing_[i2]);
}
public FdmIndicesOnBoundary(FdmLinearOpLayout layout,
int direction, FdmDirichletBoundary.Side side)
{
List <int> newDim = new List <int>(layout.dim());
newDim[direction] = 1;
int hyperSize
= newDim.accumulate(0, newDim.Count, 1,
(a, b) => (a * b));
indices_ = new InitializedList <int>(hyperSize);
int i = 0;
FdmLinearOpIterator endIter = layout.end();
for (FdmLinearOpIterator iter = layout.begin();
iter != endIter;
++iter)
{
if ((side == FdmDirichletBoundary.Side.Lower &&
iter.coordinates()[direction] == 0) ||
(side == FdmDirichletBoundary.Side.Upper &&
iter.coordinates()[direction]
== layout.dim()[direction] - 1))
{
Utils.QL_REQUIRE(hyperSize > i, () => "index missmatch");
indices_[i++] = iter.index();
}
}
}
protected double avgInnerValueCalc(FdmLinearOpIterator iter, double t)
{
int dim = mesher_.layout().dim()[direction_];
int coord = iter.coordinates()[direction_];
double loc = mesher_.location(iter, direction_);
double a = loc;
double b = loc;
if (coord > 0)
{
a -= mesher_.dminus(iter, direction_).Value / 2.0;
}
if (coord < dim - 1)
{
b += mesher_.dplus(iter, direction_).Value / 2.0;
}
Func <double, double> f = x => payoff_.value(Math.Exp(x));
double retVal;
try {
double acc
= ((f(a) != 0.0 || f(b) != 0.0) ? (f(a) + f(b)) * 5e-5 : 1e-4);
retVal = new SimpsonIntegral(acc, 8).value(f, a, b) / (b - a);
}
catch {
// use default value
retVal = innerValue(iter, t);
}
return(retVal);
}
public Fdm1DimSolver(FdmSolverDesc solverDesc,
FdmSchemeDesc schemeDesc,
FdmLinearOpComposite op)
{
solverDesc_ = solverDesc;
schemeDesc_ = schemeDesc;
op_ = op;
thetaCondition_ = new FdmSnapshotCondition(
0.99 * Math.Min(1.0 / 365.0,
solverDesc.condition.stoppingTimes().empty()
? solverDesc.maturity
: solverDesc.condition.stoppingTimes().First()));
conditions_ = FdmStepConditionComposite.joinConditions(thetaCondition_,
solverDesc.condition);
x_ = new InitializedList <double>(solverDesc.mesher.layout().size());
initialValues_ = new InitializedList <double>(solverDesc.mesher.layout().size());
resultValues_ = new Vector(solverDesc.mesher.layout().size());
FdmMesher mesher = solverDesc.mesher;
FdmLinearOpLayout layout = mesher.layout();
FdmLinearOpIterator endIter = layout.end();
for (FdmLinearOpIterator iter = layout.begin(); iter != endIter;
++iter)
{
initialValues_[iter.index()]
= solverDesc_.calculator.avgInnerValue(iter,
solverDesc.maturity);
x_[iter.index()] = mesher.location(iter, 0);
}
}
public override double innerValue(FdmLinearOpIterator iter, double t)
{
Vector x = new Vector(mesher_.layout().dim().Count);
for (int i = 0; i < x.size(); ++i)
{
x[i] = Math.Exp(mesher_.location(iter, i));
}
return(payoff_.value(x));
}
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 override Vector locations(int direction)
{
Vector retVal = new Vector(layout_.size());
FdmLinearOpIterator endIter = layout_.end();
for (FdmLinearOpIterator iter = layout_.begin();
iter != endIter;
++iter)
{
retVal[iter.index()] = locations_[direction][iter.coordinates()[direction]];
}
return(retVal);
}
public Vector solve_splitting(Vector r, double a, double b = 1.0)
{
FdmLinearOpLayout layout = mesher_.layout();
Utils.QL_REQUIRE(r.size() == layout.size(), () => "inconsistent size of rhs");
for (FdmLinearOpIterator iter = layout.begin();
iter != layout.end(); ++iter)
{
List <int> coordinates = iter.coordinates();
Utils.QL_REQUIRE(coordinates[direction_] != 0 ||
lower_[iter.index()] == 0, () => "removing non zero entry!");
Utils.QL_REQUIRE(coordinates[direction_] != layout.dim()[direction_] - 1 ||
upper_[iter.index()] == 0, () => "removing non zero entry!");
}
Vector retVal = new Vector(r.size()), tmp = new Vector(r.size());
// Thomson algorithm to solve a tridiagonal system.
// Example code taken from Tridiagonalopertor and
// changed to fit for the triple band operator.
int rim1 = reverseIndex_[0];
double bet = 1.0 / (a * diag_[rim1] + b);
Utils.QL_REQUIRE(bet != 0.0, () => "division by zero");
retVal[reverseIndex_[0]] = r[rim1] * bet;
for (int j = 1; j <= layout.size() - 1; j++)
{
int ri = reverseIndex_[j];
tmp[j] = a * upper_[rim1] * bet;
bet = b + a * (diag_[ri] - tmp[j] * lower_[ri]);
Utils.QL_REQUIRE(bet != 0.0, () => "division by zero"); //QL_ENSURE
bet = 1.0 / bet;
retVal[ri] = (r[ri] - a * lower_[ri] * retVal[rim1]) * bet;
rim1 = ri;
}
// cannot be j>=0 with Size j
for (int j = layout.size() - 2; j > 0; --j)
{
retVal[reverseIndex_[j]] -= tmp[j + 1] * retVal[reverseIndex_[j + 1]];
}
retVal[reverseIndex_[0]] -= tmp[1] * retVal[reverseIndex_[1]];
return(retVal);
}
public void applyTo(object o, double t)
{
Vector a = (Vector)o;
FdmLinearOpLayout layout = mesher_.layout();
FdmLinearOpIterator endIter = layout.end();
for (FdmLinearOpIterator iter = layout.begin(); iter != endIter;
++iter)
{
double innerValue = calculator_.innerValue(iter, t);
if (innerValue > a[iter.index()])
{
a[iter.index()] = innerValue;
}
}
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
FdmLinearOpIterator iter = obj as FdmLinearOpIterator;
if (iter == null)
{
return(false);
}
return(iter.index_ == index_);
}
public int neighbourhood(FdmLinearOpIterator iterator, int i, int offset)
{
int myIndex = iterator.index() - iterator.coordinates()[i] * spacing_[i];
int coorOffset = iterator.coordinates()[i] + offset;
if (coorOffset < 0)
{
coorOffset = -coorOffset;
}
else if (coorOffset >= dim_[i])
{
coorOffset = 2 * (dim_[i] - 1) - coorOffset;
}
return(myIndex + coorOffset * spacing_[i]);
}
//! Time \f$t1 <= t2\f$ is required
public override void setTime(double t1, double t2)
{
double r = rTS_.forwardRate(t1, t2, Compounding.Continuous).rate();
double q = qTS_.forwardRate(t1, t2, Compounding.Continuous).rate();
if (localVol_ != null)
{
FdmLinearOpLayout layout = mesher_.layout();
FdmLinearOpIterator endIter = layout.end();
Vector v = new Vector(layout.size());
for (FdmLinearOpIterator iter = layout.begin();
iter != endIter; ++iter)
{
int i = iter.index();
if (illegalLocalVolOverwrite_ == null)
{
double t = localVol_.localVol(0.5 * (t1 + t2), x_[i], true);
v[i] = t * t;
}
else
{
try
{
double t = localVol_.localVol(0.5 * (t1 + t2), x_[i], true);
v[i] = t * t;
}
catch
{
v[i] = illegalLocalVolOverwrite_.Value * illegalLocalVolOverwrite_.Value;
}
}
}
mapT_.axpyb(r - q - 0.5 * v, dxMap_,
dxxMap_.mult(0.5 * v), new Vector(1, -r));
}
else
{
double vv
= volTS_.blackForwardVariance(t1, t2, strike_) / (t2 - t1);
mapT_.axpyb(new Vector(1, r - q - 0.5 * vv), dxMap_,
dxxMap_.mult(0.5 * new Vector(mesher_.layout().size(), vv)),
new Vector(1, -r));
}
}
public NinePointLinearOp(int d0, int d1, FdmMesher mesher)
{
d0_ = d0;
d1_ = d1;
i00_ = new InitializedList <int>(mesher.layout().size());
i10_ = new InitializedList <int>(mesher.layout().size());
i20_ = new InitializedList <int>(mesher.layout().size());
i01_ = new InitializedList <int>(mesher.layout().size());
i21_ = new InitializedList <int>(mesher.layout().size());
i02_ = new InitializedList <int>(mesher.layout().size());
i12_ = new InitializedList <int>(mesher.layout().size());
i22_ = new InitializedList <int>(mesher.layout().size());
a00_ = new InitializedList <double>(mesher.layout().size());
a10_ = new InitializedList <double>(mesher.layout().size());
a20_ = new InitializedList <double>(mesher.layout().size());
a01_ = new InitializedList <double>(mesher.layout().size());
a11_ = new InitializedList <double>(mesher.layout().size());
a21_ = new InitializedList <double>(mesher.layout().size());
a02_ = new InitializedList <double>(mesher.layout().size());
a12_ = new InitializedList <double>(mesher.layout().size());
a22_ = new InitializedList <double>(mesher.layout().size());
mesher_ = mesher;
Utils.QL_REQUIRE(d0_ != d1_ &&
d0_ < mesher.layout().dim().Count &&
d1_ < mesher.layout().dim().Count,
() => "inconsistent derivative directions");
FdmLinearOpLayout layout = mesher.layout();
FdmLinearOpIterator endIter = layout.end();
for (FdmLinearOpIterator iter = layout.begin(); iter != endIter; ++iter)
{
int i = iter.index();
i10_[i] = layout.neighbourhood(iter, d1_, -1);
i01_[i] = layout.neighbourhood(iter, d0_, -1);
i21_[i] = layout.neighbourhood(iter, d0_, 1);
i12_[i] = layout.neighbourhood(iter, d1_, 1);
i00_[i] = layout.neighbourhood(iter, d0_, -1, d1_, -1);
i20_[i] = layout.neighbourhood(iter, d0_, 1, d1_, -1);
i02_[i] = layout.neighbourhood(iter, d0_, -1, d1_, 1);
i22_[i] = layout.neighbourhood(iter, d0_, 1, d1_, 1);
}
}
public FdmLinearOpIterator iter_neighbourhood(FdmLinearOpIterator iterator, int i, int offset)
{
List <int> coordinates = iterator.coordinates();
int coorOffset = coordinates[i] + offset;
if (coorOffset < 0)
{
coorOffset = -coorOffset;
}
else if (coorOffset >= dim_[i])
{
coorOffset = 2 * (dim_[i] - 1) - coorOffset;
}
coordinates[i] = coorOffset;
FdmLinearOpIterator retVal = new FdmLinearOpIterator(dim_, coordinates,
index(coordinates));
return(retVal);
}
public Vector getState(ModelType model, double t, FdmLinearOpIterator iter)
{
if (model.GetType().Equals(typeof(HullWhite)))
{
Vector retVal = new Vector(1, (model as HullWhite).dynamics().shortRate(t,
mesher_.location(iter, direction_)));
return(retVal);
}
else if (model.GetType().Equals(typeof(G2)))
{
Vector retVal = new Vector(2);
retVal[0] = mesher_.location(iter, direction_);
retVal[1] = mesher_.location(iter, direction_ + 1);
return(retVal);
}
else
{
return(new Vector());
}
}
public TripleBandLinearOp(int direction, FdmMesher mesher)
{
direction_ = direction;
i0_ = new InitializedList <int>(mesher.layout().size());
i2_ = new InitializedList <int>(mesher.layout().size());
reverseIndex_ = new InitializedList <int>(mesher.layout().size());
lower_ = new InitializedList <double>(mesher.layout().size());
diag_ = new InitializedList <double>(mesher.layout().size());
upper_ = new InitializedList <double>(mesher.layout().size());
mesher_ = mesher;
FdmLinearOpLayout layout = mesher.layout();
FdmLinearOpIterator endIter = layout.end();
int tmp;
List <int> newDim = new List <int>(layout.dim());
tmp = newDim[direction_];
newDim[direction_] = newDim[0];
newDim[0] = tmp;
List <int> newSpacing = new FdmLinearOpLayout(newDim).spacing();
tmp = newSpacing[direction_];
newSpacing[direction_] = newSpacing[0];
newSpacing[0] = tmp;
for (FdmLinearOpIterator iter = layout.begin(); iter != endIter; ++iter)
{
int i = iter.index();
i0_[i] = layout.neighbourhood(iter, direction, -1);
i2_[i] = layout.neighbourhood(iter, direction, 1);
List <int> coordinates = iter.coordinates();
int newIndex = coordinates.inner_product(0, coordinates.Count, 0, newSpacing, 0);
reverseIndex_[newIndex] = i;
}
}
public override double avgInnerValue(FdmLinearOpIterator iter, double t)
{
if (avgInnerValues_.empty())
{
// calculate caching values
avgInnerValues_ = new InitializedList <double>(mesher_.layout().dim()[direction_]);
List <bool> initialized = new InitializedList <bool>(avgInnerValues_.Count, false);
FdmLinearOpLayout layout = mesher_.layout();
FdmLinearOpIterator endIter = layout.end();
for (FdmLinearOpIterator new_iter = layout.begin(); new_iter != endIter;
++new_iter)
{
int xn = new_iter.coordinates()[direction_];
if (!initialized[xn])
{
initialized[xn] = true;
avgInnerValues_[xn] = avgInnerValueCalc(new_iter, t);
}
}
}
return(avgInnerValues_[iter.coordinates()[direction_]]);
}
public FirstDerivativeOp(int direction, FdmMesher mesher)
: base(direction, mesher)
{
FdmLinearOpLayout layout = mesher.layout();
FdmLinearOpIterator endIter = layout.end();
for (FdmLinearOpIterator iter = layout.begin(); iter != endIter; ++iter)
{
int i = iter.index();
double?hm = mesher.dminus(iter, direction_);
double?hp = mesher.dplus(iter, direction_);
double?zetam1 = hm * (hm + hp);
double?zeta0 = hm * hp;
double?zetap1 = hp * (hm + hp);
if (iter.coordinates()[direction_] == 0)
{
//upwinding scheme
lower_[i] = 0.0;
diag_[i] = -(upper_[i] = 1 / hp.Value);
}
else if (iter.coordinates()[direction_]
== layout.dim()[direction] - 1)
{
// downwinding scheme
lower_[i] = -(diag_[i] = 1 / hm.Value);
upper_[i] = 0.0;
}
else
{
lower_[i] = -hp.Value / zetam1.Value;
diag_[i] = (hp.Value - hm.Value) / zeta0.Value;
upper_[i] = hm.Value / zetap1.Value;
}
}
}
public override double avgInnerValue(FdmLinearOpIterator iter, double t)
{
return(innerValue(iter, t));
}
public override double location(FdmLinearOpIterator iter,
int direction)
{
return(locations_[direction][iter.coordinates()[direction]]);
}
public override double?dminus(FdmLinearOpIterator iter, int direction)
{
return(dx_[direction]);
}
public FdmLinearOpIterator(FdmLinearOpIterator iter)
{
swap(iter);
}
public void swap(FdmLinearOpIterator iter)
{
Utils.swap(ref iter.index_, ref index_);
Utils.swap(ref iter.dim_, ref dim_);
Utils.swap(ref iter.coordinates_, ref coordinates_);
}
public override double innerValue(FdmLinearOpIterator iter, double t)
{
return(0.0);
}
public abstract double?dminus(FdmLinearOpIterator iter,
int direction);
public abstract double avgInnerValue(FdmLinearOpIterator iter, double t);
public abstract double location(FdmLinearOpIterator iter,
int direction);
public override double innerValue(FdmLinearOpIterator iter, double t)
{
double s = Math.Exp(mesher_.location(iter, direction_));
return(payoff_.value(s));
}
