protected double getResidual(
final double fwd, final double expiry, final double[] ks, final double[] vols) {
// Check for trivial case where cutoff is so low that there's no effective value in the option
final double cutoffPrice =
BlackFormulaRepository.price(fwd, ks[0], expiry, vols[0], ks[0] > fwd);
if (CompareUtils.closeEquals(cutoffPrice, 0)) {
return 0.0; // i.e. the tail function is never used
}
// The typical case - fit a ShiftedLognormal to the two strike-vol pairs
final ShiftedLognormalVolModel leftExtrapolator =
new ShiftedLognormalVolModel(fwd, expiry, ks[0], vols[0], ks[1], vols[1]);
// Now, handle behaviour near zero strike. ShiftedLognormalVolModel has non-zero put price for
// zero strike.
// What we do is to find the strike, k_min, at which f(k) = p(k)/k^2 begins to blow up, by
// finding the minimum of this function, k_min
// then setting f(k) = f(k_min) for k < k_min. This ensures the implied volatility and the
// integrand are well behaved in the limit k -> 0.
final Function1D<Double, Double> shiftedLnIntegrand =
new Function1D<Double, Double>() {
@Override
public Double evaluate(final Double strike) {
return leftExtrapolator.priceFromFixedStrike(strike) / (strike * strike);
}
};
final double kMin = new BrentMinimizer1D().minimize(shiftedLnIntegrand, EPS, EPS, ks[0]);
final double fMin = shiftedLnIntegrand.evaluate(kMin);
double res = fMin * kMin; // the (hopefully) very small rectangular bit between zero and kMin
res += _integrator.integrate(shiftedLnIntegrand, kMin, ks[0]);
return res;
}
public void theta() {
double priceFutures =
METHOD_FUTURE.price(CALL_JB_147.getUnderlyingFuture(), ISSUER_SPECIFIC_MULTICURVES);
double expiry = CALL_JB_147.getExpirationTime();
double volatility = BLACK_SURFACE_EXP_STRIKE.getZValue(expiry, STRIKE_147);
double rate =
-Math.log(
ISSUER_SPECIFIC_MULTICURVES
.getMulticurveProvider()
.getDiscountFactor(CALL_JB_147.getCurrency(), CALL_JB_147.getExpirationTime()))
/ CALL_JB_147.getExpirationTime();
double thetaCallExpected =
BlackFormulaRepository.theta(
priceFutures,
STRIKE_147,
CALL_JB_147.getExpirationTime(),
volatility,
CALL_JB_147.isCall(),
rate);
double thetaCallComputed = METHOD_OPT.theta(CALL_JB_147, BLACK_EXP_STRIKE_BNDFUT);
assertEquals(
"BondFuturesOptionMarginSecurityBlackFlatMethod: theta",
thetaCallExpected,
thetaCallComputed,
TOLERANCE_DELTA);
}
@Override
public Pair<double[], double[]> visitDelta(
final BlackVolatilitySurfaceDelta surface, final DoublesPair data) {
Validate.isTrue(data.first > 0.0 && data.first < 1.0, "cut off must be a valide delta (0,1)");
Validate.isTrue(
data.second > 0.0 && data.second < data.first,
"spread must be positive and numerically less than cutoff");
final double[] deltas = new double[2];
final double[] k = new double[2];
final double[] vols = new double[2];
deltas[0] = data.first;
deltas[1] = data.first - data.second;
vols[0] = surface.getVolatilityForDelta(_t, deltas[0]);
vols[1] = surface.getVolatilityForDelta(_t, deltas[1]);
k[0] = BlackFormulaRepository.strikeForDelta(_f, deltas[0], _t, vols[0], true);
k[1] = BlackFormulaRepository.strikeForDelta(_f, deltas[1], _t, vols[1], true);
Validate.isTrue(k[0] < k[1], "need first (cutoff) strike less than second");
return new ObjectsPair<double[], double[]>(k, vols);
}
@SuppressWarnings("synthetic-access")
@Override
public Double visitDelta(final BlackVolatilitySurfaceDelta surface, final DoublesPair data) {
Validate.isTrue(data.first < data.second, "lower limit not less that upper");
Validate.isTrue(data.first >= 0.0, "lower limit < 0.0");
Validate.isTrue(data.second <= 1.0, "upper limit > 1.0");
if (_t < 1e-4) {
final double dnsVol = surface.getVolatilityForDelta(_t, 0.5);
return dnsVol * dnsVol; // this will be identical to atm-vol for t-> 0
}
final Function1D<Double, Double> integrand = getDeltaIntegrand(surface);
// find the delta corresponding to the at-the-money-forward (NOTE this is not the DNS of delta
// = 0.5)
final double atmfVol = surface.getVolatility(_t, _f);
final double atmfDelta = BlackFormulaRepository.delta(_f, _f, _t, atmfVol, true);
final double lowerLimit = data.first;
final double upperLimit = data.second;
// Do the call/k^2 integral - split up into the the put integral and the call integral because
// the function is not smooth at strike = forward
double res = _integrator.integrate(integrand, lowerLimit, atmfDelta); // Call part
if (_addResidual) {
// The lower strike cutoff is expressed as a absolute strike (i.e. k << f), while the
// upperLimit is a call delta (values close to one = small absolute strikes),
// so we must covert the lower strike cutoff to a upper delta cutoff
final double limitVol = surface.getVolatility(_t, _lowStrikeCutoff);
final double limitDelta =
BlackFormulaRepository.delta(_f, _lowStrikeCutoff, _t, limitVol, true);
final double u = Math.min(upperLimit, limitDelta);
res += _integrator.integrate(integrand, atmfDelta, u); // put part
res += _residual;
} else {
res += _integrator.integrate(integrand, atmfDelta, upperLimit); // put part
}
return 2 * res / _t;
}
private double presentValueDeltaStandard(
final double forward,
final double strike,
final double expiry,
final boolean isCall,
final double df,
final double notional,
final double yearFraction) {
double volatility = _smileFunction.getVolatility(strike);
double price =
BlackFormulaRepository.delta(forward, strike, expiry, volatility, isCall)
* df
* notional
* yearFraction;
return price;
}
@SuppressWarnings("synthetic-access")
@Override
public Double visitDelta(final BlackVolatilitySurfaceDelta surface) {
if (_t < 1e-4) {
final double atmVol = surface.getVolatility(_t, _f);
return atmVol * atmVol;
}
final double lowerLimit = _tol;
double upperLimit;
if (_addResidual) {
final double limitVol = surface.getVolatility(_t, _lowStrikeCutoff);
upperLimit = BlackFormulaRepository.delta(_f, _lowStrikeCutoff, _t, limitVol, true);
} else {
upperLimit = 1 - _tol;
}
final DoublesPair limits = new DoublesPair(lowerLimit, upperLimit);
return visitDelta(surface, limits);
}
/** The dividend is cash or proportional to asset price */
@Test
public void priceDiscreteDividendTest() {
final LatticeSpecification[] lattices =
new LatticeSpecification[] {
new CoxRossRubinsteinLatticeSpecification(),
new JarrowRuddLatticeSpecification(),
new TrigeorgisLatticeSpecification(),
new JabbourKraminYoungLatticeSpecification(),
new TianLatticeSpecification(),
new LeisenReimerLatticeSpecification()
};
final double[] propDividends = new double[] {0.01, 0.01, 0.01};
final double[] cashDividends = new double[] {5., 10., 8.};
final double[] dividendTimes = new double[] {TIME / 9., TIME / 3., TIME / 2.};
final boolean[] tfSet = new boolean[] {true, false};
for (final LatticeSpecification lattice : lattices) {
for (final boolean isCall : tfSet) {
for (final double strike : STRIKES) {
for (final double interest : INTERESTS) {
for (final double vol : VOLS) {
final int[] choicesSteps = new int[] {33, 115};
for (final int nSteps : choicesSteps) {
final OptionFunctionProvider1D function =
new EuropeanVanillaOptionFunctionProvider(strike, TIME, nSteps, isCall);
final DividendFunctionProvider cashDividend =
new CashDividendFunctionProvider(dividendTimes, cashDividends);
final DividendFunctionProvider propDividend =
new ProportionalDividendFunctionProvider(dividendTimes, propDividends);
final double df = Math.exp(-interest * TIME);
final double resSpot =
SPOT
* Math.exp(interest * TIME)
* (1. - propDividends[0])
* (1. - propDividends[1])
* (1. - propDividends[2]);
final double modSpot =
SPOT
- cashDividends[0] * Math.exp(-interest * dividendTimes[0])
- cashDividends[1] * Math.exp(-interest * dividendTimes[1])
- cashDividends[2] * Math.exp(-interest * dividendTimes[2]);
final double exactProp =
df * BlackFormulaRepository.price(resSpot, strike, TIME, vol, isCall);
final double appCash =
BlackScholesFormulaRepository.price(
modSpot, strike, TIME, vol, interest, interest, isCall);
final double resProp =
_model.getPrice(lattice, function, SPOT, vol, interest, propDividend);
final double refProp = Math.max(exactProp, 1.) / Math.sqrt(nSteps);
assertEquals(resProp, exactProp, refProp);
final double resCash =
_model.getPrice(lattice, function, SPOT, vol, interest, cashDividend);
final double refCash = Math.max(appCash, 1.) / Math.sqrt(nSteps);
assertEquals(resCash, appCash, refCash);
if (lattice instanceof CoxRossRubinsteinLatticeSpecification
|| lattice instanceof JarrowRuddLatticeSpecification
|| lattice instanceof TrigeorgisLatticeSpecification
|| lattice instanceof TianLatticeSpecification) {
final double resPropTrinomial =
_modelTrinomial.getPrice(
lattice, function, SPOT, vol, interest, propDividend);
final double resCashTrinomial =
_modelTrinomial.getPrice(
lattice, function, SPOT, vol, interest, cashDividend);
assertEquals(
resPropTrinomial, resProp, Math.max(resProp, 1.) / Math.sqrt(nSteps));
assertEquals(
resCashTrinomial, resCash, Math.max(resCash, 1.) / Math.sqrt(nSteps));
}
}
}
}
}
}
}
}
/** Check trivial extrapolation is recovered for Benaim-Dodgson-Kainth extrapolation */
@Test
public void functionRecoveryBDKExtrapolationTest() {
double forward = 1.0;
double expiry = 3.0;
int nSamples = 4;
double[] strikes = new double[nSamples];
double[] vols = new double[nSamples];
final double mu = 1.0;
final double a = -1.0;
final double b = 0.0;
final double c = 0.0;
// Expected left extrapolation
Function1D<Double, Double> left =
new Function1D<Double, Double>() {
@Override
public Double evaluate(Double strike) {
return Math.pow(strike, mu) * Math.exp(a + b * strike + c * strike * strike);
}
};
// Expected right extrapolation
Function1D<Double, Double> right =
new Function1D<Double, Double>() {
@Override
public Double evaluate(Double strike) {
return Math.pow(strike, -mu) * Math.exp(a + b / strike + c / strike / strike);
}
};
for (int i = 0; i < nSamples; ++i) {
double strike = forward * (0.75 + 0.05 * i);
double price = left.evaluate(strike);
double vol = BlackFormulaRepository.impliedVolatility(price, forward, strike, expiry, false);
strikes[i] = strike;
vols[i] = vol;
}
SmileExtrapolationFunctionSABRProvider extrapBDK =
new BenaimDodgsonKainthExtrapolationFunctionProvider(mu, mu);
SmileInterpolatorSABRWithExtrapolation interpBDK =
new SmileInterpolatorSABRWithExtrapolation(
new SABRBerestyckiVolatilityFunction(), extrapBDK);
InterpolatedSmileFunction funcBDK =
new InterpolatedSmileFunction(interpBDK, forward, strikes, expiry, vols);
double[] keys = new double[] {forward * 0.1, forward * 0.5, forward * 0.66};
for (int i = 0; i < keys.length; ++i) {
double vol = funcBDK.getVolatility(keys[i]);
double price = BlackFormulaRepository.price(forward, keys[i], expiry, vol, false);
assertEquals(left.evaluate(keys[i]), price, 1.e-2);
}
for (int i = 0; i < nSamples; ++i) {
double strike = forward * (1.1 + 0.05 * i);
double price = right.evaluate(strike);
double vol = BlackFormulaRepository.impliedVolatility(price, forward, strike, expiry, true);
strikes[i] = strike;
vols[i] = vol;
}
extrapBDK = new BenaimDodgsonKainthExtrapolationFunctionProvider(mu, mu);
interpBDK = new SmileInterpolatorSABRWithExtrapolation(extrapBDK);
funcBDK = new InterpolatedSmileFunction(interpBDK, forward, strikes, expiry, vols);
keys = new double[] {forward * 1.31, forward * 1.5, forward * 2.61, forward * 15.0};
for (int i = 0; i < keys.length; ++i) {
double vol = funcBDK.getVolatility(keys[i]);
double price = BlackFormulaRepository.price(forward, keys[i], expiry, vol, true);
assertEquals(right.evaluate(keys[i]), price, 1.e-2);
}
}
/** Check C2 smoothness of Benaim-Dodgson-Kainth extrapolation */
@Test
public void BDKSmoothnessGeneralTest() {
double eps = 1.0e-5;
double expiry = 1.5;
double forward = 1.1;
int nStrikes = 10;
double[] strikes = new double[nStrikes];
double[] impliedVols =
new double[] {0.97, 0.92, 0.802, 0.745, 0.781, 0.812, 0.8334, 0.878, 0.899, 0.9252};
for (int i = 0; i < nStrikes; ++i) {
strikes[i] = forward * (0.85 + i * 0.05);
}
double muLow =
strikes[0]
* BlackFormulaRepository.dualDelta(forward, strikes[0], expiry, impliedVols[0], false)
/ BlackFormulaRepository.price(forward, strikes[0], expiry, impliedVols[0], false);
double muHigh =
-strikes[nStrikes - 1]
* BlackFormulaRepository.dualDelta(
forward, strikes[nStrikes - 1], expiry, impliedVols[nStrikes - 1], true)
/ BlackFormulaRepository.price(
forward, strikes[nStrikes - 1], expiry, impliedVols[nStrikes - 1], true);
SmileExtrapolationFunctionSABRProvider extrapBDK =
new BenaimDodgsonKainthExtrapolationFunctionProvider(muLow, muHigh);
SmileInterpolatorSABRWithExtrapolation interpBDK =
new SmileInterpolatorSABRWithExtrapolation(
new SABRBerestyckiVolatilityFunction(), extrapBDK);
InterpolatedSmileFunction funcBDK =
new InterpolatedSmileFunction(interpBDK, forward, strikes, expiry, impliedVols);
List<SABRFormulaData> modelParams =
(new SmileInterpolatorSABR())
.getFittedModelParameters(forward, strikes, expiry, impliedVols);
SABRExtrapolationLeftFunction sabrLeftExtrapolation =
new SABRExtrapolationLeftFunction(
forward,
modelParams.get(0),
strikes[0],
expiry,
muLow,
new SABRHaganVolatilityFunction());
SABRExtrapolationRightFunction sabrRightExtrapolation =
new SABRExtrapolationRightFunction(
forward,
modelParams.get(nStrikes - 3),
strikes[nStrikes - 1],
expiry,
muHigh,
new SABRHaganVolatilityFunction());
/*
* left interpolation
*/
{
// Checking underlying extrapolation
double boundaryValue =
sabrLeftExtrapolation.price(new EuropeanVanillaOption(strikes[0], expiry, false));
double CutoffUp = strikes[0] + eps;
double CutoffDw = strikes[0] - eps;
double optionPriceExt =
sabrLeftExtrapolation.price(new EuropeanVanillaOption(CutoffDw, expiry, false));
double optionPriceInt =
sabrLeftExtrapolation.price(new EuropeanVanillaOption(CutoffUp, expiry, false));
assertEquals(boundaryValue, optionPriceExt, eps);
assertEquals(boundaryValue, optionPriceInt, eps);
double optionPriceExtDw =
sabrLeftExtrapolation.price(new EuropeanVanillaOption(CutoffDw - eps, expiry, false));
double firstExt = (1.5 * boundaryValue + 0.5 * optionPriceExtDw - 2.0 * optionPriceExt) / eps;
double optionPriceIntUp =
sabrLeftExtrapolation.price(new EuropeanVanillaOption(CutoffUp + eps, expiry, false));
double firstInt = (2.0 * optionPriceInt - 0.5 * optionPriceIntUp - 1.5 * boundaryValue) / eps;
assertEquals(firstInt, firstExt, eps);
double secondExt = (boundaryValue + optionPriceExtDw - 2.0 * optionPriceExt) / eps / eps;
double secondInt = (optionPriceIntUp + boundaryValue - 2.0 * optionPriceInt) / eps / eps;
assertEquals(secondInt, secondExt, Math.abs(secondInt) * 1.0e-3);
// Checking volatility function
double volInt = funcBDK.getVolatility(CutoffUp);
double volExt = funcBDK.getVolatility(CutoffDw);
double volBoundary = funcBDK.getVolatility(strikes[0]);
assertEquals(volBoundary, volInt, eps);
assertEquals(volBoundary, volExt, eps);
double volExtDw = funcBDK.getVolatility(CutoffDw - eps);
double volFirstExt = (1.5 * volBoundary + 0.5 * volExtDw - 2.0 * volExt) / eps;
double volIntUp = funcBDK.getVolatility(CutoffUp + eps);
double volFirstInt = (2.0 * volInt - 0.5 * volIntUp - 1.5 * volBoundary) / eps;
assertEquals(volFirstInt, volFirstExt, eps);
double volSecondExt = (volBoundary + volExtDw - 2.0 * volExt) / eps / eps;
double volSecondInt = (volIntUp + volBoundary - 2.0 * volInt) / eps / eps;
assertEquals(volSecondInt, volSecondExt, Math.abs(volSecondInt) * 1.0e-3);
}
/*
* right interpolation
*/
{
// Checking underlying extrapolation
double boundaryValue =
sabrRightExtrapolation.price(
new EuropeanVanillaOption(strikes[nStrikes - 1], expiry, true));
double CutoffUp = strikes[nStrikes - 1] + eps;
double CutoffDw = strikes[nStrikes - 1] - eps;
double optionPriceExt =
sabrRightExtrapolation.price(new EuropeanVanillaOption(CutoffUp, expiry, true));
double optionPriceInt =
sabrRightExtrapolation.price(new EuropeanVanillaOption(CutoffDw, expiry, true));
assertEquals(boundaryValue, optionPriceExt, eps);
assertEquals(boundaryValue, optionPriceInt, eps);
double optionPriceExtUp =
sabrRightExtrapolation.price(new EuropeanVanillaOption(CutoffUp + eps, expiry, true));
double firstExt = (2.0 * optionPriceExt - 0.5 * optionPriceExtUp - 1.5 * boundaryValue) / eps;
double optionPriceIntDw =
sabrRightExtrapolation.price(new EuropeanVanillaOption(CutoffDw - eps, expiry, true));
double firstInt =
(-2.0 * optionPriceInt + 1.5 * boundaryValue + 0.5 * optionPriceIntDw) / eps;
assertEquals(firstInt, firstExt, eps);
double secondExt = (optionPriceExtUp + boundaryValue - 2.0 * optionPriceExt) / eps / eps;
double secondInt = (boundaryValue + optionPriceIntDw - 2.0 * optionPriceInt) / eps / eps;
assertEquals(secondInt, secondExt, Math.abs(secondInt) * 1.0e-3);
// Checking volatility function
double volInt = funcBDK.getVolatility(CutoffDw);
double volExt = funcBDK.getVolatility(CutoffUp);
double volBoundary = funcBDK.getVolatility(strikes[nStrikes - 1]);
assertEquals(volBoundary, volInt, eps);
assertEquals(volBoundary, volExt, eps);
double volExtUp = funcBDK.getVolatility(CutoffUp + eps);
double volFirstExt = (2.0 * volExt - 0.5 * volExtUp - 1.5 * volBoundary) / eps;
double volIntDw = funcBDK.getVolatility(CutoffDw - eps);
double volFirstInt = (-2.0 * volInt + 1.5 * volBoundary + 0.5 * volIntDw) / eps;
assertEquals(volFirstInt, volFirstExt, eps);
double volSecondExt = (volBoundary + volExtUp - 2.0 * volExt) / eps / eps;
double volSecondInt = (volIntDw + volBoundary - 2.0 * volInt) / eps / eps;
assertEquals(volSecondInt, volSecondExt, Math.abs(volSecondInt) * 1.0e-3);
}
}
@SuppressWarnings("unused")
@Test
public void limitTest() {
final LocalDate optionExpiry = getNextIMMDate(TRADE_DATE).minusDays(1);
final double timeToExpiry = ACT365F.yearFraction(TRADE_DATE, optionExpiry);
final CDSAnalytic fwdCDX = FACTORY.makeCDX(optionExpiry, Period.ofYears(5));
final CDSAnalytic fwdStartingCDX = fwdCDX.withOffset(timeToExpiry);
final double[] indexPUF = new double[] {0.0556, 0.0582, 0.0771, 0.0652};
final CDSAnalytic[] indexCDS = FACTORY.makeCDX(TRADE_DATE, INDEX_PILLARS);
final IntrinsicIndexDataBundle adjCurves =
PSA.adjustCurves(indexPUF, indexCDS, INDEX_COUPON, YIELD_CURVE, INTRINSIC_DATA);
final double fwdSpread =
INDEX_CAL.defaultAdjustedForwardSpread(
fwdStartingCDX, timeToExpiry, YIELD_CURVE, adjCurves);
final double fwdAnnuity = INDEX_CAL.indexAnnuity(fwdStartingCDX, YIELD_CURVE, adjCurves);
final BlackIndexOptionPricer pricerWithFwd =
new BlackIndexOptionPricer(
fwdCDX, timeToExpiry, YIELD_CURVE, INDEX_COUPON, fwdSpread, fwdAnnuity);
final double modStrikeLimit = INDEX_COUPON + fwdCDX.getLGD() / fwdAnnuity;
final double vol = 0.4;
final double payLargeSpLimit =
fwdAnnuity
* BlackFormulaRepository.price(fwdSpread, modStrikeLimit, timeToExpiry, vol, true);
final double recLargeSpLimit =
fwdAnnuity
* BlackFormulaRepository.price(fwdSpread, modStrikeLimit, timeToExpiry, vol, false);
final double largeStrikeSp = 75.0;
final double payLargeStrikeSp =
pricerWithFwd.getOptionPriceForSpreadQuotedIndex(largeStrikeSp, vol, true);
final double recLargeStrikeSp =
pricerWithFwd.getOptionPriceForSpreadQuotedIndex(largeStrikeSp, vol, false);
assertEquals(payLargeSpLimit, payLargeStrikeSp, 1.e-12);
assertEquals(
recLargeSpLimit,
recLargeStrikeSp,
1.e-3); // larger strike spread ends up with failure in root-finding
/** Exception expected */
final double negativeTime = -0.5;
try {
new BlackIndexOptionPricer(
fwdCDX, negativeTime, YIELD_CURVE, INDEX_COUPON, fwdSpread, fwdAnnuity);
throw new RuntimeException();
} catch (final Exception e) {
assertEquals("timeToExpiry must be positive. Value given " + negativeTime, e.getMessage());
}
try {
new BlackIndexOptionPricer(
fwdStartingCDX, timeToExpiry, YIELD_CURVE, INDEX_COUPON, fwdSpread, fwdAnnuity);
throw new RuntimeException();
} catch (final Exception e) {
assertEquals("fwdCDS should be a Forward CDS", e.getMessage());
}
final double negativeCoupon = -150.0 * 1.0e-4;
try {
new BlackIndexOptionPricer(
fwdCDX, timeToExpiry, YIELD_CURVE, negativeCoupon, fwdSpread, fwdAnnuity);
throw new RuntimeException();
} catch (final Exception e) {
assertEquals("indexCoupon must be positive", e.getMessage());
}
final double negativeFwdSp = -0.5;
try {
new BlackIndexOptionPricer(
fwdCDX, timeToExpiry, YIELD_CURVE, INDEX_COUPON, negativeFwdSp, fwdAnnuity);
throw new RuntimeException();
} catch (final Exception e) {
assertEquals("defaultAdjustedFwdSpread must be positive", e.getMessage());
}
final double negativeAnn = -0.3;
try {
new BlackIndexOptionPricer(
fwdCDX, timeToExpiry, YIELD_CURVE, INDEX_COUPON, fwdSpread, negativeAnn);
throw new RuntimeException();
} catch (final Exception e) {
assertEquals("pvFwdAnnuity must be positive", e.getMessage());
}
final double largeAnn = fwdCDX.getProtectionEnd() * 2.0;
try {
new BlackIndexOptionPricer(
fwdCDX, timeToExpiry, YIELD_CURVE, INDEX_COUPON, fwdSpread, largeAnn);
throw new RuntimeException();
} catch (final Exception e) {
assertEquals(
"Value of annuity of "
+ largeAnn
+ " is greater than length (in years) of forward CDS. Annuity should be given for unit notional",
e.getMessage());
}
final double smallStrike = -0.9;
try {
pricerWithFwd.getOptionPriceForPriceQuotedIndex(smallStrike, vol, true);
throw new RuntimeException();
} catch (final Exception e) {
assertTrue(e instanceof IllegalArgumentException);
}
final double largeStrike = 0.9;
try {
pricerWithFwd.getOptionPriceForPriceQuotedIndex(largeStrike, vol, true);
throw new RuntimeException();
} catch (final Exception e) {
assertTrue(e instanceof IllegalArgumentException);
}
try {
pricerWithFwd.getOptionPriceForSpreadQuotedIndex(smallStrike, vol, true);
throw new RuntimeException();
} catch (final Exception e) {
assertTrue(e instanceof IllegalArgumentException);
}
}