//-------------------------------------------------------------------------
// Check market data computation
public virtual void market_data()
{
RatesCurveGroupDefinition group = GROUPS_SYN_EUR;
RatesProvider multicurveTsLarge = MULTICURVE_INPUT_EUR_TSEMPTY.toBuilder().timeSeries(TS_LARGE).build();
MarketData madTsEmpty = CALIBRATOR_SYNTHETIC.marketData(group, MULTICURVE_INPUT_EUR_TSEMPTY, REF_DATA);
MarketData madTsLarge = CALIBRATOR_SYNTHETIC.marketData(group, multicurveTsLarge, REF_DATA);
assertEquals(madTsEmpty.ValuationDate, VALUATION_DATE);
foreach (CurveDefinition entry in group.CurveDefinitions)
{
ImmutableList <CurveNode> nodes = entry.Nodes;
foreach (CurveNode node in nodes)
{
ResolvedTrade tradeTsEmpty = node.resolvedTrade(1d, madTsEmpty, REF_DATA);
double mqTsEmpty = MQ_MEASURES.value(tradeTsEmpty, MULTICURVE_INPUT_EUR_TSEMPTY);
assertEquals(mqTsEmpty, (double?)madTsEmpty.getValue(node.requirements().GetEnumerator().next()), TOLERANCE_MQ);
ResolvedTrade tradeTsLarge = node.resolvedTrade(1d, madTsLarge, REF_DATA);
double mqTsLarge = MQ_MEASURES.value(tradeTsLarge, multicurveTsLarge);
assertEquals(mqTsLarge, (double?)madTsLarge.getValue(node.requirements().GetEnumerator().next()), TOLERANCE_MQ);
// Market Quote for Fixed v ibor swaps should have changed with the fixing
if ((tradeTsLarge is ResolvedSwapTrade) && (((ResolvedSwapTrade)tradeTsLarge)).Product.getLegs(SwapLegType.IBOR).size() == 1)
{
assertTrue(Math.Abs(mqTsEmpty - mqTsLarge) > TOLERANCE_MQ);
}
}
}
assertEquals(madTsEmpty.TimeSeriesIds, ImmutableSet.of());
assertEquals(madTsLarge.TimeSeriesIds, ImmutableSet.of(IndexQuoteId.of(EUR_EURIBOR_3M), IndexQuoteId.of(EUR_EURIBOR_6M)));
}
static CalibrationZeroRateAndDiscountFactorUsd2OisIrsTest()
{
DSC_NAMES[DSCON_CURVE_NAME] = USD;
ISet <Index> usdFedFundSet = new HashSet <Index>();
usdFedFundSet.Add(USD_FED_FUND);
IDX_NAMES[DSCON_CURVE_NAME] = usdFedFundSet;
ISet <Index> usdLibor3Set = new HashSet <Index>();
usdLibor3Set.Add(USD_LIBOR_3M);
IDX_NAMES[FWD3_CURVE_NAME] = usdLibor3Set;
double fixingValue = 0.002345;
LocalDateDoubleTimeSeries tsBdUsdLibor3M = LocalDateDoubleTimeSeries.builder().put(VAL_DATE_BD, fixingValue).build();
LocalDate fixingDateHo = LocalDate.of(2015, 12, 24);
LocalDateDoubleTimeSeries tsHoUsdLibor3M = LocalDateDoubleTimeSeries.builder().put(fixingDateHo, fixingValue).build();
TS_BD_LIBOR3M = ImmutableMarketData.builder(VAL_DATE_BD).addTimeSeries(IndexQuoteId.of(USD_LIBOR_3M), tsBdUsdLibor3M).build();
TS_HO_LIBOR3M = ImmutableMarketData.builder(VAL_DATE_HO).addTimeSeries(IndexQuoteId.of(USD_LIBOR_3M), tsHoUsdLibor3M).build();
for (int i = 0; i < DSC_NB_OIS_NODES; i++)
{
DSC_NODES[i] = FixedOvernightSwapCurveNode.of(FixedOvernightSwapTemplate.of(Period.ZERO, Tenor.of(DSC_OIS_TENORS[i]), USD_FIXED_1Y_FED_FUND_OIS), QuoteId.of(StandardId.of(SCHEME, DSC_ID_VALUE[i])));
}
FWD3_NODES[0] = IborFixingDepositCurveNode.of(IborFixingDepositTemplate.of(USD_LIBOR_3M), QuoteId.of(StandardId.of(SCHEME, FWD3_ID_VALUE[0])));
for (int i = 0; i < FWD3_NB_FRA_NODES; i++)
{
FWD3_NODES[i + 1] = FraCurveNode.of(FraTemplate.of(FWD3_FRA_TENORS[i], USD_LIBOR_3M), QuoteId.of(StandardId.of(SCHEME, FWD3_ID_VALUE[i + 1])));
}
for (int i = 0; i < FWD3_NB_IRS_NODES; i++)
{
FWD3_NODES[i + 1 + FWD3_NB_FRA_NODES] = FixedIborSwapCurveNode.of(FixedIborSwapTemplate.of(Period.ZERO, Tenor.of(FWD3_IRS_TENORS[i]), USD_FIXED_6M_LIBOR_3M), QuoteId.of(StandardId.of(SCHEME, FWD3_ID_VALUE[i + 1 + FWD3_NB_FRA_NODES])));
}
ImmutableMarketDataBuilder builder = ImmutableMarketData.builder(VAL_DATE_BD);
for (int i = 0; i < FWD3_NB_NODES; i++)
{
builder.addValue(QuoteId.of(StandardId.of(SCHEME, FWD3_ID_VALUE[i])), FWD3_MARKET_QUOTES[i]);
}
for (int i = 0; i < DSC_NB_NODES; i++)
{
builder.addValue(QuoteId.of(StandardId.of(SCHEME, DSC_ID_VALUE[i])), DSC_MARKET_QUOTES[i]);
}
ALL_QUOTES_BD = builder.build();
IList <CurveNode[]> groupDsc = new List <CurveNode[]>();
groupDsc.Add(DSC_NODES);
CURVES_NODES.Add(groupDsc);
IList <CurveNode[]> groupFwd3 = new List <CurveNode[]>();
groupFwd3.Add(FWD3_NODES);
CURVES_NODES.Add(groupFwd3);
IList <CurveMetadata> groupDsc = new List <CurveMetadata>();
groupDsc.Add(DefaultCurveMetadata.builder().curveName(DSCON_CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(CURVE_DC).build());
CURVES_METADATA.Add(groupDsc);
IList <CurveMetadata> groupFwd3 = new List <CurveMetadata>();
groupFwd3.Add(DefaultCurveMetadata.builder().curveName(FWD3_CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(CURVE_DC).build());
CURVES_METADATA.Add(groupFwd3);
}
static SyntheticRatesCurveCalibratorTest()
{ // Fixing unnaturally high to see the difference in the calibration
LocalDateDoubleTimeSeries tsEur3 = LocalDateDoubleTimeSeries.builder().put(VALUATION_DATE, 0.0200).build();
LocalDateDoubleTimeSeries tsEur6 = LocalDateDoubleTimeSeries.builder().put(VALUATION_DATE, 0.0250).build();
TS_LARGE[EUR_EURIBOR_3M] = tsEur3;
TS_LARGE[EUR_EURIBOR_6M] = tsEur6;
TS_LARGE_MD = ImmutableMarketData.builder(VALUATION_DATE).addTimeSeries(IndexQuoteId.of(EUR_EURIBOR_3M), tsEur3).addTimeSeries(IndexQuoteId.of(EUR_EURIBOR_6M), tsEur6).build();
}
//-------------------------------------------------------------------------
public virtual void test_requirementsAndCurrency()
{
OvernightFutureTradeCalculationFunction <OvernightFutureTrade> function = OvernightFutureTradeCalculationFunction.TRADE;
ISet <Measure> measures = function.supportedMeasures();
FunctionRequirements reqs = function.requirements(TRADE, measures, PARAMS, REF_DATA);
assertThat(reqs.OutputCurrencies).Empty;
assertThat(reqs.ValueRequirements).isEqualTo(ImmutableSet.of(FORWARD_CURVE_ID, QUOTE_KEY));
assertThat(reqs.TimeSeriesRequirements).isEqualTo(ImmutableSet.of(IndexQuoteId.of(INDEX)));
assertThat(function.naturalCurrency(TRADE, REF_DATA)).isEqualTo(CURRENCY);
}
//-------------------------------------------------------------------------
public virtual void test_requirementsAndCurrency()
{
FraTradeCalculationFunction function = new FraTradeCalculationFunction();
ISet <Measure> measures = function.supportedMeasures();
FunctionRequirements reqs = function.requirements(TRADE, measures, PARAMS, REF_DATA);
assertThat(reqs.OutputCurrencies).containsOnly(CURRENCY);
assertThat(reqs.ValueRequirements).isEqualTo(ImmutableSet.of(DISCOUNT_CURVE_ID, FORWARD_CURVE_ID));
assertThat(reqs.TimeSeriesRequirements).isEqualTo(ImmutableSet.of(IndexQuoteId.of(INDEX)));
assertThat(function.naturalCurrency(TRADE, REF_DATA)).isEqualTo(CURRENCY);
}
//-------------------------------------------------------------------------
public virtual void test_requirementsAndCurrency()
{
CapitalIndexedBondTradeCalculationFunction <CapitalIndexedBondTrade> function = CapitalIndexedBondTradeCalculationFunction.TRADE;
ISet <Measure> measures = function.supportedMeasures();
FunctionRequirements reqs = function.requirements(TRADE, measures, PARAMS, REF_DATA);
assertThat(reqs.OutputCurrencies).containsOnly(CURRENCY);
assertThat(reqs.ValueRequirements).isEqualTo(ImmutableSet.of(INF_CURVE_ID, REPO_CURVE_ID, ISSUER_CURVE_ID));
assertThat(reqs.TimeSeriesRequirements).isEqualTo(ImmutableSet.of(IndexQuoteId.of(US_CPI_U)));
assertThat(function.naturalCurrency(TRADE, REF_DATA)).isEqualTo(CURRENCY);
}
//-------------------------------------------------------------------------
// loads a single fixing series CSV file
private static ImmutableMap <ObservableId, LocalDateDoubleTimeSeries> parseSingle(CharSource resource)
{
IDictionary <ObservableId, LocalDateDoubleTimeSeriesBuilder> builders = new Dictionary <ObservableId, LocalDateDoubleTimeSeriesBuilder>();
try
{
CsvFile csv = CsvFile.of(resource, true);
foreach (CsvRow row in csv.rows())
{
string referenceStr = row.getField(REFERENCE_FIELD);
string dateStr = row.getField(DATE_FIELD);
string valueStr = row.getField(VALUE_FIELD);
Index index = LoaderUtils.findIndex(referenceStr);
ObservableId id = IndexQuoteId.of(index);
double value = double.Parse(valueStr);
LocalDate date;
if (index is PriceIndex)
{
try
{
YearMonth ym = LoaderUtils.parseYearMonth(dateStr);
date = ym.atEndOfMonth();
}
catch (Exception)
{
date = LoaderUtils.parseDate(dateStr);
if (date.DayOfMonth != date.lengthOfMonth())
{
throw new System.ArgumentException(Messages.format("Fixing Series CSV loader for price index must have date at end of month: {}", resource));
}
}
}
else
{
date = LoaderUtils.parseDate(dateStr);
}
LocalDateDoubleTimeSeriesBuilder builder = builders.computeIfAbsent(id, k => LocalDateDoubleTimeSeries.builder());
builder.put(date, value);
}
}
catch (Exception ex)
{
throw new System.ArgumentException(Messages.format("Error processing resource as CSV file: {}", resource), ex);
}
return(MapStream.of(builders).mapValues(builder => builder.build()).toMap());
}
static CalibrationInflationUsdTest()
{
DSC_NAMES[DSCON_CURVE_NAME] = USD;
ISet <Index> usdFedFundSet = new HashSet <Index>();
usdFedFundSet.Add(USD_FED_FUND);
IDX_NAMES[DSCON_CURVE_NAME] = usdFedFundSet;
ISet <Index> usdLibor3Set = new HashSet <Index>();
usdLibor3Set.Add(USD_LIBOR_3M);
IDX_NAMES[CPI_CURVE_NAME] = usdLibor3Set;
for (int i = 0; i < DSC_NB_DEPO_NODES; i++)
{
BusinessDayAdjustment bda = BusinessDayAdjustment.of(FOLLOWING, USNY);
TermDepositConvention convention = ImmutableTermDepositConvention.of("USD-Dep", USD, bda, ACT_360, DaysAdjustment.ofBusinessDays(DSC_DEPO_OFFSET[i], USNY));
DSC_NODES[i] = TermDepositCurveNode.of(TermDepositTemplate.of(Period.ofDays(1), convention), QuoteId.of(StandardId.of(SCHEME, DSC_ID_VALUE[i])));
}
for (int i = 0; i < DSC_NB_OIS_NODES; i++)
{
DSC_NODES[DSC_NB_DEPO_NODES + i] = FixedOvernightSwapCurveNode.of(FixedOvernightSwapTemplate.of(Period.ZERO, Tenor.of(DSC_OIS_TENORS[i]), USD_FIXED_1Y_FED_FUND_OIS), QuoteId.of(StandardId.of(SCHEME, DSC_ID_VALUE[DSC_NB_DEPO_NODES + i])));
}
for (int i = 0; i < CPI_NB_NODES; i++)
{
CPI_NODES[i] = FixedInflationSwapCurveNode.builder().template(FixedInflationSwapTemplate.of(Tenor.of(CPI_TENORS[i]), FixedInflationSwapConventions.USD_FIXED_ZC_US_CPI)).rateId(QuoteId.of(StandardId.of(SCHEME, CPI_ID_VALUE[i]))).date(CurveNodeDate.LAST_FIXING).build();
}
ImmutableMarketDataBuilder builder = ImmutableMarketData.builder(VAL_DATE);
for (int i = 0; i < DSC_NB_NODES; i++)
{
builder.addValue(QuoteId.of(StandardId.of(SCHEME, DSC_ID_VALUE[i])), DSC_MARKET_QUOTES[i]);
}
for (int i = 0; i < CPI_NB_NODES; i++)
{
builder.addValue(QuoteId.of(StandardId.of(SCHEME, CPI_ID_VALUE[i])), CPI_MARKET_QUOTES[i]);
}
builder.addTimeSeries(IndexQuoteId.of(US_CPI_U), TS_USD_CPI);
ALL_QUOTES = builder.build();
IList <CurveNode[]> groupDsc = new List <CurveNode[]>();
groupDsc.Add(DSC_NODES);
CURVES_NODES.Add(groupDsc);
IList <CurveNode[]> groupCpi = new List <CurveNode[]>();
groupCpi.Add(CPI_NODES);
CURVES_NODES.Add(groupCpi);
}
public double initialGuess(MarketData marketData, ValueType valueType)
{
if (ValueType.PRICE_INDEX.Equals(valueType))
{
PriceIndex index = template.Convention.FloatingLeg.Index;
LocalDateDoubleTimeSeries ts = marketData.getTimeSeries(IndexQuoteId.of(index));
double latestIndex = ts.LatestValue;
double rate = marketData.getValue(rateId);
double year = template.Tenor.Period.Years;
return(latestIndex * Math.Pow(1.0 + rate, year));
}
if (ValueType.ZERO_RATE.Equals(valueType))
{
return(marketData.getValue(rateId));
}
throw new System.ArgumentException("No default initial guess when value type is not 'PriceIndex' or 'ZeroRate'.");
}
/// <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)));
}
static CalibrationDiscountFactorUsd2FomcDatesOisIrsTest()
{
DSC_NAMES[DSCON_CURVE_NAME] = USD;
ISet <Index> usdFedFundSet = new HashSet <Index>();
usdFedFundSet.Add(USD_FED_FUND);
IDX_NAMES[DSCON_CURVE_NAME] = usdFedFundSet;
ISet <Index> usdLibor3Set = new HashSet <Index>();
usdLibor3Set.Add(USD_LIBOR_3M);
IDX_NAMES[FWD3_CURVE_NAME] = usdLibor3Set;
double fixingValue = 0.002345;
LocalDateDoubleTimeSeries tsBdUsdLibor3M = LocalDateDoubleTimeSeries.builder().put(VAL_DATE_BD, fixingValue).build();
TS_BD_LIBOR3M = ImmutableMarketData.builder(VAL_DATE_BD).addTimeSeries(IndexQuoteId.of(USD_LIBOR_3M), tsBdUsdLibor3M).build();
for (int i = 0; i < DSC_NB_DEPO_NODES; i++)
{
BusinessDayAdjustment bda = BusinessDayAdjustment.of(FOLLOWING, USNY);
TermDepositConvention convention = ImmutableTermDepositConvention.of("USD-Dep", USD, bda, ACT_360, DaysAdjustment.ofBusinessDays(DSC_DEPO_OFFSET[i], USNY));
LocalDate nodeDate = FOMC_NODES[i];
if (nodeDate != null)
{
DSC_NODES[i] = TermDepositCurveNode.builder().template(TermDepositTemplate.of(Period.ofDays(1), convention)).rateId(QuoteId.of(StandardId.of(SCHEME, DSC_ID_VALUE[i]))).date(CurveNodeDate.of(nodeDate)).build();
}
else
{
DSC_NODES[i] = TermDepositCurveNode.of(TermDepositTemplate.of(Period.ofDays(1), convention), QuoteId.of(StandardId.of(SCHEME, DSC_ID_VALUE[i])));
}
}
for (int i = 0; i < DSC_NB_OIS_NODES; i++)
{
LocalDate nodeDate = FOMC_NODES[DSC_NB_DEPO_NODES + i];
if (nodeDate != null)
{
DSC_NODES[DSC_NB_DEPO_NODES + i] = FixedOvernightSwapCurveNode.builder().template(FixedOvernightSwapTemplate.of(Period.ZERO, Tenor.of(DSC_OIS_TENORS[i]), USD_FIXED_1Y_FED_FUND_OIS)).rateId(QuoteId.of(StandardId.of(SCHEME, DSC_ID_VALUE[DSC_NB_DEPO_NODES + i]))).date(CurveNodeDate.of(nodeDate)).build();
}
else
{
DSC_NODES[DSC_NB_DEPO_NODES + i] = FixedOvernightSwapCurveNode.of(FixedOvernightSwapTemplate.of(Period.ZERO, Tenor.of(DSC_OIS_TENORS[i]), USD_FIXED_1Y_FED_FUND_OIS), QuoteId.of(StandardId.of(SCHEME, DSC_ID_VALUE[DSC_NB_DEPO_NODES + i])));
}
}
FWD3_NODES[0] = IborFixingDepositCurveNode.of(IborFixingDepositTemplate.of(USD_LIBOR_3M), QuoteId.of(StandardId.of(SCHEME, FWD3_ID_VALUE[0])));
for (int i = 0; i < FWD3_NB_FRA_NODES; i++)
{
FWD3_NODES[i + 1] = FraCurveNode.of(FraTemplate.of(FWD3_FRA_TENORS[i], USD_LIBOR_3M), QuoteId.of(StandardId.of(SCHEME, FWD3_ID_VALUE[i + 1])));
}
for (int i = 0; i < FWD3_NB_IRS_NODES; i++)
{
FWD3_NODES[i + 1 + FWD3_NB_FRA_NODES] = FixedIborSwapCurveNode.of(FixedIborSwapTemplate.of(Period.ZERO, Tenor.of(FWD3_IRS_TENORS[i]), USD_FIXED_6M_LIBOR_3M), QuoteId.of(StandardId.of(SCHEME, FWD3_ID_VALUE[i + 1 + FWD3_NB_FRA_NODES])));
}
ImmutableMarketDataBuilder builder = ImmutableMarketData.builder(VAL_DATE_BD);
for (int i = 0; i < FWD3_NB_NODES; i++)
{
builder.addValue(QuoteId.of(StandardId.of(SCHEME, FWD3_ID_VALUE[i])), FWD3_MARKET_QUOTES[i]);
}
for (int i = 0; i < DSC_NB_NODES; i++)
{
builder.addValue(QuoteId.of(StandardId.of(SCHEME, DSC_ID_VALUE[i])), DSC_MARKET_QUOTES[i]);
}
ALL_QUOTES_BD = builder.build();
IList <CurveNode[]> groupDsc = new List <CurveNode[]>();
groupDsc.Add(DSC_NODES);
CURVES_NODES.Add(groupDsc);
IList <CurveNode[]> groupFwd3 = new List <CurveNode[]>();
groupFwd3.Add(FWD3_NODES);
CURVES_NODES.Add(groupFwd3);
IList <CurveMetadata> groupDsc = new List <CurveMetadata>();
groupDsc.Add(DefaultCurveMetadata.builder().curveName(DSCON_CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(CURVE_DC).build());
CURVES_METADATA.Add(groupDsc);
IList <CurveMetadata> groupFwd3 = new List <CurveMetadata>();
groupFwd3.Add(DefaultCurveMetadata.builder().curveName(FWD3_CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(CURVE_DC).build());
CURVES_METADATA.Add(groupFwd3);
}
//-------------------------------------------------------------------------
public virtual MarketDataRequirements requirements(RatesCurveGroupId id, MarketDataConfig marketDataConfig)
{
RatesCurveGroupDefinition groupDefn = marketDataConfig.get(typeof(RatesCurveGroupDefinition), id.CurveGroupName);
// request input data for any curves that need market data
// no input data is requested if the curve definition contains all the market data needed to build the curve
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <RatesCurveInputsId> curveInputsIds = groupDefn.CurveDefinitions.Where(defn => requiresMarketData(defn)).Select(defn => defn.Name).Select(curveName => RatesCurveInputsId.of(groupDefn.Name, curveName, id.ObservableSource)).collect(toImmutableList());
IList <ObservableId> timeSeriesIds = groupDefn.Entries.stream().flatMap(entry => entry.Indices.stream()).distinct().map(index => IndexQuoteId.of(index)).collect(toImmutableList());
return(MarketDataRequirements.builder().addValues(curveInputsIds).addTimeSeries(timeSeriesIds).build());
}
//-------------------------------------------------------------------------
internal static ScenarioMarketData marketData()
{
return(new TestMarketDataMap(VAL_DATE, ImmutableMap.of(INF_CURVE_ID, CapitalIndexedBondCurveDataSet.CPI_CURVE, REPO_CURVE_ID, CapitalIndexedBondCurveDataSet.REPO_CURVE, ISSUER_CURVE_ID, CapitalIndexedBondCurveDataSet.ISSUER_CURVE), ImmutableMap.of(IndexQuoteId.of(US_CPI_U), CapitalIndexedBondCurveDataSet.getTimeSeries(VAL_DATE))));
}
public virtual void test_initialGuess()
{
FixedInflationSwapCurveNode node = FixedInflationSwapCurveNode.of(TEMPLATE, QUOTE_ID, SPREAD);
LocalDate valuationDate = LocalDate.of(2015, 1, 22);
double rate = 0.035;
double lastPriceIndex = 123.4;
LocalDateDoubleTimeSeries ts = LocalDateDoubleTimeSeries.builder().put(LocalDate.of(2024, 10, 31), lastPriceIndex).build();
MarketData marketData = ImmutableMarketData.builder(valuationDate).addValue(QUOTE_ID, rate).addTimeSeries(IndexQuoteId.of(PriceIndices.EU_EXT_CPI), ts).build();
assertEquals(node.initialGuess(marketData, ValueType.ZERO_RATE), rate);
double priceIndexGuess = lastPriceIndex * Math.Pow(1.0d + rate, TENOR_10Y.get(ChronoUnit.YEARS));
assertEquals(node.initialGuess(marketData, ValueType.PRICE_INDEX), priceIndexGuess, TOLERANCE_GUESS);
}
/// <summary>
/// Constructs the synthetic market data from an existing rates provider and the configuration of the new curves.
/// </summary>
/// <param name="group"> the curve group definition for the synthetic curves and instruments </param>
/// <param name="inputProvider"> the input rates provider </param>
/// <param name="refData"> the reference data, used to resolve the trades </param>
/// <returns> the market data </returns>
public ImmutableMarketData marketData(RatesCurveGroupDefinition group, RatesProvider inputProvider, ReferenceData refData)
{
// Retrieve the set of required indices and the list of required currencies
ISet <Index> indicesRequired = new HashSet <Index>();
IList <Currency> ccyRequired = new List <Currency>();
foreach (RatesCurveGroupEntry entry in group.Entries)
{
indicesRequired.addAll(entry.Indices);
((IList <Currency>)ccyRequired).AddRange(entry.DiscountCurrencies);
}
// Retrieve the required time series if present in the original provider
IDictionary <IndexQuoteId, LocalDateDoubleTimeSeries> ts = new Dictionary <IndexQuoteId, LocalDateDoubleTimeSeries>();
foreach (Index idx in Sets.intersection(inputProvider.TimeSeriesIndices, indicesRequired))
{
ts[IndexQuoteId.of(idx)] = inputProvider.timeSeries(idx);
}
LocalDate valuationDate = inputProvider.ValuationDate;
ImmutableList <CurveDefinition> curveGroups = group.CurveDefinitions;
// Create fake market quotes of 0, only to be able to generate trades
//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> mapId0 = new java.util.HashMap<>();
IDictionary <MarketDataId <object>, double> mapId0 = new Dictionary <MarketDataId <object>, double>();
foreach (CurveDefinition entry in curveGroups)
{
ImmutableList <CurveNode> nodes = entry.Nodes;
for (int i = 0; i < nodes.size(); i++)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (com.opengamma.strata.data.MarketDataId<?> key : nodes.get(i).requirements())
foreach (MarketDataId <object> key in nodes.get(i).requirements())
{
mapId0[key] = 0.0d;
}
}
}
ImmutableMarketData marketQuotes0 = ImmutableMarketData.of(valuationDate, mapId0);
// Generate market quotes from the trades
//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> mapIdSy = new java.util.HashMap<>();
IDictionary <MarketDataId <object>, object> mapIdSy = new Dictionary <MarketDataId <object>, object>();
foreach (CurveDefinition entry in curveGroups)
{
ImmutableList <CurveNode> nodes = entry.Nodes;
foreach (CurveNode node in nodes)
{
ResolvedTrade trade = node.resolvedTrade(1d, marketQuotes0, refData);
double mq = measures.value(trade, inputProvider);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<?> k = node.requirements().iterator().next();
MarketDataId <object> k = node.requirements().GetEnumerator().next();
mapIdSy[k] = mq;
}
}
// Generate quotes for FX pairs. The first currency is arbitrarily selected as starting point.
// The crosses are automatically generated by the MarketDataFxRateProvider used in calibration.
for (int loopccy = 1; loopccy < ccyRequired.Count; loopccy++)
{
CurrencyPair ccyPair = CurrencyPair.of(ccyRequired[0], ccyRequired[loopccy]);
FxRateId fxId = FxRateId.of(ccyPair);
mapIdSy[fxId] = FxRate.of(ccyPair, inputProvider.fxRate(ccyPair));
}
return(ImmutableMarketData.builder(valuationDate).addValueMap(mapIdSy).addTimeSeriesMap(ts).build());
}
public LocalDateDoubleTimeSeries timeSeries(Index index)
{
return(marketData.getTimeSeries(IndexQuoteId.of(index)));
}
//-------------------------------------------------------------------------
internal static ScenarioMarketData marketData()
{
LocalDateDoubleTimeSeries ts = LocalDateDoubleTimeSeries.of(date(2015, 10, 19), 0.013);
TestMarketDataMap md = new TestMarketDataMap(VAL_DATE, ImmutableMap.of(DISCOUNT_CURVE_ID, SwaptionSabrRateVolatilityDataSet.CURVE_DSC_EUR, FORWARD_CURVE_ID, SwaptionSabrRateVolatilityDataSet.CURVE_FWD_EUR, SWAPTION_ID, VOLS), ImmutableMap.of(IndexQuoteId.of(SWAP_INDEX), ts));
return(md);
}
//-------------------------------------------------------------------------
public virtual void test_of_map()
{
ImmutableMap <Currency, CurveId> discounts = ImmutableMap.of(USD, CURVE_ID_DSC);
ImmutableMap <Index, CurveId> forwards = ImmutableMap.of(USD_LIBOR_3M, CURVE_ID_FWD);
RatesMarketDataLookup test = RatesMarketDataLookup.of(discounts, forwards);
assertEquals(test.queryType(), typeof(RatesMarketDataLookup));
assertEquals(test.DiscountCurrencies, ImmutableSet.of(USD));
assertEquals(test.getDiscountMarketDataIds(USD), ImmutableSet.of(CURVE_ID_DSC));
assertEquals(test.ForwardIndices, ImmutableSet.of(USD_LIBOR_3M));
assertEquals(test.getForwardMarketDataIds(USD_LIBOR_3M), ImmutableSet.of(CURVE_ID_FWD));
assertThrowsIllegalArg(() => test.getDiscountMarketDataIds(GBP));
assertThrowsIllegalArg(() => test.getForwardMarketDataIds(GBP_LIBOR_3M));
assertEquals(test.ObservableSource, ObservableSource.NONE);
assertEquals(test.FxRateLookup, FxRateLookup.ofRates());
assertEquals(test.requirements(USD), FunctionRequirements.builder().valueRequirements(CURVE_ID_DSC).outputCurrencies(USD).build());
assertEquals(test.requirements(USD, USD_LIBOR_3M), FunctionRequirements.builder().valueRequirements(CURVE_ID_DSC, CURVE_ID_FWD).timeSeriesRequirements(IndexQuoteId.of(USD_LIBOR_3M)).outputCurrencies(USD).build());
assertEquals(test.requirements(ImmutableSet.of(USD), ImmutableSet.of(USD_LIBOR_3M)), FunctionRequirements.builder().valueRequirements(CURVE_ID_DSC, CURVE_ID_FWD).timeSeriesRequirements(IndexQuoteId.of(USD_LIBOR_3M)).outputCurrencies(USD).build());
assertThrowsIllegalArg(() => test.requirements(ImmutableSet.of(USD), ImmutableSet.of(GBP_LIBOR_3M)));
assertEquals(test.ratesProvider(MOCK_MARKET_DATA), DefaultLookupRatesProvider.of((DefaultRatesMarketDataLookup)test, MOCK_MARKET_DATA));
}
