private CrossGammaParameterSensitivity computeGammaForCurve(CurveName curveName, Curve curve, Currency sensitivityCurrency, System.Func <Curve, ImmutableLegalEntityDiscountingProvider> ratesProviderFn, System.Func <ImmutableLegalEntityDiscountingProvider, CurrencyParameterSensitivities> sensitivitiesFn)
{
System.Func <DoubleArray, DoubleArray> function = (DoubleArray t) =>
{
Curve newCurve = curve.withPerturbation((i, v, m) => t.get(i));
ImmutableLegalEntityDiscountingProvider newRates = ratesProviderFn(newCurve);
CurrencyParameterSensitivities sensiMulti = sensitivitiesFn(newRates);
return(sensiMulti.getSensitivity(curveName, sensitivityCurrency).Sensitivity);
};
int nParams = curve.ParameterCount;
DoubleMatrix sensi = fd.differentiate(function).apply(DoubleArray.of(nParams, n => curve.getParameter(n)));
IList <ParameterMetadata> metadata = IntStream.range(0, nParams).mapToObj(i => curve.getParameterMetadata(i)).collect(toImmutableList());
return(CrossGammaParameterSensitivity.of(curveName, metadata, sensitivityCurrency, sensi));
}
//-------------------------------------------------------------------------
public virtual void test_of()
{
ZeroRateDiscountFactors test = ZeroRateDiscountFactors.of(GBP, DATE_VAL, CURVE);
assertEquals(test.Currency, GBP);
assertEquals(test.ValuationDate, DATE_VAL);
assertEquals(test.Curve, CURVE);
assertEquals(test.ParameterCount, CURVE.ParameterCount);
assertEquals(test.getParameter(0), CURVE.getParameter(0));
assertEquals(test.getParameterMetadata(0), CURVE.getParameterMetadata(0));
assertEquals(test.withParameter(0, 1d).Curve, CURVE.withParameter(0, 1d));
assertEquals(test.withPerturbation((i, v, m) => v + 1d).Curve, CURVE.withPerturbation((i, v, m) => v + 1d));
assertEquals(test.findData(CURVE.Name), CURVE);
assertEquals(test.findData(CurveName.of("Rubbish")), null);
}
//-------------------------------------------------------------------------
private static void parseCurveMaps(CharSource groupsCharSource, IDictionary <CurveGroupName, IDictionary <Pair <RepoGroup, Currency>, CurveName> > repoGroups, IDictionary <CurveGroupName, IDictionary <Pair <LegalEntityGroup, Currency>, CurveName> > legalEntityGroups)
{
CsvFile csv = CsvFile.of(groupsCharSource, true);
foreach (CsvRow row in csv.rows())
{
string curveGroupStr = row.getField(GROUPS_NAME);
string curveTypeStr = row.getField(GROUPS_CURVE_TYPE);
string referenceStr = row.getField(GROUPS_REFERENCE);
string currencyStr = row.getField(GROUPS_CURRENCY);
string curveNameStr = row.getField(GROUPS_CURVE_NAME);
CurveName curveName = CurveName.of(curveNameStr);
createKey(curveName, CurveGroupName.of(curveGroupStr), curveTypeStr, referenceStr, currencyStr, repoGroups, legalEntityGroups);
}
}
//-------------------------------------------------------------------------
internal static ScenarioMarketData marketData(CurveName curveName)
{
DoubleMatrix jacobian = DoubleMatrix.ofUnsafe(new double[][]
{
new double[] { 0.985d, 0.01d, 0d },
new double[] { 0.01d, 0.98d, 0.01d },
new double[] { 0.005d, 0.01d, 0.99d }
});
JacobianCalibrationMatrix jcm = JacobianCalibrationMatrix.of(ImmutableList.of(CurveParameterSize.of(curveName, 3)), jacobian);
DoubleArray time = DoubleArray.of(0.1, 0.25, 0.5d);
DoubleArray rate = DoubleArray.of(0.01, 0.015, 0.008d);
Curve curve = InterpolatedNodalCurve.of(Curves.zeroRates(curveName, ACT_360).withInfo(CurveInfoType.JACOBIAN, jcm), time, rate, NATURAL_SPLINE);
TestMarketDataMap md = new TestMarketDataMap(VAL_DATE, ImmutableMap.of(FORWARD_CURVE_ID, curve, QUOTE_KEY, MARKET_PRICE), ImmutableMap.of());
return(md);
}
// build the curves
private static IList <CurveDefinition> buildCurveDefinition(IDictionary <CurveName, LoadedCurveSettings> settingsMap, IDictionary <CurveName, IList <CurveNode> > allNodes)
{
ImmutableList.Builder <CurveDefinition> results = ImmutableList.builder();
foreach (KeyValuePair <CurveName, IList <CurveNode> > entry in allNodes.SetOfKeyValuePairs())
{
CurveName name = entry.Key;
LoadedCurveSettings settings = settingsMap[name];
if (settings == null)
{
throw new System.ArgumentException(Messages.format("Missing settings for curve: {}", name));
}
results.add(settings.createCurveDefinition(entry.Value));
}
return(results.build());
}
private LoadedCurveSettings(CurveName curveName, ValueType xValueType, ValueType yValueType, DayCount dayCount, CurveInterpolator interpolator, CurveExtrapolator extrapolatorLeft, CurveExtrapolator extrapolatorRight)
{
JodaBeanUtils.notNull(curveName, "curveName");
JodaBeanUtils.notNull(xValueType, "xValueType");
JodaBeanUtils.notNull(yValueType, "yValueType");
JodaBeanUtils.notNull(dayCount, "dayCount");
JodaBeanUtils.notNull(interpolator, "interpolator");
JodaBeanUtils.notNull(extrapolatorLeft, "extrapolatorLeft");
JodaBeanUtils.notNull(extrapolatorRight, "extrapolatorRight");
this.curveName = curveName;
this.xValueType = xValueType;
this.yValueType = yValueType;
this.dayCount = dayCount;
this.interpolator = interpolator;
this.extrapolatorLeft = extrapolatorLeft;
this.extrapolatorRight = extrapolatorRight;
}
public virtual void test_of_constant_interface()
{
IsdaCreditDiscountFactors test = (IsdaCreditDiscountFactors)CreditDiscountFactors.of(USD, VALUATION, CONST_CURVE);
assertEquals(test.Currency, USD);
assertEquals(test.Curve, CONST_CURVE);
assertEquals(test.DayCount, ACT_365L);
assertEquals(test.ParameterCount, 1);
assertEquals(test.getParameter(0), RATE_SINGLE);
assertEquals(test.ParameterKeys, DoubleArray.of(TIME_SINGLE));
assertEquals(test.getParameterMetadata(0), SimpleCurveParameterMetadata.of(METADATA.XValueType, TIME_SINGLE));
assertEquals(test.ValuationDate, VALUATION);
assertEquals(test.findData(CONST_CURVE.Name), CONST_CURVE);
assertEquals(test.findData(CurveName.of("Rubbish")), null);
assertEquals(test.toDiscountFactors(), ZeroRateDiscountFactors.of(USD, VALUATION, CONST_CURVE));
assertEquals(test.IsdaCompliant, true);
}
//-------------------------------------------------------------------------
/// <summary>
/// Parses the seasonality definition CSV file.
/// </summary>
/// <param name="charSource"> the seasonality CSV character source </param>
/// <returns> the map of seasonality definitions </returns>
public static IDictionary <CurveName, SeasonalityDefinition> parseSeasonalityDefinitions(CharSource charSource)
{
ImmutableMap.Builder <CurveName, SeasonalityDefinition> builder = ImmutableMap.builder();
CsvFile csv = CsvFile.of(charSource, true);
foreach (CsvRow row in csv.rows())
{
string curveNameStr = row.getField(CURVE_NAME);
string shiftTypeStr = row.getField(SHIFT_TYPE);
DoubleArray values = DoubleArray.of(12, i => double.Parse(row.getField(MONTH_PAIRS.get(i))));
CurveName curveName = CurveName.of(curveNameStr);
ShiftType shiftType = ShiftType.valueOf(shiftTypeStr.ToUpper(Locale.ENGLISH));
builder.put(curveName, SeasonalityDefinition.of(values, shiftType));
}
return(builder.build());
}
public virtual void test_bondDiscountingProvider()
{
LocalDate valDate = LocalDate.of(2015, 6, 30);
Curve ccAUsd = ConstantNodalCurve.of(Curves.zeroRates(CC_A_USD.CurveName, ACT_365F), 0.5d, 1.5d);
Curve ccBGbp = ConstantNodalCurve.of(Curves.zeroRates(CC_B_GBP.CurveName, ACT_365F), 0.5d, 2d);
Curve ccAGbp = ConstantNodalCurve.of(Curves.zeroRates(CC_A_GBP.CurveName, ACT_365F), 0.5d, 3d);
Curve dcGbp = ConstantNodalCurve.of(Curves.zeroRates(DC_GBP.CurveName, ACT_365F), 0.5d, 0.1d);
Curve dcUsd = ConstantNodalCurve.of(Curves.zeroRates(DC_USD.CurveName, ACT_365F), 0.5d, 0.05d);
Curve rcA = ConstantCurve.of(Curves.recoveryRates(RC_A.CurveName, ACT_365F), 0.5d);
Curve rcB = ConstantCurve.of(Curves.recoveryRates(RC_B.CurveName, ACT_365F), 0.4234d);
IDictionary <CurveId, Curve> curveMap = new Dictionary <CurveId, Curve>();
curveMap[CC_A_USD] = ccAUsd;
curveMap[CC_B_GBP] = ccBGbp;
curveMap[CC_A_GBP] = ccAGbp;
curveMap[DC_USD] = dcUsd;
curveMap[DC_GBP] = dcGbp;
curveMap[RC_A] = rcA;
curveMap[RC_B] = rcB;
MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.copyOf(curveMap));
CreditRatesProvider provider = LOOKUP_WITH_SOURCE.creditRatesProvider(md);
assertEquals(provider.ValuationDate, valDate);
assertEquals(provider.findData(CC_A_USD.CurveName), ccAUsd);
assertEquals(provider.findData(DC_USD.CurveName), dcUsd);
assertEquals(provider.findData(RC_B.CurveName), rcB);
assertEquals(provider.findData(CurveName.of("Rubbish")), null);
// check credit curve
LegalEntitySurvivalProbabilities cc = provider.survivalProbabilities(ISSUER_A, GBP);
IsdaCreditDiscountFactors ccUnder = (IsdaCreditDiscountFactors)cc.SurvivalProbabilities;
assertEquals(ccUnder.Curve.Name, ccAGbp.Name);
assertThrowsRuntime(() => provider.survivalProbabilities(ISSUER_B, USD));
assertThrowsRuntime(() => provider.survivalProbabilities(ISSUER_C, USD));
// check discount curve
IsdaCreditDiscountFactors dc = (IsdaCreditDiscountFactors)provider.discountFactors(USD);
assertEquals(dc.Curve.Name, dcUsd.Name);
assertThrowsRuntime(() => provider.discountFactors(EUR));
// check recovery rate curve
ConstantRecoveryRates rc = (ConstantRecoveryRates)provider.recoveryRates(ISSUER_B);
assertEquals(rc.RecoveryRate, rcB.getParameter(0));
assertThrowsRuntime(() => provider.recoveryRates(ISSUER_C));
}
public MarketDataBox <RatesCurveInputs> build(RatesCurveInputsId id, MarketDataConfig marketDataConfig, ScenarioMarketData marketData, ReferenceData refData)
{
CurveGroupName groupName = id.CurveGroupName;
CurveName curveName = id.CurveName;
RatesCurveGroupDefinition groupDefn = marketDataConfig.get(typeof(RatesCurveGroupDefinition), groupName);
Optional <CurveDefinition> optionalDefinition = groupDefn.findCurveDefinition(id.CurveName);
if (!optionalDefinition.Present)
{
throw new System.ArgumentException(Messages.format("No curve named '{}' found in group '{}'", curveName, groupName));
}
CurveDefinition configuredDefn = optionalDefinition.get();
// determine market data needs
MarketDataBox <LocalDate> valuationDates = marketData.ValuationDate;
bool multipleValuationDates = valuationDates.ScenarioValue;
// curve definition can vary for each valuation date
if (multipleValuationDates)
{
IList <CurveDefinition> curveDefns = IntStream.range(0, valuationDates.ScenarioCount).mapToObj(valuationDates.getValue).map((LocalDate valDate) => configuredDefn.filtered(valDate, refData)).collect(toImmutableList());
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Set<com.opengamma.strata.data.MarketDataId<?>> requirements = nodeRequirements(curveDefns);
ISet <MarketDataId <object> > requirements = nodeRequirements(curveDefns);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, com.opengamma.strata.data.scenario.MarketDataBox<?>> marketDataValues = requirements.stream().collect(toImmutableMap(k -> k, k -> marketData.getValue(k)));
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IDictionary <MarketDataId <object>, MarketDataBox <object> > marketDataValues = requirements.collect(toImmutableMap(k => k, k => marketData.getValue(k)));
return(buildMultipleCurveInputs(MarketDataBox.ofScenarioValues(curveDefns), marketDataValues, valuationDates, refData));
}
// only one valuation date
LocalDate valuationDate = valuationDates.getValue(0);
CurveDefinition filteredDefn = configuredDefn.filtered(valuationDate, refData);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Set<com.opengamma.strata.data.MarketDataId<?>> requirements = nodeRequirements(com.google.common.collect.ImmutableList.of(filteredDefn));
ISet <MarketDataId <object> > requirements = nodeRequirements(ImmutableList.of(filteredDefn));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, com.opengamma.strata.data.scenario.MarketDataBox<?>> marketDataValues = requirements.stream().collect(toImmutableMap(k -> k, k -> marketData.getValue(k)));
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IDictionary <MarketDataId <object>, MarketDataBox <object> > marketDataValues = requirements.collect(toImmutableMap(k => k, k => marketData.getValue(k)));
// Do any of the inputs contain values for multiple scenarios, or do they contain 1 value each?
bool multipleInputValues = marketDataValues.Values.Any(MarketDataBox.isScenarioValue);
return(multipleInputValues || multipleValuationDates?buildMultipleCurveInputs(MarketDataBox.ofSingleValue(filteredDefn), marketDataValues, valuationDates, refData) : buildSingleCurveInputs(filteredDefn, marketDataValues, valuationDate, refData));
}
public virtual void test_builder_tenors()
{
CurveName curveName = CurveName.of("GBP");
CurrencyParameterSensitivity sens1Y = CurrencyParameterSensitivity.of(curveName, ImmutableList.of(TENOR_MD_1Y), GBP, DoubleArray.of(3));
CurveSensitivities test = CurveSensitivities.builder(PortfolioItemInfo.empty()).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1M, 4).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1W, 1).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1Y, 2).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1W, 2).add(ZERO_RATE_DELTA, sens1Y).build();
assertEquals(test.Info, PortfolioItemInfo.empty());
assertEquals(test.TypedSensitivities.size(), 1);
CurrencyParameterSensitivities sens = test.getTypedSensitivity(ZERO_RATE_DELTA);
assertEquals(sens.Sensitivities.size(), 1);
CurrencyParameterSensitivity singleSens = sens.getSensitivity(curveName, GBP);
assertEquals(singleSens.Sensitivity, DoubleArray.of(3, 4, 5));
assertEquals(singleSens.getParameterMetadata(0), TENOR_MD_1W);
assertEquals(singleSens.getParameterMetadata(1), TENOR_MD_1M);
assertEquals(singleSens.getParameterMetadata(2), TENOR_MD_1Y);
}
//-------------------------------------------------------------------------
/// <summary>
/// Parses the curve groups definition CSV file.
/// <para>
/// The list of <seealso cref="NodalCurveDefinition"/> will be empty in the resulting definition.
///
/// </para>
/// </summary>
/// <param name="groupsCharSource"> the curve groups CSV character source </param>
/// <returns> the list of definitions </returns>
public static IList <RatesCurveGroupDefinition> parseCurveGroupDefinitions(CharSource groupsCharSource)
{
IDictionary <CurveName, ISet <GroupAndReference> > curveGroups = new LinkedHashMap <CurveName, ISet <GroupAndReference> >();
CsvFile csv = CsvFile.of(groupsCharSource, true);
foreach (CsvRow row in csv.rows())
{
string curveGroupStr = row.getField(GROUPS_NAME);
string curveTypeStr = row.getField(GROUPS_CURVE_TYPE);
string referenceStr = row.getField(GROUPS_REFERENCE);
string curveNameStr = row.getField(GROUPS_CURVE_NAME);
GroupAndReference gar = createKey(CurveGroupName.of(curveGroupStr), curveTypeStr, referenceStr);
CurveName curveName = CurveName.of(curveNameStr);
curveGroups.computeIfAbsent(curveName, k => new LinkedHashSet <>()).add(gar);
}
return(buildCurveGroups(curveGroups));
}
/// <summary>
/// Creates a curve group entry for a curve from a list of keys from the same curve group.
/// </summary>
/// <param name="curveName"> the name of the curve </param>
/// <param name="gars"> the group-reference pairs </param>
/// <returns> a curve group entry built from the data in the IDs </returns>
private static RatesCurveGroupEntry curveGroupEntry(CurveName curveName, IList <GroupAndReference> gars)
{
ISet <Currency> currencies = new LinkedHashSet <Currency>();
ISet <Index> indices = new LinkedHashSet <Index>();
foreach (GroupAndReference gar in gars)
{
if (gar.currency != null)
{
currencies.Add(gar.currency);
}
else
{
indices.Add(gar.index);
}
}
return(RatesCurveGroupEntry.builder().curveName(curveName).discountCurrencies(currencies).indices(indices).build());
}
//-------------------------------------------------------------------------
// parses the currency as a column or from the reference
private static Currency parseCurrency(CsvRow row, CurveName reference)
{
Optional <string> currencyStr = row.findValue(CURRENCY_HEADER);
if (currencyStr.Present)
{
return(LoaderUtils.parseCurrency(currencyStr.get()));
}
string referenceStr = reference.Name.ToUpper(Locale.ENGLISH);
try
{
Optional <IborIndex> ibor = IborIndex.extendedEnum().find(referenceStr);
if (ibor.Present)
{
return(ibor.get().Currency);
}
else
{
Optional <FloatingRateName> frName = FloatingRateName.extendedEnum().find(referenceStr);
if (frName.Present)
{
return(frName.get().Currency);
}
else if (referenceStr.Length == 3)
{
return(Currency.of(referenceStr));
}
else if (referenceStr.Length > 3 && referenceStr[3] == '-' || referenceStr[3] == '_')
{
return(LoaderUtils.parseCurrency(referenceStr.Substring(0, 3)));
}
else
{
// drop out to exception
}
}
}
catch (Exception)
{
// drop out to exception
}
throw new System.ArgumentException("Unable to parse currency from reference, consider adding a 'Currency' column");
}
public virtual void test_ratesProvider()
{
ImmutableMap <Currency, CurveId> discounts = ImmutableMap.of(USD, CURVE_ID_DSC);
ImmutableMap <Index, CurveId> forwards = ImmutableMap.of(USD_FED_FUND, CURVE_ID_DSC, USD_LIBOR_3M, CURVE_ID_FWD, US_CPI_U, CURVE_ID_FWD);
RatesMarketDataLookup test = RatesMarketDataLookup.of(discounts, forwards);
LocalDate valDate = date(2015, 6, 30);
Curve dscCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_DSC.CurveName, ACT_360), 1d);
Curve fwdCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_FWD.CurveName, ACT_360), 2d);
MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.of(CURVE_ID_DSC, dscCurve, CURVE_ID_FWD, fwdCurve));
RatesProvider ratesProvider = test.ratesProvider(md);
assertEquals(ratesProvider.ValuationDate, valDate);
assertEquals(ratesProvider.findData(CURVE_ID_DSC.CurveName), dscCurve);
assertEquals(ratesProvider.findData(CURVE_ID_FWD.CurveName), fwdCurve);
assertEquals(ratesProvider.findData(CurveName.of("Rubbish")), null);
assertEquals(ratesProvider.IborIndices, ImmutableSet.of(USD_LIBOR_3M));
assertEquals(ratesProvider.OvernightIndices, ImmutableSet.of(USD_FED_FUND));
assertEquals(ratesProvider.PriceIndices, ImmutableSet.of(US_CPI_U));
assertEquals(ratesProvider.TimeSeriesIndices, ImmutableSet.of());
// check discount factors
SimpleDiscountFactors df = (SimpleDiscountFactors)ratesProvider.discountFactors(USD);
assertEquals(df.Curve.Name, dscCurve.Name);
assertThrowsIllegalArg(() => ratesProvider.discountFactors(GBP));
// check Ibor
DiscountIborIndexRates ibor = (DiscountIborIndexRates)ratesProvider.iborIndexRates(USD_LIBOR_3M);
SimpleDiscountFactors iborDf = (SimpleDiscountFactors)ibor.DiscountFactors;
assertEquals(iborDf.Curve.Name, fwdCurve.Name);
assertThrowsIllegalArg(() => ratesProvider.iborIndexRates(GBP_LIBOR_3M));
// check Overnight
DiscountOvernightIndexRates on = (DiscountOvernightIndexRates)ratesProvider.overnightIndexRates(USD_FED_FUND);
SimpleDiscountFactors onDf = (SimpleDiscountFactors)on.DiscountFactors;
assertEquals(onDf.Curve.Name, dscCurve.Name);
assertThrowsIllegalArg(() => ratesProvider.overnightIndexRates(GBP_SONIA));
// check price curve must be interpolated
assertThrowsIllegalArg(() => ratesProvider.priceIndexValues(US_CPI_U));
// to immutable
ImmutableRatesProvider expectedImmutable = ImmutableRatesProvider.builder(valDate).fxRateProvider(MarketDataFxRateProvider.of(md)).discountCurve(USD, dscCurve).indexCurve(USD_FED_FUND, dscCurve).indexCurve(USD_LIBOR_3M, fwdCurve).indexCurve(US_CPI_U, fwdCurve).build();
assertEquals(ratesProvider.toImmutableRatesProvider(), expectedImmutable);
}
internal static InterpolatedNodalCurveDefinition fraSwapCurveDefinition()
{
string fra3x6 = "fra3x6";
string fra6x9 = "fra6x9";
string swap1y = "swap1y";
string swap2y = "swap2y";
string swap3y = "swap3y";
FraCurveNode fra3x6Node = CurveTestUtils.fraNode(3, fra3x6);
FraCurveNode fra6x9Node = CurveTestUtils.fraNode(6, fra6x9);
FixedIborSwapCurveNode swap1yNode = fixedIborSwapNode(Tenor.TENOR_1Y, swap1y);
FixedIborSwapCurveNode swap2yNode = fixedIborSwapNode(Tenor.TENOR_2Y, swap2y);
FixedIborSwapCurveNode swap3yNode = fixedIborSwapNode(Tenor.TENOR_3Y, swap3y);
CurveName curveName = CurveName.of("FRA and Fixed-Float Swap Curve");
IList <CurveNode> nodes = ImmutableList.of(fra3x6Node, fra6x9Node, swap1yNode, swap2yNode, swap3yNode);
return(InterpolatedNodalCurveDefinition.builder().name(curveName).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(DayCounts.ACT_ACT_ISDA).nodes(nodes).interpolator(CurveInterpolators.DOUBLE_QUADRATIC).extrapolatorLeft(CurveExtrapolators.FLAT).extrapolatorRight(CurveExtrapolators.FLAT).build());
}
private static void createKey(CurveName curveName, CurveGroupName curveGroup, string curveTypeStr, string referenceStr, string currencyStr, IDictionary <CurveGroupName, IDictionary <Pair <RepoGroup, Currency>, CurveName> > repoGroups, IDictionary <CurveGroupName, IDictionary <Pair <LegalEntityGroup, Currency>, CurveName> > legalEntityGroups)
{
Currency currency = Currency.of(currencyStr);
if (REPO.Equals(curveTypeStr.ToLower(Locale.ENGLISH), StringComparison.OrdinalIgnoreCase))
{
RepoGroup repoGroup = RepoGroup.of(referenceStr);
repoGroups.computeIfAbsent(curveGroup, k => new LinkedHashMap <>()).put(Pair.of(repoGroup, currency), curveName);
}
else if (ISSUER.Equals(curveTypeStr.ToLower(Locale.ENGLISH), StringComparison.OrdinalIgnoreCase))
{
LegalEntityGroup legalEntiryGroup = LegalEntityGroup.of(referenceStr);
legalEntityGroups.computeIfAbsent(curveGroup, k => new LinkedHashMap <>()).put(Pair.of(legalEntiryGroup, currency), curveName);
}
else
{
throw new System.ArgumentException(Messages.format("Unsupported curve type: {}", curveTypeStr));
}
}
public virtual void test_builder_mixCurrency()
{
CurveName curveName = CurveName.of("WEIRD");
CurveSensitivities test = CurveSensitivities.builder(PortfolioItemInfo.empty()).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1Y, 1).add(ZERO_RATE_DELTA, curveName, USD, TENOR_MD_1Y, 2).build();
assertEquals(test.Info, PortfolioItemInfo.empty());
assertEquals(test.TypedSensitivities.size(), 1);
CurrencyParameterSensitivities sens = test.getTypedSensitivity(ZERO_RATE_DELTA);
assertEquals(sens.Sensitivities.size(), 2);
CurrencyParameterSensitivity sensGbp = sens.getSensitivity(curveName, GBP);
assertEquals(sensGbp.Sensitivity, DoubleArray.of(1));
assertEquals(sensGbp.getParameterMetadata(0), TENOR_MD_1Y);
CurrencyParameterSensitivity sensUsd = sens.getSensitivity(curveName, USD);
assertEquals(sensUsd.Sensitivity, DoubleArray.of(2));
assertEquals(sensUsd.getParameterMetadata(0), TENOR_MD_1Y);
}
public virtual void test_of()
{
IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE);
assertEquals(test.Currency, USD);
assertEquals(test.Curve, CURVE);
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.ParameterCount, RATE.size());
assertEquals(test.getParameter(3), RATE.get(3));
assertEquals(test.getParameter(1), RATE.get(1));
assertEquals(test.ParameterKeys, TIME);
assertEquals(test.getParameterMetadata(4), SimpleCurveParameterMetadata.of(METADATA.XValueType, TIME.get(4)));
assertEquals(test.getParameterMetadata(6), SimpleCurveParameterMetadata.of(METADATA.XValueType, TIME.get(6)));
assertEquals(test.ValuationDate, VALUATION);
assertEquals(test.findData(CURVE.Name), CURVE);
assertEquals(test.findData(CurveName.of("Rubbish")), null);
assertEquals(test.toDiscountFactors(), ZeroRateDiscountFactors.of(USD, VALUATION, CURVE));
assertEquals(test.IsdaCompliant, true);
}
//-------------------------------------------------------------------------
// parses the file in standard format
private void parseStandardFormat(CsvIterator csv, ListMultimap <string, CurveSensitivities> parsed, IList <FailureItem> failures)
{
// loop around all rows, peeking to match batches with the same identifier
// no exception catch at this level to avoid infinite loops
while (csv.hasNext())
{
CsvRow peekedRow = csv.peek();
PortfolioItemInfo info = parseInfo(peekedRow);
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
string id = info.Id.map(StandardId::toString).orElse("");
// process in batches, where the ID is the same
CurveSensitivitiesBuilder builder = CurveSensitivities.builder(info);
IList <CsvRow> batchRows = csv.nextBatch(r => matchId(r, id));
foreach (CsvRow batchRow in batchRows)
{
try
{
CurveName reference = CurveName.of(batchRow.getValue(REFERENCE_HEADER));
CurveName resolvedCurveName = resolver.checkCurveName(reference);
CurveSensitivitiesType type = CurveSensitivitiesType.of(batchRow.getValue(TYPE_HEADER));
ParameterMetadata metadata = parseMetadata(batchRow, false);
Currency currency = parseCurrency(batchRow, reference);
string valueStr = batchRow.getField(VALUE_HEADER);
if (valueStr.Length > 0)
{
double value = LoaderUtils.parseDouble(valueStr);
builder.add(type, resolvedCurveName, currency, metadata, value);
}
}
catch (System.ArgumentException ex)
{
failures.Add(FailureItem.of(PARSING, "CSV file could not be parsed at line {}: {}", batchRow.lineNumber(), ex.Message));
}
}
CurveSensitivities sens = builder.build();
if (!sens.TypedSensitivities.Empty)
{
parsed.put(sens.Id.map(object.toString).orElse(""), sens);
}
}
}
//-------------------------------------------------------------------------
public virtual void duplicateInputDataKeys()
{
FxSwapTemplate template1 = FxSwapTemplate.of(Period.ofMonths(1), FxSwapConventions.EUR_USD);
FxSwapTemplate template2 = FxSwapTemplate.of(Period.ofMonths(2), FxSwapConventions.EUR_USD);
QuoteId pointsKey1a = QuoteId.of(StandardId.of("test", "1a"));
QuoteId pointsKey1b = QuoteId.of(StandardId.of("test", "1b"));
QuoteId pointsKey2a = QuoteId.of(StandardId.of("test", "2a"));
QuoteId pointsKey2b = QuoteId.of(StandardId.of("test", "2b"));
FxSwapCurveNode node1a = FxSwapCurveNode.of(template1, pointsKey1a);
FxSwapCurveNode node1b = FxSwapCurveNode.of(template2, pointsKey1b);
FxSwapCurveNode node2 = FxSwapCurveNode.of(template1, pointsKey2a);
FxSwapCurveNode node2b = FxSwapCurveNode.of(template2, pointsKey2b);
CurveName curveName1 = CurveName.of("curve1");
InterpolatedNodalCurveDefinition curve1 = InterpolatedNodalCurveDefinition.builder().name(curveName1).nodes(node1a, node1b).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(ACT_360).interpolator(CurveInterpolators.LINEAR).extrapolatorLeft(CurveExtrapolators.LINEAR).extrapolatorRight(CurveExtrapolators.LINEAR).build();
CurveName curveName2 = CurveName.of("curve2");
InterpolatedNodalCurveDefinition curve2 = InterpolatedNodalCurveDefinition.builder().name(curveName2).nodes(node2, node2b).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(ACT_360).interpolator(CurveInterpolators.LINEAR).extrapolatorLeft(CurveExtrapolators.LINEAR).extrapolatorRight(CurveExtrapolators.LINEAR).build();
CurveGroupName curveGroupName = CurveGroupName.of("group");
RatesCurveGroupDefinition groupDefinition = RatesCurveGroupDefinition.builder().name(curveGroupName).addDiscountCurve(curve1, Currency.EUR).addDiscountCurve(curve2, Currency.USD).build();
RatesCurveGroupMarketDataFunction fn = new RatesCurveGroupMarketDataFunction();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> marketDataMap1 = com.google.common.collect.ImmutableMap.of(com.opengamma.strata.data.FxRateId.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD), com.opengamma.strata.basics.currency.FxRate.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD, 1.01), pointsKey1a, 0.1d, pointsKey1b, 0.2d);
IDictionary <MarketDataId <object>, object> marketDataMap1 = ImmutableMap.of(FxRateId.of(Currency.EUR, Currency.USD), FxRate.of(Currency.EUR, Currency.USD, 1.01), pointsKey1a, 0.1d, pointsKey1b, 0.2d);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> marketDataMap2 = com.google.common.collect.ImmutableMap.of(com.opengamma.strata.data.FxRateId.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD), com.opengamma.strata.basics.currency.FxRate.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD, 1.01), pointsKey2a, 0.1d, pointsKey2b, 0.2d);
IDictionary <MarketDataId <object>, object> marketDataMap2 = ImmutableMap.of(FxRateId.of(Currency.EUR, Currency.USD), FxRate.of(Currency.EUR, Currency.USD, 1.01), pointsKey2a, 0.1d, pointsKey2b, 0.2d);
RatesCurveInputs curveInputs1 = RatesCurveInputs.of(marketDataMap1, DefaultCurveMetadata.of("curve1"));
RatesCurveInputs curveInputs2 = RatesCurveInputs.of(marketDataMap2, DefaultCurveMetadata.of("curve2"));
ImmutableScenarioMarketData marketData = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addValue(RatesCurveInputsId.of(curveGroupName, curveName1, ObservableSource.NONE), curveInputs1).addValue(RatesCurveInputsId.of(curveGroupName, curveName2, ObservableSource.NONE), curveInputs2).build();
fn.buildCurveGroup(groupDefinition, CALIBRATOR, marketData, REF_DATA, ObservableSource.NONE);
// This has a duplicate key with a different value which should fail
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> badMarketDataMap = com.google.common.collect.ImmutableMap.of(com.opengamma.strata.data.FxRateId.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD), com.opengamma.strata.basics.currency.FxRate.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD, 1.02), pointsKey2a, 0.2d);
IDictionary <MarketDataId <object>, object> badMarketDataMap = ImmutableMap.of(FxRateId.of(Currency.EUR, Currency.USD), FxRate.of(Currency.EUR, Currency.USD, 1.02), pointsKey2a, 0.2d);
RatesCurveInputs badCurveInputs = RatesCurveInputs.of(badMarketDataMap, DefaultCurveMetadata.of("curve2"));
ScenarioMarketData badMarketData = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addValue(RatesCurveInputsId.of(curveGroupName, curveName1, ObservableSource.NONE), curveInputs1).addValue(RatesCurveInputsId.of(curveGroupName, curveName2, ObservableSource.NONE), badCurveInputs).build();
string msg = "Multiple unequal values found for identifier .*\\. Values: .* and .*";
assertThrowsIllegalArg(() => fn.buildCurveGroup(groupDefinition, CALIBRATOR, badMarketData, REF_DATA, ObservableSource.NONE), msg);
}
/// <summary>
/// Obtains a generator from an existing provider and definition.
/// </summary>
/// <param name="knownProvider"> the underlying known provider </param>
/// <param name="groupDefn"> the curve group definition </param>
/// <param name="refData"> the reference data to use </param>
/// <returns> the generator </returns>
public static ImmutableRatesProviderGenerator of(ImmutableRatesProvider knownProvider, RatesCurveGroupDefinition groupDefn, ReferenceData refData)
{
IList <CurveDefinition> curveDefns = new List <CurveDefinition>();
IList <CurveMetadata> curveMetadata = new List <CurveMetadata>();
SetMultimap <CurveName, Currency> discountNames = HashMultimap.create();
SetMultimap <CurveName, Index> indexNames = HashMultimap.create();
foreach (CurveDefinition curveDefn in groupDefn.CurveDefinitions)
{
curveDefns.Add(curveDefn);
curveMetadata.Add(curveDefn.metadata(knownProvider.ValuationDate, refData));
CurveName curveName = curveDefn.Name;
// A curve group is guaranteed to include an entry for every definition
RatesCurveGroupEntry entry = groupDefn.findEntry(curveName).get();
ISet <Currency> ccy = entry.DiscountCurrencies;
discountNames.putAll(curveName, ccy);
indexNames.putAll(curveName, entry.Indices);
}
return(new ImmutableRatesProviderGenerator(knownProvider, curveDefns, curveMetadata, discountNames, indexNames));
}
/// <summary>
/// Builds a list of curve group definitions from the map of curves and their keys.
/// <para>
/// The keys specify which curve groups each curve belongs to and how it is used in the group, for example
/// as a discount curve for a particular currency or as a forward curve for an index.
///
/// </para>
/// </summary>
/// <param name="garMap"> the map of name to keys </param>
/// <returns> a map of curve group name to curve group definition built from the curves </returns>
private static ImmutableList <RatesCurveGroupDefinition> buildCurveGroups(IDictionary <CurveName, ISet <GroupAndReference> > garMap)
{
Multimap <CurveGroupName, RatesCurveGroupEntry> groups = LinkedHashMultimap.create();
foreach (KeyValuePair <CurveName, ISet <GroupAndReference> > entry in garMap.SetOfKeyValuePairs())
{
CurveName curveName = entry.Key;
ISet <GroupAndReference> curveIds = entry.Value;
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IDictionary <CurveGroupName, IList <GroupAndReference> > idsByGroup = curveIds.collect(groupingBy(p => p.groupName));
foreach (KeyValuePair <CurveGroupName, IList <GroupAndReference> > groupEntry in idsByGroup.SetOfKeyValuePairs())
{
CurveGroupName groupName = groupEntry.Key;
IList <GroupAndReference> gars = groupEntry.Value;
groups.put(groupName, curveGroupEntry(curveName, gars));
}
}
return(MapStream.of(groups.asMap()).map((name, entry) => RatesCurveGroupDefinition.of(name, entry, ImmutableList.of())).collect(toImmutableList()));
}
public virtual void test_getter()
{
assertEquals(VOLS.ValuationDate, VAL_DATE);
assertEquals(VOLS.Index, GBP_LIBOR_3M);
assertEquals(VOLS.Surface, SURFACE);
assertEquals(VOLS.ParameterCount, TIME.size());
assertEquals(VOLS.findData(CURVE.Name).get(), CURVE);
assertEquals(VOLS.findData(SURFACE.Name).get(), SURFACE);
assertFalse(VOLS.findData(CurveName.of("foo")).Present);
int nParams = VOLS.ParameterCount;
double newValue = 152d;
for (int i = 0; i < nParams; ++i)
{
assertEquals(VOLS.getParameter(i), SURFACE.getParameter(i));
assertEquals(VOLS.getParameterMetadata(i), SURFACE.getParameterMetadata(i));
assertEquals(VOLS.withParameter(i, newValue), ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities.of(GBP_LIBOR_3M, VAL_DATE_TIME, SURFACE.withParameter(i, newValue), CURVE));
assertEquals(VOLS.withPerturbation((n, v, m) => 2d * v), ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities.of(GBP_LIBOR_3M, VAL_DATE_TIME, SURFACE.withPerturbation((n, v, m) => 2d * v), CURVE));
}
}
private void SetProperties(PricingStructureTypeEnum pricingStructureType, string curveName)
{
if (pricingStructureType == PricingStructureTypeEnum.RateCurve ||
pricingStructureType == PricingStructureTypeEnum.RateBasisCurve ||
pricingStructureType == PricingStructureTypeEnum.ClearedRateCurve ||
pricingStructureType == PricingStructureTypeEnum.RateSpreadCurve)
{
var rateCurveId = curveName.Split('-');
var indexTenor = rateCurveId[rateCurveId.Length - 1];
var indexName = rateCurveId[0];
for (var i = 1; i < rateCurveId.Length - 1; i++)
{
indexName = indexName + '-' + rateCurveId[i];
}
ForecastRateIndex = ForecastRateIndexHelper.Parse(indexName, indexTenor);
}
if (pricingStructureType == PricingStructureTypeEnum.DiscountCurve ||
pricingStructureType == PricingStructureTypeEnum.RateXccyCurve)
{
var rateCurveId = CurveName.Split('-');
var subordination = rateCurveId[rateCurveId.Length - 1];
var indexName = rateCurveId[0];
for (var i = 1; i < rateCurveId.Length - 1; i++)
{
indexName = indexName + '-' + rateCurveId[i];
}
CreditInstrumentId = InstrumentIdHelper.Parse(indexName);
CreditSeniority = CreditSeniorityHelper.Parse(subordination);
}
if (pricingStructureType == PricingStructureTypeEnum.InflationCurve)
{
var rateCurveId = CurveName.Split('-');
var indexTenor = rateCurveId[rateCurveId.Length - 1];
var indexName = rateCurveId[0];
for (var i = 1; i < rateCurveId.Length - 1; i++)
{
indexName = indexName + '-' + rateCurveId[i];
}
ForecastRateIndex = ForecastRateIndexHelper.Parse(indexName, indexTenor);
}
}
//-------------------------------------------------------------------------
public ImmutableRatesProvider generate(DoubleArray parameters, IDictionary <CurveName, JacobianCalibrationMatrix> jacobians, IDictionary <CurveName, DoubleArray> sensitivitiesMarketQuote)
{
// collect curves for child provider based on existing provider
IDictionary <Currency, Curve> discountCurves = new Dictionary <Currency, Curve>();
IDictionary <Index, Curve> indexCurves = new Dictionary <Index, Curve>();
//JAVA TO C# CONVERTER TODO TASK: There is no .NET Dictionary equivalent to the Java 'putAll' method:
discountCurves.putAll(knownProvider.DiscountCurves);
//JAVA TO C# CONVERTER TODO TASK: There is no .NET Dictionary equivalent to the Java 'putAll' method:
indexCurves.putAll(knownProvider.IndexCurves);
// generate curves from combined parameter array
int startIndex = 0;
for (int i = 0; i < curveDefinitions.size(); i++)
{
CurveDefinition curveDefn = curveDefinitions.get(i);
CurveMetadata metadata = curveMetadata.get(i);
CurveName name = curveDefn.Name;
// extract parameters for the child curve
int paramCount = curveDefn.ParameterCount;
DoubleArray curveParams = parameters.subArray(startIndex, startIndex + paramCount);
startIndex += paramCount;
// create the child curve
CurveMetadata childMetadata = this.childMetadata(metadata, curveDefn, jacobians, sensitivitiesMarketQuote);
Curve curve = curveDefn.curve(knownProvider.ValuationDate, childMetadata, curveParams);
// put child curve into maps
ISet <Currency> currencies = discountCurveNames.get(name);
foreach (Currency currency in currencies)
{
discountCurves[currency] = curve;
}
ISet <Index> indices = forwardCurveNames.get(name);
foreach (Index index in indices)
{
indexCurves[index] = curve;
}
}
return(knownProvider.toBuilder().discountCurves(discountCurves).indexCurves(indexCurves).build());
}
/// <summary>
/// Tests calibration a curve containing FRAs and pricing the curve instruments using the curve.
/// </summary>
public virtual void roundTripFra()
{
InterpolatedNodalCurveDefinition curveDefn = CurveTestUtils.fraCurveDefinition();
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <FraCurveNode> nodes = curveDefn.Nodes.Select(typeof(FraCurveNode).cast).collect(toImmutableList());
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<com.opengamma.strata.data.MarketDataId<?>> keys = nodes.stream().map(CurveTestUtils::key).collect(toImmutableList());
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <MarketDataId <object> > keys = nodes.Select(CurveTestUtils.key).collect(toImmutableList());
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, double> inputData = com.google.common.collect.ImmutableMap.builder<com.opengamma.strata.data.MarketDataId<?>, double>().put(keys.get(0), 0.003).put(keys.get(1), 0.0033).put(keys.get(2), 0.0037).put(keys.get(3), 0.0054).put(keys.get(4), 0.007).put(keys.get(5), 0.0091).put(keys.get(6), 0.0134).build();
IDictionary <MarketDataId <object>, double> inputData = ImmutableMap.builder <MarketDataId <object>, double>().put(keys[0], 0.003).put(keys[1], 0.0033).put(keys[2], 0.0037).put(keys[3], 0.0054).put(keys[4], 0.007).put(keys[5], 0.0091).put(keys[6], 0.0134).build();
CurveGroupName groupName = CurveGroupName.of("Curve Group");
CurveName curveName = CurveName.of("FRA Curve");
RatesCurveInputs curveInputs = RatesCurveInputs.of(inputData, DefaultCurveMetadata.of(curveName));
RatesCurveGroupDefinition groupDefn = RatesCurveGroupDefinition.builder().name(groupName).addCurve(curveDefn, Currency.USD, IborIndices.USD_LIBOR_3M).build();
RatesCurveGroupMarketDataFunction function = new RatesCurveGroupMarketDataFunction();
LocalDate valuationDate = date(2011, 3, 8);
ScenarioMarketData inputMarketData = ImmutableScenarioMarketData.builder(valuationDate).addValue(RatesCurveInputsId.of(groupName, curveName, ObservableSource.NONE), curveInputs).build();
MarketDataBox <RatesCurveGroup> curveGroup = function.buildCurveGroup(groupDefn, CALIBRATOR, inputMarketData, REF_DATA, ObservableSource.NONE);
Curve curve = curveGroup.SingleValue.findDiscountCurve(Currency.USD).get();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> marketDataMap = com.google.common.collect.ImmutableMap.builder<com.opengamma.strata.data.MarketDataId<?>, Object>().putAll(inputData).put(com.opengamma.strata.market.curve.CurveId.of(groupName, curveName), curve).build();
IDictionary <MarketDataId <object>, object> marketDataMap = ImmutableMap.builder <MarketDataId <object>, object>().putAll(inputData).put(CurveId.of(groupName, curveName), curve).build();
MarketData marketData = ImmutableMarketData.of(valuationDate, marketDataMap);
TestMarketDataMap scenarioMarketData = new TestMarketDataMap(valuationDate, marketDataMap, ImmutableMap.of());
RatesMarketDataLookup lookup = RatesMarketDataLookup.of(groupDefn);
RatesProvider ratesProvider = lookup.ratesProvider(scenarioMarketData.scenario(0));
// The PV should be zero for an instrument used to build the curve
nodes.ForEach(node => checkFraPvIsZero(node, ratesProvider, marketData));
}
public void test_write_standard_withDate()
{
CurveName curve1 = CurveName.of("GBDSC");
CurveName curve2 = CurveName.of("GBFWD");
// listed in reverse order to check ordering
CurveSensitivities sens = CurveSensitivities.builder(PortfolioItemInfo.empty().withAttribute(CCP_ATTR, "LCH")).add(ZERO_RATE_GAMMA, curve2, Currency.GBP, TenorParameterMetadata.of(Tenor.TENOR_3M), 1).add(ZERO_RATE_GAMMA, curve2, Currency.GBP, TenorParameterMetadata.of(Tenor.TENOR_6M), 2).add(ZERO_RATE_DELTA, curve2, Currency.GBP, TenorParameterMetadata.of(Tenor.TENOR_3M), 3).add(ZERO_RATE_DELTA, curve2, Currency.GBP, TenorParameterMetadata.of(Tenor.TENOR_6M), 5).add(ZERO_RATE_DELTA, curve1, Currency.GBP, TenorDateParameterMetadata.of(date(2018, 6, 30), Tenor.TENOR_3M), 2).add(ZERO_RATE_DELTA, curve1, Currency.GBP, TenorParameterMetadata.of(Tenor.TENOR_6M), 4).build();
StringBuilder buf = new StringBuilder();
WRITER_CCP.write(sens, buf);
string content = buf.ToString();
string expected = "" +
"Reference,Sensitivity Type,Sensitivity Tenor,Sensitivity Date,Currency,Value,CCP\n" +
"GBDSC,ZeroRateDelta,3M,2018-06-30,GBP,2.0,LCH\n" +
"GBDSC,ZeroRateDelta,6M,,GBP,4.0,LCH\n" +
"GBFWD,ZeroRateDelta,3M,,GBP,3.0,LCH\n" +
"GBFWD,ZeroRateDelta,6M,,GBP,5.0,LCH\n" +
"GBFWD,ZeroRateGamma,3M,,GBP,1.0,LCH\n" +
"GBFWD,ZeroRateGamma,6M,,GBP,2.0,LCH\n";
assertEquals(content, expected);
}
/// <summary>
/// Tests that par rates and ibor index are required for curves.
/// </summary>
public virtual void requirements()
{
FraCurveNode node1x4 = CurveTestUtils.fraNode(1, "foo");
FraCurveNode node2x5 = CurveTestUtils.fraNode(2, "foo");
IList <CurveNode> nodes = ImmutableList.of(node1x4, node2x5);
CurveGroupName groupName = CurveGroupName.of("Curve Group");
CurveName curveName = CurveName.of("FRA Curve");
ObservableSource obsSource = ObservableSource.of("Vendor");
InterpolatedNodalCurveDefinition curveDefn = InterpolatedNodalCurveDefinition.builder().name(curveName).nodes(nodes).interpolator(CurveInterpolators.DOUBLE_QUADRATIC).extrapolatorLeft(CurveExtrapolators.FLAT).extrapolatorRight(CurveExtrapolators.FLAT).build();
RateIndex ibor = IborIndices.USD_LIBOR_3M;
RatesCurveGroupDefinition groupDefn = RatesCurveGroupDefinition.builder().name(groupName).addCurve(curveDefn, Currency.USD, ibor).build();
MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(groupName, groupDefn).build();
RatesCurveGroupMarketDataFunction function = new RatesCurveGroupMarketDataFunction();
RatesCurveGroupId curveGroupId = RatesCurveGroupId.of(groupName, obsSource);
MarketDataRequirements requirements = function.requirements(curveGroupId, marketDataConfig);
assertThat(requirements.NonObservables).contains(RatesCurveInputsId.of(groupName, curveName, obsSource));
assertThat(requirements.TimeSeries.contains(IndexQuoteId.of(ibor)));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the notional equivalent from the present value market quote sensitivities.
/// <para>
/// The notional equivalent is the notional in each instrument used to calibrate the curves to have the same
/// sensitivity as the one of the portfolio described by the market quote sensitivities.
///
/// </para>
/// </summary>
/// <param name="marketQuoteSensitivities"> the market quote sensitivities </param>
/// <param name="provider"> the rates provider, containing sensitivity information </param>
/// <returns> the notionals </returns>
public virtual CurrencyParameterSensitivities notionalEquivalent(CurrencyParameterSensitivities marketQuoteSensitivities, RatesProvider provider)
{
IList <CurrencyParameterSensitivity> equivalentList = new List <CurrencyParameterSensitivity>();
foreach (CurrencyParameterSensitivity s in marketQuoteSensitivities.Sensitivities)
{
ArgChecker.isTrue(s.MarketDataName is CurveName, "curve name");
CurveName name = (CurveName)s.MarketDataName;
Optional <Curve> curveOpt = provider.findData(name);
ArgChecker.isTrue(curveOpt.Present, "Curve {} in the sensitiivty is not present in the provider", name);
Curve curve = curveOpt.get();
Optional <DoubleArray> pvSensiOpt = curve.Metadata.findInfo(CurveInfoType.PV_SENSITIVITY_TO_MARKET_QUOTE);
ArgChecker.isTrue(pvSensiOpt.Present, "Present value sensitivity curve info is required");
DoubleArray pvSensi = pvSensiOpt.get();
double[] notionalArray = new double[pvSensi.size()];
for (int i = 0; i < pvSensi.size(); i++)
{
notionalArray[i] = s.Sensitivity.get(i) / pvSensi.get(i);
}
DoubleArray notional = DoubleArray.ofUnsafe(notionalArray);
equivalentList.Add(CurrencyParameterSensitivity.of(name, s.ParameterMetadata, s.Currency, notional));
}
return(CurrencyParameterSensitivities.of(equivalentList));
}
public GCurve(CurveName Curvename)
{
name = Curvename.ToString();
minval = double.MinValue;
maxval = double.MaxValue;
init0 = 0;
init1 = 0;
Points = new List<KeyValuePair<bool, PointF>>();
}
public GCurve(CurveName Curvename, float Val, int filecount)
{
name = Curvename.ToString();
minval = double.MinValue;
maxval = double.MaxValue;
init0 = Val;
init1 = Val;
SelectedPoint = 0;
Points = new List<KeyValuePair<bool, PointF>>();
ResetCurve(filecount);
}
public GCurve(CurveName Curvename, double min, double max, float firstVal, float lastVal, int filecount)
{
name = Curvename.ToString();
minval = min;
maxval = max;
init0 = firstVal;
init1 = lastVal;
SelectedPoint = 0;
Points = new List<KeyValuePair<bool, PointF>>();
ResetCurve(filecount);
}
public GCurve GetCurve(CurveName Name)
{
GCurve output;
Curves.TryGetValue(Name.ToString(), out output);
return output;
}
