//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(enabled = true) public void log_normal_atm()
public virtual void log_normal_atm()
{
double beta = 0.50;
Surface betaSurface = ConstantSurface.of("Beta", beta).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).zValueType(ValueType.SABR_BETA).surfaceName("Beta").build());
double shift = 0.0000;
Surface shiftSurface = ConstantSurface.of("Shift", shift).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).surfaceName("Shift").build());
SabrParametersSwaptionVolatilities calibratedSmile = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, DATA_SPARSE, MULTICURVE, betaSurface, shiftSurface);
SabrParametersSwaptionVolatilities calibratedAtm = SABR_CALIBRATION.calibrateAlphaWithAtm(NAME_SABR, calibratedSmile, MULTICURVE, ATM_LOGNORMAL_SIMPLE, TENORS_SIMPLE, EXPIRIES_SIMPLE_2, INTERPOLATOR_2D);
int nbExp = EXPIRIES_SIMPLE_2.size();
int nbTenor = TENORS_SIMPLE.size();
for (int loopexpiry = 0; loopexpiry < nbExp; loopexpiry++)
{
for (int looptenor = 0; looptenor < nbTenor; looptenor++)
{
double tenor = TENORS_SIMPLE.get(looptenor).get(ChronoUnit.YEARS);
LocalDate expiry = EUR_FIXED_1Y_EURIBOR_6M.FloatingLeg.StartDateBusinessDayAdjustment.adjust(CALIBRATION_DATE.plus(EXPIRIES_SIMPLE_2.get(loopexpiry)), REF_DATA);
LocalDate effectiveDate = EUR_FIXED_1Y_EURIBOR_6M.calculateSpotDateFromTradeDate(expiry, REF_DATA);
LocalDate endDate = effectiveDate.plus(TENORS_SIMPLE.get(looptenor));
SwapTrade swap = EUR_FIXED_1Y_EURIBOR_6M.toTrade(CALIBRATION_DATE, effectiveDate, endDate, BuySell.BUY, 1.0, 0.0);
double parRate = SWAP_PRICER.parRate(swap.resolve(REF_DATA).Product, MULTICURVE);
ZonedDateTime expiryDateTime = expiry.atTime(11, 0).atZone(ZoneId.of("Europe/Berlin"));
double time = calibratedAtm.relativeTime(expiryDateTime);
double volBlack = calibratedAtm.volatility(expiryDateTime, tenor, parRate, parRate);
double priceComputed = calibratedAtm.price(time, tenor, PutCall.CALL, parRate, parRate, volBlack);
double priceBlack = BlackFormulaRepository.price(parRate, parRate, time, DATA_LOGNORMAL_ATM_SIMPLE[looptenor + loopexpiry * nbTenor], true);
assertEquals(priceComputed, priceBlack, TOLERANCE_PRICE_CALIBRATION_ROOT);
}
}
}
private const double TOLERANCE_PRICE_CALIBRATION_LS = 5.0E-4; // Calibration Least Square; result not exact
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void normal_cube()
public virtual void normal_cube()
{
double beta = 0.50;
Surface betaSurface = ConstantSurface.of("Beta", beta).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).zValueType(ValueType.SABR_BETA).surfaceName("Beta").build());
double shift = 0.0300;
Surface shiftSurface = ConstantSurface.of("Shift", shift).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).surfaceName("Shift").build());
SabrParametersSwaptionVolatilities calibrated = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, DATA_SPARSE, MULTICURVE, betaSurface, shiftSurface);
for (int looptenor = 0; looptenor < TENORS.size(); looptenor++)
{
double tenor = TENORS.get(looptenor).get(ChronoUnit.YEARS);
for (int loopexpiry = 0; loopexpiry < EXPIRIES.size(); loopexpiry++)
{
LocalDate expiry = EUR_FIXED_1Y_EURIBOR_6M.FloatingLeg.StartDateBusinessDayAdjustment.adjust(CALIBRATION_DATE.plus(EXPIRIES.get(loopexpiry)), REF_DATA);
LocalDate effectiveDate = EUR_FIXED_1Y_EURIBOR_6M.calculateSpotDateFromTradeDate(expiry, REF_DATA);
LocalDate endDate = effectiveDate.plus(TENORS.get(looptenor));
SwapTrade swap = EUR_FIXED_1Y_EURIBOR_6M.toTrade(CALIBRATION_DATE, effectiveDate, endDate, BuySell.BUY, 1.0, 0.0);
double parRate = SWAP_PRICER.parRate(swap.resolve(REF_DATA).Product, MULTICURVE);
ZonedDateTime expiryDateTime = expiry.atTime(11, 0).atZone(ZoneId.of("Europe/Berlin"));
double time = calibrated.relativeTime(expiryDateTime);
for (int loopmoney = 0; loopmoney < MONEYNESS.size(); loopmoney++)
{
if (!double.IsNaN(DATA_ARRAY_SPARSE[looptenor][loopexpiry][loopmoney]))
{
double strike = parRate + MONEYNESS.get(loopmoney);
double volBlack = calibrated.volatility(expiryDateTime, tenor, strike, parRate);
double priceComputed = BlackFormulaRepository.price(parRate + shift, parRate + MONEYNESS.get(loopmoney) + shift, time, volBlack, true);
double priceNormal = NormalFormulaRepository.price(parRate, parRate + MONEYNESS.get(loopmoney), time, DATA_ARRAY_SPARSE[looptenor][loopexpiry][loopmoney], PutCall.CALL);
assertEquals(priceComputed, priceNormal, TOLERANCE_PRICE_CALIBRATION_LS);
}
}
}
}
}
public virtual DeformedSurface localVolatilityFromPrice(Surface callPriceSurface, double spot, System.Func <double, double> interestRate, System.Func <double, double> dividendRate)
{
System.Func <DoublesPair, ValueDerivatives> func = (DoublesPair x) =>
{
double t = x.First;
double k = x.Second;
double r = interestRate(t);
double q = dividendRate(t);
double price = callPriceSurface.zValue(t, k);
DoubleArray priceSensi = callPriceSurface.zValueParameterSensitivity(t, k).Sensitivity;
double divT = FIRST_DERIV.differentiate(u => callPriceSurface.zValue(u, k)).apply(t);
DoubleArray divTSensi = FIRST_DERIV_SENSI.differentiate(u => callPriceSurface.zValueParameterSensitivity(u.get(0), k).Sensitivity).apply(DoubleArray.of(t)).column(0);
double divK = FIRST_DERIV.differentiate(l => callPriceSurface.zValue(t, l)).apply(k);
DoubleArray divKSensi = FIRST_DERIV_SENSI.differentiate(l => callPriceSurface.zValueParameterSensitivity(t, l.get(0)).Sensitivity).apply(DoubleArray.of(k)).column(0);
double divK2 = SECOND_DERIV.differentiate(l => callPriceSurface.zValue(t, l)).apply(k);
DoubleArray divK2Sensi = SECOND_DERIV_SENSI.differentiateNoCross(l => callPriceSurface.zValueParameterSensitivity(t, l.get(0)).Sensitivity).apply(DoubleArray.of(k)).column(0);
double var = 2d * (divT + q * price + (r - q) * k * divK) / (k * k * divK2);
if (var < 0d)
{
throw new System.ArgumentException("Negative variance");
}
double localVol = Math.Sqrt(var);
double factor = 1d / (localVol * k * k * divK2);
DoubleArray localVolSensi = divTSensi.multipliedBy(factor).plus(divKSensi.multipliedBy((r - q) * k * factor)).plus(priceSensi.multipliedBy(q * factor)).plus(divK2Sensi.multipliedBy(-0.5 * localVol / divK2));
return(ValueDerivatives.of(localVol, localVolSensi));
};
SurfaceMetadata metadata = DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.STRIKE).zValueType(ValueType.LOCAL_VOLATILITY).surfaceName(SurfaceName.of("localVol_" + callPriceSurface.Name)).build();
return(DeformedSurface.of(metadata, callPriceSurface, func));
}
public virtual InterpolatedNodalSurface localVolatilityFromPrice(Surface callPriceSurface, double spot, System.Func <double, double> interestRate, System.Func <double, double> dividendRate)
{
double[][] stateValue = new double[nSteps + 1][];
double[] df = new double[nSteps];
IList <DoubleMatrix> probability = new List <DoubleMatrix>(nSteps);
int nTotal = (nSteps - 1) * (nSteps - 1) + 1;
double[] timeRes = new double[nTotal];
double[] spotRes = new double[nTotal];
double[] volRes = new double[nTotal];
// uniform grid based on TrigeorgisLatticeSpecification, using reference values
double refPrice = callPriceSurface.zValue(maxTime, spot) * Math.Exp(interestRate(maxTime) * maxTime);
double refForward = spot * Math.Exp((interestRate(maxTime) - dividendRate(maxTime)) * maxTime);
double refVolatility = BlackFormulaRepository.impliedVolatility(refPrice, refForward, spot, maxTime, true);
double dt = maxTime / nSteps;
double dx = refVolatility * Math.Sqrt(3d * dt);
double upFactor = Math.Exp(dx);
double downFactor = Math.Exp(-dx);
double[] adSec = new double[2 * nSteps + 1];
double[] assetPrice = new double[2 * nSteps + 1];
for (int i = nSteps; i > -1; --i)
{
if (i == 0)
{
resolveFirstLayer(interestRate, dividendRate, nTotal, dt, spot, adSec, assetPrice, timeRes, spotRes, volRes, df, stateValue, probability);
}
else
{
double time = dt * i;
double zeroRate = interestRate(time);
double zeroDividendRate = dividendRate(time);
int nNodes = 2 * i + 1;
double[] assetPriceLocal = new double[nNodes];
double[] callOptionPrice = new double[nNodes];
double[] putOptionPrice = new double[nNodes];
int position = i - 1;
double assetTmp = spot * Math.Pow(upFactor, i);
// call options for upper half nodes
for (int j = nNodes - 1; j > position - 1; --j)
{
assetPriceLocal[j] = assetTmp;
callOptionPrice[j] = callPriceSurface.zValue(time, assetPriceLocal[j]);
assetTmp *= downFactor;
}
// put options for lower half nodes
assetTmp = spot * Math.Pow(downFactor, i);
for (int j = 0; j < position + 2; ++j)
{
assetPriceLocal[j] = assetTmp;
putOptionPrice[j] = callPriceSurface.zValue(time, assetPriceLocal[j]) - spot * Math.Exp(-zeroDividendRate * time) + Math.Exp(-zeroRate * time) * assetPriceLocal[j];
assetTmp *= upFactor;
}
resolveLayer(interestRate, dividendRate, i, nTotal, position, dt, zeroRate, zeroDividendRate, callOptionPrice, putOptionPrice, adSec, assetPrice, assetPriceLocal, timeRes, spotRes, volRes, df, stateValue, probability);
}
}
SurfaceMetadata metadata = DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.STRIKE).zValueType(ValueType.LOCAL_VOLATILITY).surfaceName(SurfaceName.of("localVol_" + callPriceSurface.Name)).build();
return(InterpolatedNodalSurface.ofUnsorted(metadata, DoubleArray.ofUnsafe(timeRes), DoubleArray.ofUnsafe(spotRes), DoubleArray.ofUnsafe(volRes), interpolator));
}
//-------------------------------------------------------------------------
public virtual InterpolatedNodalSurface localVolatilityFromImpliedVolatility(Surface impliedVolatilitySurface, double spot, System.Func <double, double> interestRate, System.Func <double, double> dividendRate)
{
System.Func <DoublesPair, double> surface = (DoublesPair tk) =>
{
return(impliedVolatilitySurface.zValue(tk));
};
ImmutableList <double[]> localVolData = calibrate(surface, spot, interestRate, dividendRate).First;
SurfaceMetadata metadata = DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.STRIKE).zValueType(ValueType.LOCAL_VOLATILITY).surfaceName(SurfaceName.of("localVol_" + impliedVolatilitySurface.Name)).build();
return(InterpolatedNodalSurface.ofUnsorted(metadata, DoubleArray.ofUnsafe(localVolData.get(0)), DoubleArray.ofUnsafe(localVolData.get(1)), DoubleArray.ofUnsafe(localVolData.get(2)), interpolator));
}
static BlackBondFutureOptionMarginedProductPricerTest()
{
IList <GenericVolatilitySurfaceYearFractionParameterMetadata> list = new List <GenericVolatilitySurfaceYearFractionParameterMetadata>();
int nData = TIME.size();
for (int i = 0; i < nData; ++i)
{
GenericVolatilitySurfaceYearFractionParameterMetadata parameterMetadata = GenericVolatilitySurfaceYearFractionParameterMetadata.of(TIME.get(i), LogMoneynessStrike.of(MONEYNESS.get(i)));
list.Add(parameterMetadata);
}
METADATA = DefaultSurfaceMetadata.builder().surfaceName(SurfaceName.of("GOVT1-BOND-FUT-VOL")).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.LOG_MONEYNESS).zValueType(ValueType.BLACK_VOLATILITY).parameterMetadata(list).dayCount(ACT_365F).build();
}
public virtual DeformedSurface localVolatilityFromImpliedVolatility(Surface impliedVolatilitySurface, double spot, System.Func <double, double> interestRate, System.Func <double, double> dividendRate)
{
System.Func <DoublesPair, ValueDerivatives> func = (DoublesPair x) =>
{
double t = x.First;
double k = x.Second;
double r = interestRate(t);
double q = dividendRate(t);
double vol = impliedVolatilitySurface.zValue(t, k);
DoubleArray volSensi = impliedVolatilitySurface.zValueParameterSensitivity(t, k).Sensitivity;
double divT = FIRST_DERIV.differentiate(u => impliedVolatilitySurface.zValue(u, k)).apply(t);
DoubleArray divTSensi = FIRST_DERIV_SENSI.differentiate(u => impliedVolatilitySurface.zValueParameterSensitivity(u.get(0), k).Sensitivity).apply(DoubleArray.of(t)).column(0);
double localVol;
DoubleArray localVolSensi = DoubleArray.of();
if (k < SMALL)
{
localVol = Math.Sqrt(vol * vol + 2 * vol * t * (divT));
localVolSensi = volSensi.multipliedBy((vol + t * divT) / localVol).plus(divTSensi.multipliedBy(vol * t / localVol));
}
else
{
double divK = FIRST_DERIV.differentiate(l => impliedVolatilitySurface.zValue(t, l)).apply(k);
DoubleArray divKSensi = FIRST_DERIV_SENSI.differentiate(l => impliedVolatilitySurface.zValueParameterSensitivity(t, l.get(0)).Sensitivity).apply(DoubleArray.of(k)).column(0);
double divK2 = SECOND_DERIV.differentiate(l => impliedVolatilitySurface.zValue(t, l)).apply(k);
DoubleArray divK2Sensi = SECOND_DERIV_SENSI.differentiateNoCross(l => impliedVolatilitySurface.zValueParameterSensitivity(t, l.get(0)).Sensitivity).apply(DoubleArray.of(k)).column(0);
double rq = r - q;
double h1 = (Math.Log(spot / k) + (rq + 0.5 * vol * vol) * t) / vol;
double h2 = h1 - vol * t;
double den = 1d + 2d * h1 * k * divK + k * k * (h1 * h2 * divK * divK + t * vol * divK2);
double var = (vol * vol + 2d * vol * t * (divT + k * rq * divK)) / den;
if (var < 0d)
{
throw new System.ArgumentException("Negative variance");
}
localVol = Math.Sqrt(var);
localVolSensi = volSensi.multipliedBy(localVol * k * h2 * divK * (1d + 0.5 * k * h2 * divK) / vol / den + 0.5 * localVol * Math.Pow(k * h1 * divK, 2) / vol / den + (vol + divT * t + rq * t * k * divK) / (localVol * den) - 0.5 * divK2 * localVol * k * k * t / den).plus(divKSensi.multipliedBy((vol * t * rq * k / localVol - localVol * k * h1 * (1d + k * h2 * divK)) / den)).plus(divTSensi.multipliedBy(vol * t / (localVol * den))).plus(divK2Sensi.multipliedBy(-0.5 * vol * localVol * k * k * t / den));
}
return(ValueDerivatives.of(localVol, localVolSensi));
};
SurfaceMetadata metadata = DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.STRIKE).zValueType(ValueType.LOCAL_VOLATILITY).surfaceName(SurfaceName.of("localVol_" + impliedVolatilitySurface.Name)).build();
return(DeformedSurface.of(metadata, impliedVolatilitySurface, func));
}
//-------------------------------------------------------------------------
/// <summary>
/// Runs the calibration of swaptions and print the calibrated smile results on the console.
/// </summary>
/// <param name="args"> -s to use the sparse data, i.e. a cube with missing data points </param>
public static void Main(string[] args)
{
// select data
TenorRawOptionData data = DATA_FULL;
if (args.Length > 0)
{
if (args[0].Equals("-s"))
{
data = DATA_SPARSE;
}
}
Console.WriteLine("Start calibration");
double beta = 0.50;
SurfaceMetadata betaMetadata = DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).zValueType(ValueType.SABR_BETA).surfaceName("Beta").build();
Surface betaSurface = ConstantSurface.of(betaMetadata, beta);
double shift = 0.0300;
Surface shiftSurface = ConstantSurface.of("Shift", shift);
SabrParametersSwaptionVolatilities calibrated = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, data, MULTICURVE, betaSurface, shiftSurface);
Console.WriteLine("End calibration");
/* Graph calibration */
int nbStrikesGraph = 50;
double moneyMin = -0.0250;
double moneyMax = +0.0300;
double[] moneyGraph = new double[nbStrikesGraph + 1];
for (int i = 0; i < nbStrikesGraph + 1; i++)
{
moneyGraph[i] = moneyMin + i * (moneyMax - moneyMin) / nbStrikesGraph;
}
//JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java:
//ORIGINAL LINE: double[][][] strikesGraph = new double[NB_TENORS][NB_EXPIRIES][nbStrikesGraph + 1];
double[][][] strikesGraph = RectangularArrays.ReturnRectangularDoubleArray(NB_TENORS, NB_EXPIRIES, nbStrikesGraph + 1);
//JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java:
//ORIGINAL LINE: double[][][] volLNGraph = new double[NB_TENORS][NB_EXPIRIES][nbStrikesGraph + 1];
double[][][] volLNGraph = RectangularArrays.ReturnRectangularDoubleArray(NB_TENORS, NB_EXPIRIES, nbStrikesGraph + 1);
//JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java:
//ORIGINAL LINE: double[][][] volNGraph = new double[NB_TENORS][NB_EXPIRIES][nbStrikesGraph + 1];
double[][][] volNGraph = RectangularArrays.ReturnRectangularDoubleArray(NB_TENORS, NB_EXPIRIES, nbStrikesGraph + 1);
//JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java:
//ORIGINAL LINE: double[][] parRate = new double[NB_TENORS][NB_EXPIRIES];
double[][] parRate = RectangularArrays.ReturnRectangularDoubleArray(NB_TENORS, NB_EXPIRIES);
for (int looptenor = 0; looptenor < TENORS.size(); looptenor++)
{
double tenor = TENORS.get(looptenor).get(ChronoUnit.YEARS);
for (int loopexpiry = 0; loopexpiry < EXPIRIES.size(); loopexpiry++)
{
LocalDate expiry = EUR_FIXED_1Y_EURIBOR_6M.FloatingLeg.StartDateBusinessDayAdjustment.adjust(CALIBRATION_DATE.plus(EXPIRIES.get(loopexpiry)), REF_DATA);
LocalDate effectiveDate = EUR_FIXED_1Y_EURIBOR_6M.calculateSpotDateFromTradeDate(expiry, REF_DATA);
LocalDate endDate = effectiveDate.plus(TENORS.get(looptenor));
SwapTrade swap = EUR_FIXED_1Y_EURIBOR_6M.toTrade(CALIBRATION_DATE, effectiveDate, endDate, BuySell.BUY, 1.0, 0.0);
parRate[looptenor][loopexpiry] = SWAP_PRICER.parRate(swap.resolve(REF_DATA).Product, MULTICURVE);
ZonedDateTime expiryDateTime = expiry.atTime(11, 0).atZone(ZoneId.of("Europe/Berlin"));
double time = calibrated.relativeTime(expiryDateTime);
for (int i = 0; i < nbStrikesGraph + 1; i++)
{
strikesGraph[looptenor][loopexpiry][i] = parRate[looptenor][loopexpiry] + moneyGraph[i];
volLNGraph[looptenor][loopexpiry][i] = calibrated.volatility(expiryDateTime, tenor, strikesGraph[looptenor][loopexpiry][i], parRate[looptenor][loopexpiry]);
volNGraph[looptenor][loopexpiry][i] = NormalFormulaRepository.impliedVolatilityFromBlackApproximated(parRate[looptenor][loopexpiry] + shift, strikesGraph[looptenor][loopexpiry][i] + shift, time, volLNGraph[looptenor][loopexpiry][i]);
}
}
}
/* Graph export */
string svn = "Moneyness";
for (int looptenor = 0; looptenor < TENORS.size(); looptenor++)
{
for (int loopexpiry = 0; loopexpiry < EXPIRIES.size(); loopexpiry++)
{
svn = svn + ", Strike_" + EXPIRIES.get(loopexpiry).ToString() + "x" + TENORS.get(looptenor).ToString() + ", NormalVol_" + EXPIRIES.get(loopexpiry).ToString() + "x" + TENORS.get(looptenor).ToString();
}
}
svn = svn + "\n";
for (int i = 0; i < nbStrikesGraph + 1; i++)
{
svn = svn + moneyGraph[i];
for (int looptenor = 0; looptenor < TENORS.size(); looptenor++)
{
for (int loopexpiry = 0; loopexpiry < EXPIRIES.size(); loopexpiry++)
{
svn = svn + ", " + strikesGraph[looptenor][loopexpiry][i];
svn = svn + ", " + volNGraph[looptenor][loopexpiry][i];
}
}
svn = svn + "\n";
}
Console.WriteLine(svn);
}
/// <summary>
/// Check that the sensitivities of parameters with respect to data is stored in the metadata.
/// Compare the sensitivities to a finite difference approximation.
/// This test is relatively slow as it calibrates the full surface multiple times.
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void log_normal_cube_sensitivity()
public virtual void log_normal_cube_sensitivity()
{
double beta = 1.0;
Surface betaSurface = ConstantSurface.of("Beta", beta).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).zValueType(ValueType.SABR_BETA).surfaceName("Beta").build());
double shift = 0.0000;
Surface shiftSurface = ConstantSurface.of("Shift", shift).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).surfaceName("Shift").build());
SabrParametersSwaptionVolatilities calibrated = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, DATA_SPARSE, MULTICURVE, betaSurface, shiftSurface);
double fdShift = 1.0E-5;
SurfaceMetadata alphaMetadata = calibrated.Parameters.AlphaSurface.Metadata;
Optional <IList <ParameterMetadata> > alphaParameterMetadataOption = alphaMetadata.ParameterMetadata;
assertTrue(alphaParameterMetadataOption.Present);
IList <ParameterMetadata> alphaParameterMetadata = alphaParameterMetadataOption.get();
IList <DoubleArray> alphaJacobian = calibrated.DataSensitivityAlpha.get();
SurfaceMetadata rhoMetadata = calibrated.Parameters.RhoSurface.Metadata;
Optional <IList <ParameterMetadata> > rhoParameterMetadataOption = rhoMetadata.ParameterMetadata;
assertTrue(rhoParameterMetadataOption.Present);
IList <ParameterMetadata> rhoParameterMetadata = rhoParameterMetadataOption.get();
IList <DoubleArray> rhoJacobian = calibrated.DataSensitivityRho.get();
SurfaceMetadata nuMetadata = calibrated.Parameters.NuSurface.Metadata;
Optional <IList <ParameterMetadata> > nuParameterMetadataOption = nuMetadata.ParameterMetadata;
assertTrue(nuParameterMetadataOption.Present);
IList <ParameterMetadata> nuParameterMetadata = nuParameterMetadataOption.get();
IList <DoubleArray> nuJacobian = calibrated.DataSensitivityNu.get();
int surfacePointIndex = 0;
for (int loopexpiry = 0; loopexpiry < EXPIRIES.Count; loopexpiry++)
{
for (int looptenor = 0; looptenor < TENORS.Count; looptenor++)
{
Tenor tenor = TENORS[looptenor];
double tenorYears = tenor.get(ChronoUnit.YEARS);
LocalDate expiry = EUR_FIXED_1Y_EURIBOR_6M.FloatingLeg.StartDateBusinessDayAdjustment.adjust(CALIBRATION_DATE.plus(EXPIRIES[loopexpiry]), REF_DATA);
ZonedDateTime expiryDateTime = expiry.atTime(11, 0).atZone(ZoneId.of("Europe/Berlin"));
double time = calibrated.relativeTime(expiryDateTime);
Pair <DoubleArray, DoubleArray> ds = DATA_SPARSE.getData(tenor).availableSmileAtExpiry(EXPIRIES[loopexpiry]);
if (!ds.First.Empty)
{
int availableDataIndex = 0;
ParameterMetadata alphaPM = alphaParameterMetadata[surfacePointIndex];
assertTrue(alphaPM is SwaptionSurfaceExpiryTenorParameterMetadata);
SwaptionSurfaceExpiryTenorParameterMetadata pmAlphaSabr = (SwaptionSurfaceExpiryTenorParameterMetadata)alphaPM;
assertEquals(tenorYears, pmAlphaSabr.Tenor);
assertEquals(time, pmAlphaSabr.YearFraction, TOLERANCE_EXPIRY);
DoubleArray alphaSensitivityToData = alphaJacobian[surfacePointIndex];
ParameterMetadata rhoPM = rhoParameterMetadata[surfacePointIndex];
assertTrue(rhoPM is SwaptionSurfaceExpiryTenorParameterMetadata);
SwaptionSurfaceExpiryTenorParameterMetadata pmRhoSabr = (SwaptionSurfaceExpiryTenorParameterMetadata)rhoPM;
assertEquals(tenorYears, pmRhoSabr.Tenor);
assertEquals(time, pmRhoSabr.YearFraction, TOLERANCE_EXPIRY);
DoubleArray rhoSensitivityToData = rhoJacobian[surfacePointIndex];
ParameterMetadata nuPM = nuParameterMetadata[surfacePointIndex];
assertTrue(nuPM is SwaptionSurfaceExpiryTenorParameterMetadata);
SwaptionSurfaceExpiryTenorParameterMetadata pmNuSabr = (SwaptionSurfaceExpiryTenorParameterMetadata)nuPM;
assertEquals(tenorYears, pmNuSabr.Tenor);
assertEquals(time, pmNuSabr.YearFraction, TOLERANCE_EXPIRY);
DoubleArray nuSensitivityToData = nuJacobian[surfacePointIndex];
for (int loopmoney = 0; loopmoney < MONEYNESS.size(); loopmoney++)
{
if (!double.IsNaN(DATA_LOGNORMAL[looptenor][loopexpiry][loopmoney]))
{
double[] alphaShifted = new double[2];
double[] rhoShifted = new double[2];
double[] nuShifted = new double[2];
for (int loopsign = 0; loopsign < 2; loopsign++)
{
TenorRawOptionData dataShifted = SabrSwaptionCalibratorSmileTestUtils.rawDataShiftPoint(TENORS, EXPIRIES, ValueType.SIMPLE_MONEYNESS, MONEYNESS, ValueType.BLACK_VOLATILITY, DATA_LOGNORMAL, looptenor, loopexpiry, loopmoney, (2 * loopsign - 1) * fdShift);
SabrParametersSwaptionVolatilities calibratedShifted = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, dataShifted, MULTICURVE, betaSurface, shiftSurface);
alphaShifted[loopsign] = calibratedShifted.Parameters.AlphaSurface.zValue(time, tenorYears);
rhoShifted[loopsign] = calibratedShifted.Parameters.RhoSurface.zValue(time, tenorYears);
nuShifted[loopsign] = calibratedShifted.Parameters.NuSurface.zValue(time, tenorYears);
}
double alphaSensitivityComputed = alphaSensitivityToData.get(availableDataIndex);
double alphaSensitivityExpected = (alphaShifted[1] - alphaShifted[0]) / (2 * fdShift);
checkAcceptable(alphaSensitivityComputed, alphaSensitivityExpected, TOLERANCE_PARAM_SENSITIVITY, "Alpha: " + looptenor + " / " + loopexpiry + " / " + loopmoney);
double rhoSensitivityComputed = rhoSensitivityToData.get(availableDataIndex);
double rhoSensitivityExpected = (rhoShifted[1] - rhoShifted[0]) / (2 * fdShift);
checkAcceptable(rhoSensitivityComputed, rhoSensitivityExpected, TOLERANCE_PARAM_SENSITIVITY, "Rho: " + looptenor + " / " + loopexpiry + " / " + loopmoney);
double nuSensitivityComputed = nuSensitivityToData.get(availableDataIndex);
double nuSensitivityExpected = (nuShifted[1] - nuShifted[0]) / (2 * fdShift);
checkAcceptable(nuSensitivityComputed, nuSensitivityExpected, TOLERANCE_PARAM_SENSITIVITY, "Nu: " + looptenor + " / " + loopexpiry + " / " + loopmoney);
availableDataIndex++;
}
}
surfacePointIndex++;
}
}
}
}
//-------------------------------------------------------------------------
/// <summary>
/// Runs the calibration of SABR on swaptions and print on the console the present value, bucketed PV01 and
/// the bucketed Vega of a 18M x 4Y swaption.
/// </summary>
/// <param name="args"> -s to use the spares data </param>
public static void Main(string[] args)
{
long start, end;
// Swaption description
BuySell payer = BuySell.BUY;
Period expiry = Period.ofMonths(18);
double notional = 1_000_000;
double strike = 0.0100;
Tenor tenor = Tenor.TENOR_4Y;
LocalDate expiryDate = EUR_FIXED_1Y_EURIBOR_6M.FloatingLeg.StartDateBusinessDayAdjustment.adjust(CALIBRATION_DATE.plus(expiry), REF_DATA);
SwapTrade underlying = EUR_FIXED_1Y_EURIBOR_6M.createTrade(expiryDate, tenor, payer, notional, strike, REF_DATA);
Swaption swaption = Swaption.builder().expiryDate(AdjustableDate.of(expiryDate)).expiryTime(LocalTime.of(11, 0x0)).expiryZone(ZoneId.of("Europe/Berlin")).underlying(underlying.Product).longShort(LongShort.LONG).swaptionSettlement(PhysicalSwaptionSettlement.DEFAULT).build();
ResolvedSwaption resolvedSwaption = swaption.resolve(REF_DATA);
// select data
TenorRawOptionData data = DATA_FULL;
if (args.Length > 0)
{
if (args[0].Equals("-s"))
{
data = DATA_SPARSE;
}
}
start = DateTimeHelper.CurrentUnixTimeMillis();
// Curve calibration
RatesProvider multicurve = CALIBRATOR.calibrate(CONFIGS, MARKET_QUOTES, REF_DATA);
end = DateTimeHelper.CurrentUnixTimeMillis();
Console.WriteLine("Curve calibration time: " + (end - start) + " ms.");
// SABR calibration
start = DateTimeHelper.CurrentUnixTimeMillis();
double beta = 0.50;
SurfaceMetadata betaMetadata = DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).zValueType(ValueType.SABR_BETA).surfaceName("Beta").build();
Surface betaSurface = ConstantSurface.of(betaMetadata, beta);
double shift = 0.0300;
Surface shiftSurface = ConstantSurface.of("SABR-Shift", shift);
SabrParametersSwaptionVolatilities sabr = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, data, multicurve, betaSurface, shiftSurface);
end = DateTimeHelper.CurrentUnixTimeMillis();
Console.WriteLine("SABR calibration time: " + (end - start) + " ms.");
// Price and risk
Console.WriteLine("Risk measures: ");
start = DateTimeHelper.CurrentUnixTimeMillis();
CurrencyAmount pv = SWAPTION_PRICER.presentValue(resolvedSwaption, multicurve, sabr);
Console.WriteLine(" |-> PV: " + pv.ToString());
PointSensitivities deltaPts = SWAPTION_PRICER.presentValueSensitivityRatesStickyModel(resolvedSwaption, multicurve, sabr).build();
CurrencyParameterSensitivities deltaBucketed = multicurve.parameterSensitivity(deltaPts);
Console.WriteLine(" |-> Delta bucketed: " + deltaBucketed.ToString());
PointSensitivities vegaPts = SWAPTION_PRICER.presentValueSensitivityModelParamsSabr(resolvedSwaption, multicurve, sabr).build();
Console.WriteLine(" |-> Vega point: " + vegaPts.ToString());
CurrencyParameterSensitivities vegaBucketed = sabr.parameterSensitivity(vegaPts);
for (int i = 0; i < vegaBucketed.size(); i++)
{
Console.WriteLine(" |-> Vega bucketed: " + vegaBucketed.Sensitivities.get(i));
}
end = DateTimeHelper.CurrentUnixTimeMillis();
Console.WriteLine("PV and risk time: " + (end - start) + " ms.");
}
