protected ZeroYieldStructure(int settlementDays, Calendar calendar, DayCounter dc = null,
List <Handle <Quote> > jumps = null, List <Date> jumpDates = null)
: base(settlementDays, calendar, dc, jumps, jumpDates)
{
}
public override void calculate()
{
Utils.QL_REQUIRE(arguments_.accruedCoupon == null &&
arguments_.lastFixing == null, () =>
"this engine cannot price options already started");
Utils.QL_REQUIRE(arguments_.localCap == null &&
arguments_.localFloor == null &&
arguments_.globalCap == null &&
arguments_.globalFloor == null, () =>
"this engine cannot price capped/floored options");
Utils.QL_REQUIRE(arguments_.exercise.type() == Exercise.Type.European, () => "not an European option");
PercentageStrikePayoff moneyness = arguments_.payoff as PercentageStrikePayoff;
Utils.QL_REQUIRE(moneyness != null, () => "wrong payoff given");
List <Date> resetDates = arguments_.resetDates;
resetDates.Add(arguments_.exercise.lastDate());
double underlying = process_.stateVariable().link.value();
Utils.QL_REQUIRE(underlying > 0.0, () => "negative or null underlying");
double strike = underlying * moneyness.strike();
StrikedTypePayoff payoff = new PlainVanillaPayoff(moneyness.optionType(), strike);
results_.value = 0.0;
results_.delta = results_.gamma = 0.0;
results_.theta = 0.0;
results_.rho = results_.dividendRho = 0.0;
results_.vega = 0.0;
for (int i = 1; i < resetDates.Count; i++)
{
double weight = process_.dividendYield().link.discount(resetDates[i - 1]);
double discount = process_.riskFreeRate().link.discount(resetDates[i]) /
process_.riskFreeRate().link.discount(resetDates[i - 1]);
double qDiscount = process_.dividendYield().link.discount(resetDates[i]) /
process_.dividendYield().link.discount(resetDates[i - 1]);
double forward = underlying * qDiscount / discount;
double variance = process_.blackVolatility().link.blackForwardVariance(resetDates[i - 1], resetDates[i], strike);
BlackCalculator black = new BlackCalculator(payoff, forward, Math.Sqrt(variance), discount);
DayCounter rfdc = process_.riskFreeRate().link.dayCounter();
DayCounter divdc = process_.dividendYield().link.dayCounter();
DayCounter voldc = process_.blackVolatility().link.dayCounter();
results_.value += weight * black.value();
results_.delta += weight * (black.delta(underlying) +
moneyness.strike() * discount *
black.beta());
results_.gamma += 0.0;
results_.theta += process_.dividendYield().link.forwardRate(
resetDates[i - 1], resetDates[i], rfdc, Compounding.Continuous, Frequency.NoFrequency).value() *
weight * black.value();
double dt = rfdc.yearFraction(resetDates[i - 1], resetDates[i]);
results_.rho += weight * black.rho(dt);
double t = divdc.yearFraction(process_.dividendYield().link.referenceDate(), resetDates[i - 1]);
dt = divdc.yearFraction(resetDates[i - 1], resetDates[i]);
results_.dividendRho += weight * (black.dividendRho(dt) -
t * black.value());
dt = voldc.yearFraction(resetDates[i - 1], resetDates[i]);
results_.vega += weight * black.vega(dt);
}
}
protected ZeroYieldStructure(DayCounter dc = null, List <Handle <Quote> > jumps = null, List <Date> jumpDates = null)
: base(dc, jumps, jumpDates)
{
}
protected ZeroYieldStructure(Date referenceDate, Calendar calendar = null, DayCounter dc = null,
List <Handle <Quote> > jumps = null, List <Date> jumpDates = null)
: base(referenceDate, calendar, dc, jumps, jumpDates)
{
}
public InterpolatedHazardRateCurve(List <Date> dates, List <double> hazardRates, DayCounter dayCounter, Calendar cal = null,
List <Handle <Quote> > jumps = null, List <Date> jumpDates = null, Interpolator interpolator = default(Interpolator))
: base(dates[0], cal, dayCounter, jumps, jumpDates)
{
dates_ = dates;
times_ = new List <double>();
data_ = hazardRates;
if (interpolator == null)
{
interpolator_ = FastActivator <Interpolator> .Create();
}
else
{
interpolator_ = interpolator;
}
initialize();
}
public InterpolatedHazardRateCurve(List <Date> dates, List <double> hazardRates, DayCounter dayCounter, Interpolator interpolator)
: base(dates[0], null, dayCounter)
{
dates_ = dates;
if (interpolator == null)
{
interpolator_ = FastActivator <Interpolator> .Create();
}
else
{
interpolator_ = interpolator;
}
initialize();
}
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");
PlainVanillaPayoff payoff = arguments_.payoff as PlainVanillaPayoff;
Utils.QL_REQUIRE(payoff != null, () => "non-plain payoff given");
double variance = process_.blackVolatility().link.blackVariance(ex.lastDate(), payoff.strike());
double dividendDiscount = process_.dividendYield().link.discount(ex.lastDate());
double riskFreeDiscount = process_.riskFreeRate().link.discount(ex.lastDate());
double spot = process_.stateVariable().link.value();
Utils.QL_REQUIRE(spot > 0.0, () => "negative or null underlying given");
double strike = payoff.strike();
if (payoff.optionType() == Option.Type.Put)
{
// use put-call simmetry
Utils.swap <double>(ref spot, ref strike);
Utils.swap <double>(ref riskFreeDiscount, ref dividendDiscount);
payoff = new PlainVanillaPayoff(Option.Type.Call, strike);
}
if (dividendDiscount >= 1.0)
{
// early exercise is never optimal - use Black formula
double forwardPrice = spot * dividendDiscount / riskFreeDiscount;
BlackCalculator black = new BlackCalculator(payoff, forwardPrice, Math.Sqrt(variance), riskFreeDiscount);
results_.value = black.value();
results_.delta = black.delta(spot);
results_.deltaForward = black.deltaForward();
results_.elasticity = black.elasticity(spot);
results_.gamma = black.gamma(spot);
DayCounter rfdc = process_.riskFreeRate().link.dayCounter();
DayCounter divdc = process_.dividendYield().link.dayCounter();
DayCounter voldc = process_.blackVolatility().link.dayCounter();
double t = rfdc.yearFraction(process_.riskFreeRate().link.referenceDate(), arguments_.exercise.lastDate());
results_.rho = black.rho(t);
t = divdc.yearFraction(process_.dividendYield().link.referenceDate(), arguments_.exercise.lastDate());
results_.dividendRho = black.dividendRho(t);
t = voldc.yearFraction(process_.blackVolatility().link.referenceDate(), arguments_.exercise.lastDate());
results_.vega = black.vega(t);
results_.theta = black.theta(spot, t);
results_.thetaPerDay = black.thetaPerDay(spot, t);
results_.strikeSensitivity = black.strikeSensitivity();
results_.itmCashProbability = black.itmCashProbability();
}
else
{
// early exercise can be optimal - use approximation
results_.value = americanCallApproximation(spot, strike, riskFreeDiscount, dividendDiscount, variance);
}
}
protected internal InterpolatedHazardRateCurve(int settlementDays, Calendar cal, DayCounter dc,
List <Handle <Quote> > jumps = null,
List <Date> jumpDates = null,
Interpolator interpolator = default(Interpolator))
: base(settlementDays, cal, dc, jumps, jumpDates)
{
}
//! calculate the reference date based on the global evaluation date
protected BlackVolTermStructure(int settlementDays, Calendar cal, BusinessDayConvention bdc = BusinessDayConvention.Following,
DayCounter dc = null)
: base(settlementDays, cal, bdc, dc)
{
}
//! initialize with a fixed reference date
protected BlackVolTermStructure(Date referenceDate, Calendar cal = null,
BusinessDayConvention bdc = BusinessDayConvention.Following, DayCounter dc = null)
: base(referenceDate, cal, bdc, dc)
{
}
//! default constructor
/*! \warning term structures initialized by means of this
* constructor must manage their own reference date
* by overriding the referenceDate() method.
*/
protected BlackVolTermStructure(BusinessDayConvention bdc = BusinessDayConvention.Following, DayCounter dc = null)
: base(bdc, dc)
{
}
public DiscretizedSwaption(Swaption.Arguments args,
Date referenceDate,
DayCounter dayCounter)
: base(new DiscretizedSwap(args, referenceDate, dayCounter), args.exercise.type(), new List <double>())
{
arguments_ = args;
exerciseTimes_ = new InitializedList <double>(arguments_.exercise.dates().Count);
for (int i = 0; i < exerciseTimes_.Count; ++i)
{
exerciseTimes_[i] =
dayCounter.yearFraction(referenceDate,
arguments_.exercise.date(i));
}
// Date adjustments can get time vectors out of synch.
// Here, we try and collapse similar dates which could cause
// a mispricing.
for (int i = 0; i < arguments_.exercise.dates().Count; i++)
{
Date exerciseDate = arguments_.exercise.date(i);
for (int j = 0; j < arguments_.fixedPayDates.Count; j++)
{
if (withinNextWeek(exerciseDate,
arguments_.fixedPayDates[j])
// coupons in the future are dealt with below
&& arguments_.fixedResetDates[j] < referenceDate)
{
arguments_.fixedPayDates[j] = exerciseDate;
}
}
for (int j = 0; j < arguments_.fixedResetDates.Count; j++)
{
if (withinPreviousWeek(exerciseDate,
arguments_.fixedResetDates[j]))
{
arguments_.fixedResetDates[j] = exerciseDate;
}
}
for (int j = 0; j < arguments_.floatingResetDates.Count; j++)
{
if (withinPreviousWeek(exerciseDate,
arguments_.floatingResetDates[j]))
{
arguments_.floatingResetDates[j] = exerciseDate;
}
}
}
double lastFixedPayment =
dayCounter.yearFraction(referenceDate,
arguments_.fixedPayDates.Last());
double lastFloatingPayment =
dayCounter.yearFraction(referenceDate,
arguments_.floatingPayDates.Last());
lastPayment_ = Math.Max(lastFixedPayment, lastFloatingPayment);
underlying_ = new DiscretizedSwap(arguments_,
referenceDate,
dayCounter);
}
// required for Handle
public BlackVarianceCurve(Date referenceDate, List <Date> dates, List <double> blackVolCurve, DayCounter dayCounter,
bool forceMonotoneVariance)
: base(referenceDate)
{
dayCounter_ = dayCounter;
maxDate_ = dates.Last();
Utils.QL_REQUIRE(dates.Count == blackVolCurve.Count, () => "mismatch between date vector and black vol vector");
// cannot have dates[0]==referenceDate, since the
// value of the vol at dates[0] would be lost
// (variance at referenceDate must be zero)
Utils.QL_REQUIRE(dates[0] > referenceDate, () => "cannot have dates[0] <= referenceDate");
variances_ = new InitializedList <double>(dates.Count + 1);
times_ = new InitializedList <double>(dates.Count + 1);
variances_[0] = 0.0;
times_[0] = 0.0;
for (int j = 1; j <= blackVolCurve.Count; j++)
{
times_[j] = timeFromReference(dates[j - 1]);
Utils.QL_REQUIRE(times_[j] > times_[j - 1], () => "dates must be sorted unique!");
variances_[j] = times_[j] * blackVolCurve[j - 1] * blackVolCurve[j - 1];
Utils.QL_REQUIRE(variances_[j] >= variances_[j - 1] || !forceMonotoneVariance, () => "variance must be non-decreasing");
}
// default: linear interpolation
setInterpolation <Linear>();
}