//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void test()
public virtual void test()
{
/// <summary>
/// Take the form $y = a\sin(bx + cy) + cos(y)$
/// </summary>
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ParameterizedSurface testSurface = new ParameterizedSurface()
ParameterizedSurface testSurface = new ParameterizedSurfaceAnonymousInnerClass(this);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ParameterizedFunction<com.opengamma.strata.collect.tuple.DoublesPair, com.opengamma.strata.collect.array.DoubleArray, com.opengamma.strata.collect.array.DoubleArray> parmSense = new ParameterizedFunction<com.opengamma.strata.collect.tuple.DoublesPair, com.opengamma.strata.collect.array.DoubleArray, com.opengamma.strata.collect.array.DoubleArray>()
ParameterizedFunction <DoublesPair, DoubleArray, DoubleArray> parmSense = new ParameterizedFunctionAnonymousInnerClass(this);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray params = com.opengamma.strata.collect.array.DoubleArray.of(0.7, -0.3, 1.2);
DoubleArray @params = DoubleArray.of(0.7, -0.3, 1.2);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.function.Function<com.opengamma.strata.collect.tuple.DoublesPair, com.opengamma.strata.collect.array.DoubleArray> paramsSenseFD = testSurface.getZParameterSensitivity(params);
System.Func <DoublesPair, DoubleArray> paramsSenseFD = testSurface.getZParameterSensitivity(@params);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.function.Function<com.opengamma.strata.collect.tuple.DoublesPair, com.opengamma.strata.collect.array.DoubleArray> paramsSenseAnal = parmSense.asFunctionOfArguments(params);
System.Func <DoublesPair, DoubleArray> paramsSenseAnal = parmSense.asFunctionOfArguments(@params);
for (int i = 0; i < 20; i++)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double x = Math.PI * (-0.5 + i / 19.0);
double x = Math.PI * (-0.5 + i / 19.0);
for (int j = 0; j < 20; j++)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double y = Math.PI * (-0.5 + j / 19.0);
double y = Math.PI * (-0.5 + j / 19.0);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final com.opengamma.strata.collect.tuple.DoublesPair xy = com.opengamma.strata.collect.tuple.DoublesPair.of(x, y);
DoublesPair xy = DoublesPair.of(x, y);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray s1 = paramsSenseAnal.apply(xy);
DoubleArray s1 = paramsSenseAnal(xy);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray s2 = paramsSenseFD.apply(xy);
DoubleArray s2 = paramsSenseFD(xy);
for (int k = 0; k < 3; k++)
{
assertEquals(s1.get(k), s2.get(k), 1e-10);
}
}
}
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: @Override public System.Nullable<double> evaluate(final com.opengamma.strata.collect.tuple.DoublesPair xy, final com.opengamma.strata.collect.array.DoubleArray parameters)
public override double?evaluate(DoublesPair xy, DoubleArray parameters)
{
assertEquals(3, parameters.size());
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double a = parameters.get(0);
double a = parameters.get(0);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double b = parameters.get(1);
double b = parameters.get(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double c = parameters.get(2);
double c = parameters.get(2);
return(a * Math.Sin(b * xy.First + c * xy.Second) + Math.Cos(xy.Second));
}
// constructor that sorts (artificial boolean flag)
private InterpolatedNodalSurface(SurfaceMetadata metadata, DoubleArray xValues, DoubleArray yValues, DoubleArray zValues, SurfaceInterpolator interpolator, bool sort)
{
validateInputs(metadata, xValues, yValues, zValues, interpolator);
// sort inputs
IDictionary <DoublesPair, ObjDoublePair <ParameterMetadata> > sorted = new SortedDictionary <DoublesPair, ObjDoublePair <ParameterMetadata> >();
for (int i = 0; i < xValues.size(); i++)
{
ParameterMetadata pm = metadata.getParameterMetadata(i);
sorted[DoublesPair.of(xValues.get(i), yValues.get(i))] = ObjDoublePair.of(pm, zValues.get(i));
}
double[] sortedX = new double[sorted.Count];
double[] sortedY = new double[sorted.Count];
double[] sortedZ = new double[sorted.Count];
ParameterMetadata[] sortedPm = new ParameterMetadata[sorted.Count];
int pos = 0;
foreach (KeyValuePair <DoublesPair, ObjDoublePair <ParameterMetadata> > entry in sorted.SetOfKeyValuePairs())
{
sortedX[pos] = entry.Key.First;
sortedY[pos] = entry.Key.Second;
sortedZ[pos] = entry.Value.Second;
sortedPm[pos] = entry.Value.First;
pos++;
}
// assign
SurfaceMetadata sortedMetadata = metadata.withParameterMetadata(Arrays.asList(sortedPm));
this.metadata = sortedMetadata;
this.xValues = DoubleArray.ofUnsafe(sortedX);
this.yValues = DoubleArray.ofUnsafe(sortedY);
this.zValues = DoubleArray.ofUnsafe(sortedZ);
IDictionary <DoublesPair, double> pairs = new Dictionary <DoublesPair, double>();
for (int i = 0; i < xValues.size(); i++)
{
pairs[DoublesPair.of(xValues.get(i), yValues.get(i))] = zValues.get(i);
}
this.interpolator = interpolator;
this.boundInterpolator = interpolator.bind(this.xValues, this.yValues, this.zValues);
this.parameterMetadata = IntStream.range(0, ParameterCount).mapToObj(i => sortedMetadata.getParameterMetadata(i)).collect(toImmutableList());
}
public virtual void test_volatility_sensitivity()
{
double eps = 1.0e-6;
int nData = TIME.size();
for (int i = 0; i < NB_TEST; i++)
{
double expiryTime = VOLS.relativeTime(TEST_OPTION_EXPIRY[i]);
SwaptionSensitivity point = SwaptionSensitivity.of(VOLS.Name, expiryTime, TEST_TENOR, TEST_STRIKE[i], TEST_FORWARD, GBP, TEST_SENSITIVITY[i]);
CurrencyParameterSensitivities sensActual = VOLS.parameterSensitivity(point);
CurrencyParameterSensitivity sensi = sensActual.getSensitivity(SURFACE.Name, GBP);
DoubleArray computed = sensi.Sensitivity;
IDictionary <DoublesPair, double> map = new Dictionary <DoublesPair, double>();
for (int j = 0; j < nData; ++j)
{
DoubleArray volDataUp = VOL.subArray(0, nData).with(j, VOL.get(j) + eps);
DoubleArray volDataDw = VOL.subArray(0, nData).with(j, VOL.get(j) - eps);
InterpolatedNodalSurface paramUp = InterpolatedNodalSurface.of(METADATA, TIME, STRIKE, volDataUp, INTERPOLATOR_2D);
InterpolatedNodalSurface paramDw = InterpolatedNodalSurface.of(METADATA, TIME, STRIKE, volDataDw, INTERPOLATOR_2D);
NormalSwaptionExpiryStrikeVolatilities provUp = NormalSwaptionExpiryStrikeVolatilities.of(CONVENTION, VAL_DATE_TIME, paramUp);
NormalSwaptionExpiryStrikeVolatilities provDw = NormalSwaptionExpiryStrikeVolatilities.of(CONVENTION, VAL_DATE_TIME, paramDw);
double volUp = provUp.volatility(TEST_OPTION_EXPIRY[i], TEST_TENOR, TEST_STRIKE[i], TEST_FORWARD);
double volDw = provDw.volatility(TEST_OPTION_EXPIRY[i], TEST_TENOR, TEST_STRIKE[i], TEST_FORWARD);
double fd = 0.5 * (volUp - volDw) / eps;
map[DoublesPair.of(TIME.get(j), STRIKE.get(j))] = fd;
}
IList <ParameterMetadata> list = sensi.ParameterMetadata;
assertEquals(computed.size(), nData);
for (int j = 0; j < list.Count; ++j)
{
SwaptionSurfaceExpiryStrikeParameterMetadata metadata = (SwaptionSurfaceExpiryStrikeParameterMetadata)list[i];
double expected = map[DoublesPair.of(metadata.YearFraction, metadata.Strike)];
assertEquals(computed.get(i), expected, eps);
}
}
}
//-------------------------------------------------------------------------
public double zValue(double x, double y)
{
return(deformationFunction.apply(DoublesPair.of(x, y)).Value);
}
public UnitParameterSensitivity zValueParameterSensitivity(double x, double y)
{
return(Metadata.ParameterMetadata.Present ? UnitParameterSensitivity.of(Metadata.SurfaceName, Metadata.ParameterMetadata.get(), deformationFunction.apply(DoublesPair.of(x, y)).Derivatives) : UnitParameterSensitivity.of(Metadata.SurfaceName, deformationFunction.apply(DoublesPair.of(x, y)).Derivatives));
}
public virtual void regressionPvSurfaceSensi()
{
PointSensitivities pointComputed = SWAPTION_PRICER.presentValueSensitivityModelParamsSabr(SWAPTION_PAY_LONG, RATE_PROVIDER, VOLS_REGRESSION).build();
assertSensitivity(pointComputed, SabrParameterType.ALPHA, 6.5786313367554754E7, REGRESSION_TOL);
assertSensitivity(pointComputed, SabrParameterType.BETA, -1.2044275797229866E7, REGRESSION_TOL);
assertSensitivity(pointComputed, SabrParameterType.RHO, 266223.51118849067, REGRESSION_TOL);
assertSensitivity(pointComputed, SabrParameterType.NU, 400285.5505271345, REGRESSION_TOL);
CurrencyParameterSensitivities sensiComputed = VOLS_REGRESSION.parameterSensitivity(pointComputed);
double[][] alphaExp = new double[][]
{
new double[] { 0.0, 1.0, 0.0 },
new double[] { 0.5, 1.0, 0.0 },
new double[] { 1.0, 1.0, 0.0 },
new double[] { 2.0, 1.0, 0.0 },
new double[] { 5.0, 1.0, 0.0 },
new double[] { 10.0, 1.0, 0.0 },
new double[] { 0.0, 5.0, 0.0 },
new double[] { 0.5, 5.0, 0.0 },
new double[] { 1.0, 5.0, 6204.475194599179 },
new double[] { 2.0, 5.0, 3.94631212984123E7 },
new double[] { 5.0, 5.0, 0.0 },
new double[] { 10.0, 5.0, 0.0 },
new double[] { 0.0, 10.0, 0.0 },
new double[] { 0.5, 10.0, 0.0 },
new double[] { 1.0, 10.0, 4136.961894403858 },
new double[] { 2.0, 10.0, 2.631285063205345E7 },
new double[] { 5.0, 10.0, 0.0 },
new double[] { 10.0, 10.0, 0.0 }
};
double[][] betaExp = new double[][]
{
new double[] { 0.0, 1.0, -0.0 },
new double[] { 0.5, 1.0, -0.0 },
new double[] { 1.0, 1.0, -0.0 },
new double[] { 2.0, 1.0, -0.0 },
new double[] { 5.0, 1.0, -0.0 },
new double[] { 10.0, 1.0, -0.0 },
new double[] { 0.0, 5.0, -0.0 },
new double[] { 0.5, 5.0, -0.0 },
new double[] { 1.0, 5.0, -1135.926404680998 },
new double[] { 2.0, 5.0, -7224978.759366533 },
new double[] { 5.0, 5.0, -0.0 },
new double[] { 10.0, 5.0, -0.0 },
new double[] { 0.0, 10.0, -0.0 },
new double[] { 0.5, 10.0, -0.0 },
new double[] { 1.0, 10.0, -757.402375482629 },
new double[] { 2.0, 10.0, -4817403.70908317 },
new double[] { 5.0, 10.0, -0.0 },
new double[] { 10.0, 10.0, -0.0 }
};
double[][] rhoExp = new double[][]
{
new double[] { 0.0, 1.0, 0.0 },
new double[] { 0.5, 1.0, 0.0 },
new double[] { 1.0, 1.0, 0.0 },
new double[] { 2.0, 1.0, 0.0 },
new double[] { 5.0, 1.0, 0.0 },
new double[] { 10.0, 1.0, 0.0 },
new double[] { 0.0, 5.0, 0.0 },
new double[] { 0.5, 5.0, 0.0 },
new double[] { 1.0, 5.0, 25.10821912392996 },
new double[] { 2.0, 5.0, 159699.03429338703 },
new double[] { 5.0, 5.0, 0.0 },
new double[] { 10.0, 5.0, 0.0 },
new double[] { 0.0, 10.0, 0.0 },
new double[] { 0.5, 10.0, 0.0 },
new double[] { 1.0, 10.0, 16.741423326578513 },
new double[] { 2.0, 10.0, 106482.62725265314 },
new double[] { 5.0, 10.0, 0.0 },
new double[] { 10.0, 10.0, 0.0 }
};
double[][] nuExp = new double[][]
{
new double[] { 0.0, 1.0, 0.0 },
new double[] { 0.5, 1.0, 0.0 },
new double[] { 1.0, 1.0, 0.0 },
new double[] { 2.0, 1.0, 0.0 },
new double[] { 5.0, 1.0, 0.0 },
new double[] { 10.0, 1.0, 0.0 },
new double[] { 0.0, 5.0, 0.0 },
new double[] { 0.5, 5.0, 0.0 },
new double[] { 1.0, 5.0, 37.751952372314484 },
new double[] { 2.0, 5.0, 240118.59649585965 },
new double[] { 5.0, 5.0, 0.0 },
new double[] { 10.0, 5.0, 0.0 },
new double[] { 0.0, 10.0, 0.0 },
new double[] { 0.5, 10.0, 0.0 },
new double[] { 1.0, 10.0, 25.171893432592533 },
new double[] { 2.0, 10.0, 160104.03018547 },
new double[] { 5.0, 10.0, 0.0 },
new double[] { 10.0, 10.0, 0.0 }
};
double[][][] exps = new double[][][] { alphaExp, betaExp, rhoExp, nuExp };
SurfaceMetadata[] metadata = new SurfaceMetadata[] { SwaptionSabrRateVolatilityDataSet.META_ALPHA, SwaptionSabrRateVolatilityDataSet.META_BETA_USD, SwaptionSabrRateVolatilityDataSet.META_RHO, SwaptionSabrRateVolatilityDataSet.META_NU };
// x-y-value order does not match sorted order in surface, thus sort it
CurrencyParameterSensitivities sensiExpected = CurrencyParameterSensitivities.empty();
for (int i = 0; i < exps.Length; ++i)
{
int size = exps[i].Length;
IDictionary <DoublesPair, double> sensiMap = new SortedDictionary <DoublesPair, double>();
for (int j = 0; j < size; ++j)
{
sensiMap[DoublesPair.of(exps[i][j][0], exps[i][j][1])] = exps[i][j][2];
}
IList <ParameterMetadata> paramMetadata = new List <ParameterMetadata>(size);
IList <double> sensi = new List <double>();
foreach (KeyValuePair <DoublesPair, double> entry in sensiMap.SetOfKeyValuePairs())
{
paramMetadata.Add(SwaptionSurfaceExpiryTenorParameterMetadata.of(entry.Key.First, entry.Key.Second));
sensi.Add(entry.Value);
}
SurfaceMetadata surfaceMetadata = metadata[i].withParameterMetadata(paramMetadata);
sensiExpected = sensiExpected.combinedWith(CurrencyParameterSensitivity.of(surfaceMetadata.SurfaceName, surfaceMetadata.ParameterMetadata.get(), USD, DoubleArray.copyOf(sensi)));
}
testSurfaceParameterSensitivities(sensiComputed, sensiExpected, REGRESSION_TOL * NOTIONAL);
}
//-----------------------------------------------------------------------
private Pair <ImmutableList <double[]>, RecombiningTrinomialTreeData> calibrate(System.Func <DoublesPair, double> impliedVolatilitySurface, double spot, System.Func <double, double> interestRate, System.Func <double, double> dividendRate)
{
double[][] stateValue = new double[nSteps + 1][];
double[] df = new double[nSteps];
double[] timePrim = new double[nSteps + 1];
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
double volatility = impliedVolatilitySurface(DoublesPair.of(maxTime, spot));
double dt = maxTime / nSteps;
double dx = volatility * 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)
{
timePrim[i] = dt * i;
if (i == 0)
{
resolveFirstLayer(interestRate, dividendRate, nTotal, dt, spot, adSec, assetPrice, timeRes, spotRes, volRes, df, stateValue, probability);
}
else
{
double zeroRate = interestRate(timePrim[i]);
double zeroDividendRate = dividendRate(timePrim[i]);
double zeroCostRate = zeroRate - zeroDividendRate;
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;
double impliedVol = impliedVolatilitySurface(DoublesPair.of(timePrim[i], assetPriceLocal[j]));
callOptionPrice[j] = BlackScholesFormulaRepository.price(spot, assetPriceLocal[j], timePrim[i], impliedVol, zeroRate, zeroCostRate, true);
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;
double impliedVol = impliedVolatilitySurface(DoublesPair.of(timePrim[i], assetPriceLocal[j]));
putOptionPrice[j] = BlackScholesFormulaRepository.price(spot, assetPriceLocal[j], timePrim[i], impliedVol, zeroRate, zeroCostRate, false);
assetTmp *= upFactor;
}
resolveLayer(interestRate, dividendRate, i, nTotal, position, dt, zeroRate, zeroDividendRate, callOptionPrice, putOptionPrice, adSec, assetPrice, assetPriceLocal, timeRes, spotRes, volRes, df, stateValue, probability);
}
}
ImmutableList <double[]> localVolData = ImmutableList.of(timeRes, spotRes, volRes);
RecombiningTrinomialTreeData treeData = RecombiningTrinomialTreeData.of(DoubleMatrix.ofUnsafe(stateValue), probability, DoubleArray.ofUnsafe(df), DoubleArray.ofUnsafe(timePrim));
return(Pair.of(localVolData, treeData));
}
