//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") @Override public <T> com.opengamma.strata.data.scenario.MarketDataBox<T> getValue(com.opengamma.strata.data.MarketDataId<T> id)
public override MarketDataBox <T> getValue <T>(MarketDataId <T> id)
{
// this code exists to ensure that the error messages from market data building
// are exposed to users when the failures are not checked
// a special case for FX rates containing the same currency twice
if (id is FxRateId && ((FxRateId)id).Pair.Identity)
{
FxRateId fxRateId = (FxRateId)id;
FxRate identityRate = FxRate.of(fxRateId.Pair, 1);
return(MarketDataBox.ofSingleValue((T)identityRate));
}
// find the data and check it against the failures
Optional <MarketDataBox <T> > opt = underlying.findValue(id);
if (!opt.Present)
{
Failure failure = valueFailures.get(id);
if (failure != null)
{
throw new FailureException(failure);
}
throw new MarketDataNotFoundException(Messages.format("Market data not found for identifier '{}' of type '{}'", id, id.GetType().Name));
}
return(opt.get());
}
// loads a single CSV file, filtering by date
private static void parseSingle(System.Predicate <LocalDate> datePredicate, CharSource resource, IDictionary <LocalDate, ImmutableMap.Builder <FxRateId, FxRate> > mutableMap)
{
try
{
CsvFile csv = CsvFile.of(resource, true);
foreach (CsvRow row in csv.rows())
{
string dateText = row.getField(DATE_FIELD);
LocalDate date = LoaderUtils.parseDate(dateText);
if (datePredicate(date))
{
string currencyPairStr = row.getField(CURRENCY_PAIR_FIELD);
string valueStr = row.getField(VALUE_FIELD);
CurrencyPair currencyPair = CurrencyPair.parse(currencyPairStr);
double value = Convert.ToDouble(valueStr);
ImmutableMap.Builder <FxRateId, FxRate> builderForDate = mutableMap.computeIfAbsent(date, k => ImmutableMap.builder());
builderForDate.put(FxRateId.of(currencyPair), FxRate.of(currencyPair, value));
}
}
}
catch (Exception ex)
{
throw new System.ArgumentException(Messages.format("Error processing resource as CSV file: {}", resource), ex);
}
}
private void assertFile1Date2(IDictionary <FxRateId, FxRate> map)
{
assertTrue(map.ContainsKey(EUR_USD_ID));
assertTrue(map.ContainsKey(GBP_USD_ID));
assertEquals(map[EUR_USD_ID], FxRate.of(Currency.EUR, Currency.USD, 1.12));
assertEquals(map[GBP_USD_ID], FxRate.of(Currency.GBP, Currency.USD, 1.52));
}
//-------------------------------------------------------------------------
public FxForwardRates fxForwardRates(CurrencyPair currencyPair)
{
DiscountFactors @base = discountFactors(currencyPair.Base);
DiscountFactors counter = discountFactors(currencyPair.Counter);
FxRate fxRate = FxRate.of(currencyPair, fxRate(currencyPair));
return(DiscountFxForwardRates.of(currencyPair, fxRate, @base, counter));
};
static CalibrationZeroRateUsdOisIrsEurFxXCcyIrsTest()
{
USD_DSC_NODES[0] = TermDepositCurveNode.of(TermDepositTemplate.of(Period.ofDays(1), USD_SHORT_DEPOSIT_T0), QuoteId.of(StandardId.of(SCHEME, USD_DSC_ID_VALUE[0])));
USD_DSC_NODES[1] = TermDepositCurveNode.of(TermDepositTemplate.of(Period.ofDays(1), USD_SHORT_DEPOSIT_T1), QuoteId.of(StandardId.of(SCHEME, USD_DSC_ID_VALUE[1])));
for (int i = 0; i < USD_DSC_NB_OIS_NODES; i++)
{
USD_DSC_NODES[2 + i] = FixedOvernightSwapCurveNode.of(FixedOvernightSwapTemplate.of(Period.ZERO, Tenor.of(USD_DSC_OIS_TENORS[i]), USD_FIXED_1Y_FED_FUND_OIS), QuoteId.of(StandardId.of(SCHEME, USD_DSC_ID_VALUE[2 + i])));
}
USD_FWD3_NODES[0] = IborFixingDepositCurveNode.of(IborFixingDepositTemplate.of(USD_LIBOR_3M), QuoteId.of(StandardId.of(SCHEME, USD_FWD3_ID_VALUE[0])));
for (int i = 0; i < USD_FWD3_NB_FRA_NODES; i++)
{
USD_FWD3_NODES[i + 1] = FraCurveNode.of(FraTemplate.of(USD_FWD3_FRA_TENORS[i], USD_LIBOR_3M), QuoteId.of(StandardId.of(SCHEME, USD_FWD3_ID_VALUE[i + 1])));
}
for (int i = 0; i < USD_FWD3_NB_IRS_NODES; i++)
{
USD_FWD3_NODES[i + 1 + USD_FWD3_NB_FRA_NODES] = FixedIborSwapCurveNode.of(FixedIborSwapTemplate.of(Period.ZERO, Tenor.of(USD_FWD3_IRS_TENORS[i]), USD_FIXED_6M_LIBOR_3M), QuoteId.of(StandardId.of(SCHEME, USD_FWD3_ID_VALUE[i + 1 + USD_FWD3_NB_FRA_NODES])));
}
for (int i = 0; i < EUR_DSC_NB_FX_NODES; i++)
{
EUR_DSC_NODES[i] = FxSwapCurveNode.of(FxSwapTemplate.of(EUR_DSC_FX_TENORS[i], EUR_USD), QuoteId.of(StandardId.of(SCHEME, EUR_DSC_ID_VALUE[i])));
}
for (int i = 0; i < EUR_DSC_NB_XCCY_NODES; i++)
{
EUR_DSC_NODES[EUR_DSC_NB_FX_NODES + i] = XCcyIborIborSwapCurveNode.of(XCcyIborIborSwapTemplate.of(Tenor.of(EUR_DSC_XCCY_TENORS[i]), EUR_EURIBOR_3M_USD_LIBOR_3M), QuoteId.of(StandardId.of(SCHEME, EUR_DSC_ID_VALUE[EUR_DSC_NB_FX_NODES + i])));
}
EUR_FWD3_NODES[0] = IborFixingDepositCurveNode.of(IborFixingDepositTemplate.of(EUR_EURIBOR_3M), QuoteId.of(StandardId.of(SCHEME, EUR_FWD3_ID_VALUE[0])));
for (int i = 0; i < EUR_FWD3_NB_FRA_NODES; i++)
{
EUR_FWD3_NODES[i + 1] = FraCurveNode.of(FraTemplate.of(EUR_FWD3_FRA_TENORS[i], EUR_EURIBOR_3M), QuoteId.of(StandardId.of(SCHEME, EUR_FWD3_ID_VALUE[i + 1])));
}
for (int i = 0; i < EUR_FWD3_NB_IRS_NODES; i++)
{
EUR_FWD3_NODES[i + 1 + EUR_FWD3_NB_FRA_NODES] = FixedIborSwapCurveNode.of(FixedIborSwapTemplate.of(Period.ZERO, Tenor.of(EUR_FWD3_IRS_TENORS[i]), EUR_FIXED_1Y_EURIBOR_3M), QuoteId.of(StandardId.of(SCHEME, EUR_FWD3_ID_VALUE[i + 1 + EUR_FWD3_NB_FRA_NODES])));
}
ImmutableMarketDataBuilder builder = ImmutableMarketData.builder(VAL_DATE);
for (int i = 0; i < USD_DSC_NB_NODES; i++)
{
builder.addValue(QuoteId.of(StandardId.of(SCHEME, USD_DSC_ID_VALUE[i])), USD_DSC_MARKET_QUOTES[i]);
}
for (int i = 0; i < USD_FWD3_NB_NODES; i++)
{
builder.addValue(QuoteId.of(StandardId.of(SCHEME, USD_FWD3_ID_VALUE[i])), USD_FWD3_MARKET_QUOTES[i]);
}
for (int i = 0; i < EUR_DSC_NB_NODES; i++)
{
builder.addValue(QuoteId.of(StandardId.of(SCHEME, EUR_DSC_ID_VALUE[i])), EUR_DSC_MARKET_QUOTES[i]);
}
for (int i = 0; i < EUR_FWD3_NB_NODES; i++)
{
builder.addValue(QuoteId.of(StandardId.of(SCHEME, EUR_FWD3_ID_VALUE[i])), EUR_FWD3_MARKET_QUOTES[i]);
}
builder.addValue(QuoteId.of(StandardId.of(SCHEME, EUR_USD_ID_VALUE)), FX_RATE_EUR_USD);
builder.addValue(FxRateId.of(EUR, USD), FxRate.of(EUR, USD, FX_RATE_EUR_USD));
ALL_QUOTES = builder.build();
}
public virtual void buildInverse()
{
FxRateMarketDataFunction function = new FxRateMarketDataFunction();
MarketDataBox <double> quoteBox = MarketDataBox.ofSingleValue(1.1d);
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addBox(QUOTE_ID, quoteBox).build();
MarketDataBox <FxRate> rateBox = function.build(FxRateId.of(CURRENCY_PAIR.inverse()), config(), marketData, REF_DATA);
assertThat(rateBox.SingleValue).True;
assertThat(rateBox.SingleValue).isEqualTo(FxRate.of(CURRENCY_PAIR, 1.1d));
}
//-------------------------------------------------------------------------
public virtual void convertedTo()
{
LegAmounts @base = LegAmounts.of(LEG_AMOUNT_1, LEG_AMOUNT_2);
LegAmounts test = @base.convertedTo(Currency.GBP, FxRate.of(Currency.USD, Currency.GBP, 0.7));
assertThat(test.Amounts.get(0).Amount.Currency).isEqualTo(Currency.GBP);
assertThat(test.Amounts.get(0).Amount.Amount).isEqualTo(500d * 0.7d);
assertThat(test.Amounts.get(1).Amount.Currency).isEqualTo(Currency.GBP);
assertThat(test.Amounts.get(1).Amount.Amount).isEqualTo(420d * 0.7d);
}
/// <summary>
/// Converts an FX exchange to a string.
/// </summary>
/// <param name="base"> the base currency amount </param>
/// <param name="counter"> the counter currency amount </param>
/// <returns> the string form </returns>
public static string fx(CurrencyAmount @base, CurrencyAmount counter)
{
decimal rateDec = decimal.valueOf(counter.Amount / @base.Amount).setScale(@base.Currency.MinorUnitDigits + 2, RoundingMode.HALF_UP).abs();
FxRate rate = FxRate.of(@base.Currency, counter.Currency, rateDec.doubleValue());
decimal baseDec = decimal.valueOf(@base.Amount).stripTrailingZeros();
decimal counterDec = decimal.valueOf(counter.Amount).stripTrailingZeros();
bool roundBase = baseDec.scale() < counterDec.scale();
CurrencyAmount round = roundBase ? @base : counter;
return((round.Amount < 0 ? "Pay " : "Rec ") + SummarizerUtils.amount(round.mapAmount(a => Math.Abs(a))) + " " + "@ " + rate);
}
/// <summary>
/// Creates a {@code ResolvedFxSwap} using forward points.
/// <para>
/// The FX rate at the near date is specified as {@code fxRate}.
/// The FX rate at the far date is equal to {@code fxRate + forwardPoints}
/// </para>
/// <para>
/// The two currencies must not be equal.
/// The near date must be before the far date.
/// Conventions will be used to determine the base and counter currency.
///
/// </para>
/// </summary>
/// <param name="amountCurrency1"> the amount of the near leg in the first currency </param>
/// <param name="currency2"> the second currency </param>
/// <param name="nearFxRate"> the near FX rate, where {@code (1.0 * amountCurrency1 = fxRate * amountCurrency2)} </param>
/// <param name="forwardPoints"> the forward points, where the far FX rate is {@code (fxRate + forwardPoints)} </param>
/// <param name="nearDate"> the near value date </param>
/// <param name="farDate"> the far value date </param>
/// <returns> the resolved FX swap </returns>
public static ResolvedFxSwap ofForwardPoints(CurrencyAmount amountCurrency1, Currency currency2, double nearFxRate, double forwardPoints, LocalDate nearDate, LocalDate farDate)
{
Currency currency1 = amountCurrency1.Currency;
ArgChecker.isFalse(currency1.Equals(currency2), "Currencies must not be equal");
ArgChecker.notNegativeOrZero(nearFxRate, "fxRate");
double farFxRate = nearFxRate + forwardPoints;
ResolvedFxSingle nearLeg = ResolvedFxSingle.of(amountCurrency1, FxRate.of(currency1, currency2, nearFxRate), nearDate);
ResolvedFxSingle farLeg = ResolvedFxSingle.of(amountCurrency1.negated(), FxRate.of(currency1, currency2, farFxRate), farDate);
return(of(nearLeg, farLeg));
}
public virtual void buildScenario()
{
FxRateMarketDataFunction function = new FxRateMarketDataFunction();
MarketDataBox <double> quoteBox = MarketDataBox.ofScenarioValues(1.1d, 1.2d, 1.3d);
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addBox(QUOTE_ID, quoteBox).build();
MarketDataBox <FxRate> rateBox = function.build(RATE_ID, config(), marketData, REF_DATA);
assertThat(rateBox.SingleValue).False;
assertThat(rateBox.ScenarioCount).isEqualTo(3);
assertThat(rateBox.getValue(0)).isEqualTo(FxRate.of(CURRENCY_PAIR, 1.1d));
assertThat(rateBox.getValue(1)).isEqualTo(FxRate.of(CURRENCY_PAIR, 1.2d));
assertThat(rateBox.getValue(2)).isEqualTo(FxRate.of(CURRENCY_PAIR, 1.3d));
}
public virtual void test_fxProvider()
{
RatesMarketDataLookup test = RatesMarketDataLookup.of(ImmutableMap.of(), ImmutableMap.of());
LocalDate valDate = date(2015, 6, 30);
FxRateId gbpUsdId = FxRateId.of(GBP, USD);
FxRate gbpUsdRate = FxRate.of(GBP, USD, 1.6);
MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.of(gbpUsdId, gbpUsdRate));
FxRateProvider fxProvider = test.fxRateProvider(md);
assertEquals(fxProvider.fxRate(GBP, USD), 1.6);
assertEquals(test.marketDataView(md).fxRateProvider().fxRate(GBP, USD), 1.6);
assertThrows(() => fxProvider.fxRate(EUR, USD), typeof(MarketDataNotFoundException));
}
public virtual void test_addBadScenarioCount()
{
FxRateId eurGbpId = FxRateId.of(Currency.EUR, Currency.GBP);
FxRateId eurUsdId = FxRateId.of(Currency.EUR, Currency.USD);
FxRate eurGbpRate1 = FxRate.of(Currency.EUR, Currency.GBP, 0.8);
FxRate eurGbpRate2 = FxRate.of(Currency.EUR, Currency.GBP, 0.9);
FxRate eurGbpRate3 = FxRate.of(Currency.EUR, Currency.GBP, 0.95);
FxRate eurUsdRate1 = FxRate.of(Currency.EUR, Currency.USD, 1.1);
FxRate eurUsdRate2 = FxRate.of(Currency.EUR, Currency.USD, 1.2);
ImmutableScenarioMarketDataBuilder builder = ImmutableScenarioMarketData.builder(VAL_DATE).addBox(eurGbpId, MarketDataBox.ofScenarioValues(eurGbpRate1, eurGbpRate2, eurGbpRate3));
assertThrowsIllegalArg(() => builder.addBox(eurUsdId, MarketDataBox.ofScenarioValues(eurUsdRate1, eurUsdRate2)));
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
CashFlows @base = CashFlows.of(ImmutableList.of(CASH_FLOW_1, CASH_FLOW_2));
CashFlows test = @base.convertedTo(USD, FxRate.of(GBP, USD, 1.5));
assertEquals(test.getCashFlow(0), CASH_FLOW_1);
CashFlow converted = test.getCashFlow(1);
assertEquals(converted.PaymentDate, CASH_FLOW_2.PaymentDate);
assertEquals(converted.DiscountFactor, CASH_FLOW_2.DiscountFactor, TOLERANCE);
assertEquals(converted.PresentValue.Currency, USD);
assertEquals(converted.PresentValue.Amount, CASH_FLOW_2.PresentValue.Amount * 1.5, TOLERANCE);
assertEquals(converted.ForecastValue.Currency, USD);
assertEquals(converted.ForecastValue.Amount, CASH_FLOW_2.ForecastValue.Amount * 1.5, TOLERANCE);
}
//-------------------------------------------------------------------------
public virtual void test_addValueMap()
{
FxRateId eurGbpId = FxRateId.of(Currency.EUR, Currency.GBP);
FxRateId eurUsdId = FxRateId.of(Currency.EUR, Currency.USD);
FxRate eurGbpRate = FxRate.of(Currency.EUR, Currency.GBP, 0.8);
FxRate eurUsdRate = FxRate.of(Currency.EUR, Currency.USD, 1.1);
IDictionary <FxRateId, FxRate> values = ImmutableMap.of(eurGbpId, eurGbpRate, eurUsdId, eurUsdRate);
ImmutableScenarioMarketData marketData = ImmutableScenarioMarketData.builder(VAL_DATE).addValueMap(values).build();
assertEquals(marketData.ScenarioCount, 1);
assertEquals(marketData.Ids, ImmutableSet.of(eurGbpId, eurUsdId));
assertEquals(marketData.getValue(eurGbpId), MarketDataBox.ofSingleValue(eurGbpRate));
assertEquals(marketData.getValue(eurUsdId), MarketDataBox.ofSingleValue(eurUsdRate));
}
public virtual void test_addSingleAndBox()
{
FxRateId eurGbpId = FxRateId.of(Currency.EUR, Currency.GBP);
FxRateId eurUsdId = FxRateId.of(Currency.EUR, Currency.USD);
FxRate eurGbpRate = FxRate.of(Currency.EUR, Currency.GBP, 0.8);
FxRate eurUsdRate1 = FxRate.of(Currency.EUR, Currency.USD, 1.1);
FxRate eurUsdRate2 = FxRate.of(Currency.EUR, Currency.USD, 1.2);
ImmutableScenarioMarketData marketData = ImmutableScenarioMarketData.builder(VAL_DATE).addValue(eurGbpId, eurGbpRate).addBox(eurUsdId, MarketDataBox.ofScenarioValues(eurUsdRate1, eurUsdRate2)).build();
assertEquals(marketData.ScenarioCount, 2);
assertEquals(marketData.Ids, ImmutableSet.of(eurGbpId, eurUsdId));
assertEquals(marketData.getValue(eurGbpId), MarketDataBox.ofSingleValue(eurGbpRate));
assertEquals(marketData.getValue(eurUsdId), MarketDataBox.ofScenarioValues(eurUsdRate1, eurUsdRate2));
}
//-------------------------------------------------------------------------
internal static ScenarioMarketData marketData()
{
Curve curve1 = ConstantCurve.of(Curves.discountFactors("Test", ACT_360), 0.992);
Curve curve2 = ConstantCurve.of(Curves.discountFactors("Test", ACT_360), 0.991);
TestMarketDataMap md = new TestMarketDataMap(VAL_DATE, ImmutableMap.of(DISCOUNT_CURVE_EUR_ID, curve1, DISCOUNT_CURVE_USD_ID, curve2, VOL_ID, VOLS, FxRateId.of(EUR, USD), FxRate.of(EUR, USD, 1.62)), ImmutableMap.of());
return(md);
}
//-------------------------------------------------------------------------
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);
}
public virtual void cross_counter()
{
IDictionary <FxRateId, FxRate> marketDataMap = ImmutableMap.of(FxRateId.of(EUR, USD), FxRate.of(EUR, USD, EUR_USD), FxRateId.of(EUR, BEF), FxRate.of(EUR, BEF, EUR_BEF));
MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap);
FxRateProvider fx = MarketDataFxRateProvider.of(marketData);
assertEquals(fx.fxRate(USD, BEF), EUR_BEF / EUR_USD, 1.0E-10);
assertEquals(fx.fxRate(BEF, USD), EUR_USD / EUR_BEF, 1.0E-10);
}
public virtual void cross_base()
{
IDictionary <FxRateId, FxRate> marketDataMap = ImmutableMap.of(FxRateId.of(EUR, USD), FxRate.of(EUR, USD, EUR_USD), FxRateId.of(GBP, USD), FxRate.of(GBP, USD, GBP_USD));
MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap);
FxRateProvider fx = MarketDataFxRateProvider.of(marketData);
assertEquals(fx.fxRate(GBP, EUR), GBP_USD / EUR_USD, 1.0E-10);
assertEquals(fx.fxRate(EUR, GBP), EUR_USD / GBP_USD, 1.0E-10);
}
public virtual void cross_specified()
{
IDictionary <FxRateId, FxRate> marketDataMap = ImmutableMap.of(FxRateId.of(EUR, CHF), FxRate.of(EUR, CHF, EUR_CHF), FxRateId.of(GBP, CHF), FxRate.of(GBP, CHF, GBP_CHF));
MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap);
FxRateProvider fx = MarketDataFxRateProvider.of(marketData, ObservableSource.NONE, CHF);
assertEquals(fx.fxRate(GBP, EUR), GBP_CHF / EUR_CHF, 1.0E-10);
assertEquals(fx.fxRate(EUR, GBP), EUR_CHF / GBP_CHF, 1.0E-10);
assertThrows(() => fx.fxRate(EUR, USD), typeof(MarketDataNotFoundException));
}
// create an FX Forward trade
private static Trade createTrade2()
{
FxSingle fx = FxSingle.of(CurrencyAmount.of(USD, 15000), FxRate.of(GBP, USD, 1.62), LocalDate.of(2014, 9, 14));
return(FxSingleTrade.builder().product(fx).info(TradeInfo.builder().id(StandardId.of("example", "2")).addAttribute(AttributeType.DESCRIPTION, "USD 15,000/GBP @ 1.62 fwd").counterparty(StandardId.of("example", "BigBankB")).settlementDate(LocalDate.of(2014, 9, 15)).build()).build());
}
//-------------------------------------------------------------------------
private static MarketDataFxRateProvider provider()
{
IDictionary <FxRateId, FxRate> marketDataMap = ImmutableMap.of(FxRateId.of(EUR, USD, OBS_SOURCE), FxRate.of(EUR, USD, EUR_USD));
MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap);
return(MarketDataFxRateProvider.of(marketData, OBS_SOURCE, GBP));
}
/// <summary>
/// Creates an {@code FxSwap} using decimal forward points, specifying a date adjustment.
/// <para>
/// The FX rate at the near date is specified as {@code nearRate}.
/// The FX rate at the far date is equal to {@code nearRate + forwardPoints}
/// Thus "FX forward spread" might be a better name for the concept.
/// </para>
/// <para>
/// The two currencies are specified by the near FX rate.
/// The amount must be specified using one of the currencies of the near FX rate.
/// The near date must be before the far date.
/// Conventions will be used to determine the base and counter currency.
///
/// </para>
/// </summary>
/// <param name="amount"> the amount being exchanged, positive if being received in the near leg, negative if being paid </param>
/// <param name="nearRate"> the near FX rate </param>
/// <param name="decimalForwardPoints"> the decimal forward points, where the far FX rate is {@code (nearRate + forwardPoints)} </param>
/// <param name="nearDate"> the near value date </param>
/// <param name="farDate"> the far value date </param>
/// <param name="paymentDateAdjustment"> the adjustment to apply to the payment dates </param>
/// <returns> the FX swap </returns>
/// <exception cref="IllegalArgumentException"> if the FX rate and amount do not have a currency in common </exception>
public static FxSwap ofForwardPoints(CurrencyAmount amount, FxRate nearRate, double decimalForwardPoints, LocalDate nearDate, LocalDate farDate, BusinessDayAdjustment paymentDateAdjustment)
{
FxRate farRate = FxRate.of(nearRate.Pair, nearRate.fxRate(nearRate.Pair) + decimalForwardPoints);
return(of(amount, nearRate, nearDate, farRate, farDate, paymentDateAdjustment));
}
/// <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());
}
private void loadFxRates(ImmutableMarketDataBuilder builder)
{
// TODO - load from CSV file - format to be defined
builder.addValue(FxRateId.of(Currency.GBP, Currency.USD), FxRate.of(Currency.GBP, Currency.USD, 1.61));
}
private static MarketDataFxRateProvider provider2()
{
IDictionary <FxRateId, FxRate> marketDataMap = ImmutableMap.of(FxRateId.of(EUR, USD), FxRate.of(EUR, USD, EUR_USD), FxRateId.of(EUR, BEF), FxRate.of(EUR, BEF, EUR_BEF), FxRateId.of(GBP, USD), FxRate.of(GBP, USD, GBP_USD));
MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap);
return(MarketDataFxRateProvider.of(marketData, ObservableSource.NONE, GBP));
}
/// <summary>
/// Test that the result is converted to the reporting currency if it implements ScenarioFxConvertible and
/// the FX rates are available in the market data. The "natural" currency is taken from the function.
/// </summary>
public virtual void convertResultCurrencyUsingDefaultReportingCurrency()
{
DoubleArray values = DoubleArray.of(1, 2, 3);
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <FxRate> rates = ImmutableList.of(1.61, 1.62, 1.63).Select(rate => FxRate.of(GBP, USD, rate)).collect(toImmutableList());
CurrencyScenarioArray list = CurrencyScenarioArray.of(GBP, values);
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(date(2011, 3, 8)).addScenarioValue(FxRateId.of(GBP, USD), rates).build();
ConvertibleFunction fn = ConvertibleFunction.of(() => list, USD);
CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, NATURAL);
CalculationTask task = CalculationTask.of(TARGET, fn, cell);
DoubleArray expectedValues = DoubleArray.of(1 * 1.61, 2 * 1.62, 3 * 1.63);
CurrencyScenarioArray expectedArray = CurrencyScenarioArray.of(USD, expectedValues);
CalculationResults calculationResults = task.execute(marketData, REF_DATA);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result = calculationResults.getCells().get(0).getResult();
Result <object> result = calculationResults.Cells.get(0).Result;
assertThat(result).hasValue(expectedArray);
}
// create an FX Swap trade
private static Trade createTrade3()
{
FxSwap swap = FxSwap.ofForwardPoints(CurrencyAmount.of(GBP, 10000), FxRate.of(GBP, USD, 1.62), 0.03, LocalDate.of(2014, 6, 14), LocalDate.of(2014, 9, 14));
return(FxSwapTrade.builder().product(swap).info(TradeInfo.builder().id(StandardId.of("example", "3")).addAttribute(AttributeType.DESCRIPTION, "GBP 10,000/USD @ 1.62 swap").counterparty(StandardId.of("example", "BigBankA")).settlementDate(LocalDate.of(2014, 9, 15)).build()).build());
}
//-------------------------------------------------------------------------
public FxSwapTrade toTrade(TradeInfo tradeInfo, LocalDate startDate, LocalDate endDate, BuySell buySell, double notional, double nearFxRate, double farLegForwardPoints)
{
Optional <LocalDate> tradeDate = tradeInfo.TradeDate;
if (tradeDate.Present)
{
ArgChecker.inOrderOrEqual(tradeDate.get(), startDate, "tradeDate", "startDate");
}
double amount1 = BuySell.BUY.normalize(notional);
return(FxSwapTrade.builder().info(tradeInfo).product(FxSwap.ofForwardPoints(CurrencyAmount.of(currencyPair.Base, amount1), FxRate.of(currencyPair, nearFxRate), farLegForwardPoints, startDate, endDate, BusinessDayAdjustment)).build());
}
/// <summary>
/// Creates an {@code FxSwap} using decimal forward points.
/// <para>
/// The FX rate at the near date is specified as {@code nearRate}.
/// The FX rate at the far date is equal to {@code nearRate + forwardPoints}.
/// Thus "FX forward spread" might be a better name for the concept.
/// </para>
/// <para>
/// The two currencies are specified by the near FX rate.
/// The amount must be specified using one of the currencies of the near FX rate.
/// The near date must be before the far date.
/// Conventions will be used to determine the base and counter currency.
///
/// </para>
/// </summary>
/// <param name="amount"> the amount being exchanged, positive if being received in the near leg, negative if being paid </param>
/// <param name="nearRate"> the near FX rate </param>
/// <param name="decimalForwardPoints"> the decimal forward points, where the far FX rate is {@code (nearRate + forwardPoints)} </param>
/// <param name="nearDate"> the near value date </param>
/// <param name="farDate"> the far value date </param>
/// <returns> the FX swap </returns>
/// <exception cref="IllegalArgumentException"> if the FX rate and amount do not have a currency in common </exception>
public static FxSwap ofForwardPoints(CurrencyAmount amount, FxRate nearRate, double decimalForwardPoints, LocalDate nearDate, LocalDate farDate)
{
FxRate farRate = FxRate.of(nearRate.Pair, nearRate.fxRate(nearRate.Pair) + decimalForwardPoints);
return(of(amount, nearRate, nearDate, farRate, farDate));
}