//-------------------------------------------------------------------------
public virtual void coverage()
{
FxRateScenarioArray rates1 = FxRateScenarioArray.of(Currency.EUR, Currency.USD, DoubleArray.of(1.07, 1.08, 1.09));
FxRateScenarioArray rates2 = FxRateScenarioArray.of(Currency.GBP, Currency.USD, DoubleArray.of(1.46, 1.47, 1.48));
coverImmutableBean(rates1);
coverBeanEquals(rates1, rates2);
}
/// <summary>
/// Test the expected exception is thrown when there are no FX rates available to convert the values.
/// </summary>
public virtual void missingFxRates()
{
DoubleArray values = DoubleArray.of(1, 2, 3);
FxRateScenarioArray rates = FxRateScenarioArray.of(EUR, USD, DoubleArray.of(1.61, 1.62, 1.63));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates);
CurrencyScenarioArray test = CurrencyScenarioArray.of(GBP, values);
assertThrows(() => test.convertedTo(USD, fxProvider), typeof(System.ArgumentException));
}
/// <summary>
/// Test the expected exception is thrown if there are not the same number of rates as there are values.
/// </summary>
public virtual void wrongNumberOfFxRates()
{
DoubleArray values = DoubleArray.of(1, 2, 3);
FxRateScenarioArray rates = FxRateScenarioArray.of(GBP, USD, DoubleArray.of(1.61, 1.62));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates);
CurrencyScenarioArray test = CurrencyScenarioArray.of(GBP, values);
assertThrows(() => test.convertedTo(USD, fxProvider), typeof(System.ArgumentException), "Expected 3 FX rates but received 2");
}
public virtual void wrongNumberOfFxRates()
{
FxRateScenarioArray rates = FxRateScenarioArray.of(GBP, USD, DoubleArray.of(1.61, 1.62, 1.63));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates);
IList <CurrencyAmount> values = ImmutableList.of(CurrencyAmount.of(Currency.GBP, 1), CurrencyAmount.of(Currency.GBP, 2));
DefaultScenarioArray <CurrencyAmount> test = DefaultScenarioArray.of(values);
assertThrows(() => test.convertedTo(Currency.USD, fxProvider), typeof(System.ArgumentException), "Expected 2 FX rates but received 3");
}
//-------------------------------------------------------------------------
private static void assertArraysEqual(FxRateScenarioArray a1, FxRateScenarioArray a2)
{
assertThat(a1.ScenarioCount).isEqualTo(a2.ScenarioCount);
assertThat(a1.Pair).isEqualTo(a2.Pair);
for (int i = 0; i < a1.ScenarioCount; i++)
{
assertThat(a1.fxRate(Currency.GBP, Currency.USD, i)).isEqualTo(a2.fxRate(Currency.GBP, Currency.USD, i), offset(TOLERANCE));
}
}
public virtual void missingFxRates()
{
FxRateScenarioArray rates = FxRateScenarioArray.of(EUR, USD, DoubleArray.of(1.61, 1.62, 1.63));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates);
IList <CurrencyAmount> values = ImmutableList.of(CurrencyAmount.of(Currency.GBP, 1), CurrencyAmount.of(Currency.GBP, 2), CurrencyAmount.of(Currency.GBP, 3));
DefaultScenarioArray <CurrencyAmount> test = DefaultScenarioArray.of(values);
assertThrows(() => test.convertedTo(Currency.USD, fxProvider), typeof(System.ArgumentException));
}
public virtual void getValues()
{
FxRateScenarioArray rates = FxRateScenarioArray.of(Currency.EUR, Currency.USD, DoubleArray.of(1.07, 1.08, 1.09));
assertThat(rates.Pair).isEqualTo(CurrencyPair.of(Currency.EUR, Currency.USD));
assertThat(rates.ScenarioCount).isEqualTo(3);
assertThat(rates.get(0)).isEqualTo(FxRate.of(Currency.EUR, Currency.USD, 1.07));
assertThat(rates.get(1)).isEqualTo(FxRate.of(Currency.EUR, Currency.USD, 1.08));
assertThat(rates.get(2)).isEqualTo(FxRate.of(Currency.EUR, Currency.USD, 1.09));
assertThrows(typeof(System.IndexOutOfRangeException), () => rates.get(3));
}
public virtual void convert()
{
FxRateScenarioArray rates1 = FxRateScenarioArray.of(GBP, CAD, DoubleArray.of(2.00, 2.01, 2.02));
FxRateScenarioArray rates2 = FxRateScenarioArray.of(USD, CAD, DoubleArray.of(1.30, 1.31, 1.32));
FxRateScenarioArray rates3 = FxRateScenarioArray.of(EUR, CAD, DoubleArray.of(1.4, 1.4, 1.4));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates1, rates2, rates3);
CurrencyScenarioArray convertedArray = VALUES_ARRAY.convertedTo(Currency.CAD, fxProvider);
DoubleArray expected = DoubleArray.of(20 * 2.00 + 30 * 1.30 + 40 * 1.4, 21 * 2.01 + 32 * 1.31 + 43 * 1.4, 22 * 2.02 + 33 * 1.32 + 44 * 1.4);
assertThat(convertedArray.Amounts.Values).isEqualTo(expected);
}
/// <summary>
/// Test that no conversion is done and no rates are used if the values are already in the reporting currency.
/// </summary>
public virtual void noConversionNecessary()
{
DoubleArray values = DoubleArray.of(1, 2, 3);
FxRateScenarioArray rates = FxRateScenarioArray.of(GBP, USD, DoubleArray.of(1.61, 1.62, 1.63));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates);
CurrencyScenarioArray test = CurrencyScenarioArray.of(GBP, values);
CurrencyScenarioArray convertedList = test.convertedTo(GBP, fxProvider);
assertThat(convertedList).isEqualTo(test);
}
public virtual void convert_inverse()
{
FxRateScenarioArray eurGbp = FxRateScenarioArray.of(Currency.EUR, Currency.GBP, DoubleArray.of(0.76, 0.75));
DoubleArray input = DoubleArray.of(1.11, 1.12);
DoubleArray expected = DoubleArray.of(1.11 * 1 / 0.76, 1.12 * 1 / 0.75);
DoubleArray converted = eurGbp.convert(input, Currency.GBP, Currency.EUR);
for (int i = 0; i < converted.size(); i++)
{
assertThat(converted.get(i)).isEqualTo(expected.get(i), offset(TOLERANCE));
}
}
public virtual void fxRate()
{
FxRateScenarioArray rates = FxRateScenarioArray.of(CurrencyPair.of(Currency.EUR, Currency.USD), DoubleArray.of(1.07, 1.08, 1.09));
assertThat(rates.fxRate(Currency.EUR, Currency.USD, 0)).isEqualTo(1.07);
assertThat(rates.fxRate(Currency.EUR, Currency.USD, 1)).isEqualTo(1.08);
assertThat(rates.fxRate(Currency.EUR, Currency.USD, 2)).isEqualTo(1.09);
assertThat(rates.fxRate(Currency.USD, Currency.EUR, 0)).isEqualTo(1 / 1.07);
assertThat(rates.fxRate(Currency.USD, Currency.EUR, 1)).isEqualTo(1 / 1.08);
assertThat(rates.fxRate(Currency.USD, Currency.EUR, 2)).isEqualTo(1 / 1.09);
}
//-----------------------------------------------------------------------
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
if (obj != null && obj.GetType() == this.GetType())
{
FxRateScenarioArray other = (FxRateScenarioArray)obj;
return(JodaBeanUtils.equal(pair, other.pair) && JodaBeanUtils.equal(rates, other.rates));
}
return(false);
}
//-------------------------------------------------------------------------
/// <summary>
/// Test that values are converted to the reporting currency using the rates in the market data.
/// </summary>
public virtual void convert()
{
DoubleArray values = DoubleArray.of(1, 2, 3);
FxRateScenarioArray rates = FxRateScenarioArray.of(GBP, USD, DoubleArray.of(1.61, 1.62, 1.63));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates);
CurrencyScenarioArray test = CurrencyScenarioArray.of(GBP, values);
CurrencyScenarioArray convertedList = test.convertedTo(USD, fxProvider);
DoubleArray expectedValues = DoubleArray.of(1 * 1.61, 2 * 1.62, 3 * 1.63);
CurrencyScenarioArray expectedList = CurrencyScenarioArray.of(USD, expectedValues);
assertThat(convertedList).isEqualTo(expectedList);
}
public virtual void convertCurrencyAmount()
{
FxRateScenarioArray rates = FxRateScenarioArray.of(GBP, USD, DoubleArray.of(1.61, 1.62, 1.63));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates);
SingleScenarioArray <CurrencyAmount> test = SingleScenarioArray.of(3, CurrencyAmount.of(GBP, 2));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: ScenarioArray<?> convertedList = test.convertedTo(USD, fxProvider);
ScenarioArray <object> convertedList = test.convertedTo(USD, fxProvider);
IList <CurrencyAmount> expectedValues = ImmutableList.of(CurrencyAmount.of(USD, 2 * 1.61), CurrencyAmount.of(USD, 2 * 1.62), CurrencyAmount.of(USD, 2 * 1.63));
DefaultScenarioArray <CurrencyAmount> expectedList = DefaultScenarioArray.of(expectedValues);
assertThat(convertedList).isEqualTo(expectedList);
}
public virtual void notConvertible()
{
FxRateScenarioArray rates = FxRateScenarioArray.of(GBP, USD, DoubleArray.of(1.61, 1.62, 1.63));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates);
IList <string> values = ImmutableList.of("a", "b", "c");
DefaultScenarioArray <string> test = DefaultScenarioArray.of(values);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: ScenarioArray<?> convertedList = test.convertedTo(com.opengamma.strata.basics.currency.Currency.GBP, fxProvider);
ScenarioArray <object> convertedList = test.convertedTo(Currency.GBP, fxProvider);
assertThat(convertedList).isEqualTo(test);
}
private FxRateScenarioArray computeCross(FxRateScenarioArray other, CurrencyPair crossPairAC)
{
// aim is to convert AAA/BBB and BBB/CCC to AAA/CCC
Currency currA = crossPairAC.Base;
Currency currC = crossPairAC.Counter;
// given the conventional cross rate pair, order the two rates to match
bool crossBaseCurrencyInFx1 = pair.contains(currA);
FxRateScenarioArray fxABorBA = crossBaseCurrencyInFx1 ? this : other;
FxRateScenarioArray fxBCorCB = crossBaseCurrencyInFx1 ? other : this;
// extract the rates, taking the inverse if the pair is in the inverse order
DoubleArray ratesAB = fxABorBA.Pair.Base.Equals(currA) ? fxABorBA.rates : fxABorBA.rates.map(v => 1 / v);
DoubleArray ratesBC = fxBCorCB.Pair.Counter.Equals(currC) ? fxBCorCB.rates : fxBCorCB.rates.map(v => 1 / v);
return(FxRateScenarioArray.of(crossPairAC, ratesAB.multipliedBy(ratesBC)));
}
//-------------------------------------------------------------------------
public virtual void test_addScenarioValueMap()
{
FxRateId eurGbpId = FxRateId.of(Currency.EUR, Currency.GBP);
FxRateId eurUsdId = FxRateId.of(Currency.EUR, Currency.USD);
FxRateScenarioArray eurGbpRates = FxRateScenarioArray.of(Currency.EUR, Currency.GBP, DoubleArray.of(0.79, 0.8, 0.81));
FxRateScenarioArray eurUsdRates = FxRateScenarioArray.of(Currency.EUR, Currency.USD, DoubleArray.of(1.09, 1.1, 1.11));
IDictionary <FxRateId, FxRateScenarioArray> values = ImmutableMap.of(eurGbpId, eurGbpRates, eurUsdId, eurUsdRates);
ImmutableScenarioMarketData marketData = ImmutableScenarioMarketData.builder(VAL_DATE).addScenarioValueMap(values).build();
assertEquals(marketData.ScenarioCount, 3);
assertEquals(marketData.Ids, ImmutableSet.of(eurGbpId, eurUsdId));
assertEquals(marketData.getValue(eurGbpId), MarketDataBox.ofScenarioValue(eurGbpRates));
assertEquals(marketData.getValue(eurUsdId), MarketDataBox.ofScenarioValue(eurUsdRates));
}
public virtual void convertIntoAnExistingCurrency()
{
FxRateScenarioArray rates1 = FxRateScenarioArray.of(USD, GBP, DoubleArray.of(1 / 1.50, 1 / 1.51, 1 / 1.52));
FxRateScenarioArray rates2 = FxRateScenarioArray.of(EUR, GBP, DoubleArray.of(0.7, 0.7, 0.7));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates1, rates2);
CurrencyScenarioArray convertedArray = VALUES_ARRAY.convertedTo(Currency.GBP, fxProvider);
assertThat(convertedArray.Currency).isEqualTo(Currency.GBP);
double[] expected = new double[] { 20 + 30 / 1.50 + 40 * 0.7, 21 + 32 / 1.51 + 43 * 0.7, 22 + 33 / 1.52 + 44 * 0.7 };
for (int i = 0; i < 3; i++)
{
assertThat(convertedArray.get(i).Amount).isEqualTo(expected[i], offset(1e-6));
}
}
public virtual void crossRatesInvalidInputs()
{
// Argument has both currencies the same
assertThrowsIllegalArg(() => FxRateScenarioArray.of(Currency.GBP, Currency.USD, DoubleArray.of(1)).crossRates(FxRateScenarioArray.of(Currency.EUR, Currency.EUR, DoubleArray.of(1))));
// Receiver has both currencies the same
assertThrowsIllegalArg(() => FxRateScenarioArray.of(Currency.GBP, Currency.GBP, DoubleArray.of(1)).crossRates(FxRateScenarioArray.of(Currency.EUR, Currency.USD, DoubleArray.of(1))));
// No currency in common
assertThrowsIllegalArg(() => FxRateScenarioArray.of(Currency.GBP, Currency.CHF, DoubleArray.of(1)).crossRates(FxRateScenarioArray.of(Currency.EUR, Currency.USD, DoubleArray.of(1))));
// Both pairs the same
assertThrowsIllegalArg(() => FxRateScenarioArray.of(Currency.GBP, Currency.CHF, DoubleArray.of(1)).crossRates(FxRateScenarioArray.of(Currency.GBP, Currency.CHF, DoubleArray.of(1))));
// Different length arrays
assertThrowsIllegalArg(() => FxRateScenarioArray.of(Currency.GBP, Currency.CHF, DoubleArray.of(1)).crossRates(FxRateScenarioArray.of(Currency.EUR, Currency.CHF, DoubleArray.of(1, 2))));
}
public virtual void crossRates()
{
FxRateScenarioArray eurGbp = FxRateScenarioArray.of(Currency.EUR, Currency.GBP, DoubleArray.of(0.76, 0.75));
FxRateScenarioArray eurUsd = FxRateScenarioArray.of(Currency.EUR, Currency.USD, DoubleArray.of(1.11, 1.12));
FxRateScenarioArray gbpEur = FxRateScenarioArray.of(Currency.GBP, Currency.EUR, DoubleArray.of(1 / 0.76, 1 / 0.75));
FxRateScenarioArray usdEur = FxRateScenarioArray.of(Currency.USD, Currency.EUR, DoubleArray.of(1 / 1.11, 1 / 1.12));
FxRateScenarioArray expectedGbpUsd = FxRateScenarioArray.of(Currency.GBP, Currency.USD, DoubleArray.of(1.460526315789474, 1.4933333333333334));
assertArraysEqual(eurGbp.crossRates(eurUsd), expectedGbpUsd);
assertArraysEqual(eurGbp.crossRates(usdEur), expectedGbpUsd);
assertArraysEqual(gbpEur.crossRates(eurUsd), expectedGbpUsd);
assertArraysEqual(gbpEur.crossRates(usdEur), expectedGbpUsd);
assertArraysEqual(eurUsd.crossRates(eurGbp), expectedGbpUsd);
assertArraysEqual(usdEur.crossRates(eurGbp), expectedGbpUsd);
assertArraysEqual(eurUsd.crossRates(gbpEur), expectedGbpUsd);
assertArraysEqual(usdEur.crossRates(gbpEur), expectedGbpUsd);
}
public virtual void unknownCurrencyPair()
{
FxRateScenarioArray rates = FxRateScenarioArray.of(Currency.EUR, Currency.USD, DoubleArray.of(1.07, 1.08, 1.09));
assertThrowsIllegalArg(() => rates.fxRate(Currency.AED, Currency.ARS, 0));
}
public virtual void identicalCurrenciesHaveRateOfOne()
{
assertThrowsIllegalArg(() => FxRateScenarioArray.of(Currency.EUR, Currency.EUR, DoubleArray.of(1.07, 1.08, 1.09)), "Conversion rate between identical currencies must be one");
}
public TestScenarioFxRateProvider(FxRateScenarioArray rates1, FxRateScenarioArray rates2, FxRateScenarioArray rates3)
{
this.rates1 = rates1;
this.rates2 = rates2;
this.rates3 = rates3;
}
public virtual void convert_unknown()
{
FxRateScenarioArray eurGbp = FxRateScenarioArray.of(Currency.EUR, Currency.GBP, DoubleArray.of(0.76, 0.75));
assertThrowsIllegalArg(() => eurGbp.convert(DoubleArray.of(1.07, 1.08), Currency.EUR, Currency.USD));
}
/// <summary>
/// Derives a set of FX rates from these rates and another set of rates.
/// <para>
/// For example, given rates for EUR/GBP and EUR/CHF it is possible to derive rates for GBP/CHF.
/// </para>
/// <para>
/// There must be exactly one currency in common between the two currency pairs and
/// each pair must contain two different currencies. The other rates must have the same scenario count
/// as these rates.
/// </para>
/// <para>
/// The returned object contains rates for converting between the two currencies which only appear in
/// one set of rates.
///
/// </para>
/// </summary>
/// <param name="other"> the other rates </param>
/// <returns> a set of FX rates derived from these rates and the other rates </returns>
public FxRateScenarioArray crossRates(FxRateScenarioArray other)
{
return(pair.cross(other.pair).map(cross => computeCross(other, cross)).orElseThrow(() => new System.ArgumentException(Messages.format("Unable to cross when no unique common currency: {} and {}", pair, other.pair))));
}
