//------------------------------------------------------------------------- public virtual void test_ratePointSensitivity() { DiscountFxForwardRates test = DiscountFxForwardRates.of(CURRENCY_PAIR, FX_RATE, DFCURVE_GBP, DFCURVE_USD); assertEquals(test.ratePointSensitivity(GBP, DATE_REF), FxForwardSensitivity.of(CURRENCY_PAIR, GBP, DATE_REF, 1d)); assertEquals(test.ratePointSensitivity(USD, DATE_REF), FxForwardSensitivity.of(CURRENCY_PAIR, USD, DATE_REF, 1d)); }
//------------------------------------------------------------------------- public virtual void test_multipliedBy() { FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); FxForwardSensitivity test = @base.multipliedBy(2.4d); FxForwardSensitivity expected = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY * 2.4d); assertEquals(test, expected); }
public virtual void test_forwardFxRatePointSensitivity() { PointSensitivityBuilder computed = PRICER.forwardFxRatePointSensitivity(FWD, PROVIDER); FxForwardSensitivity expected = FxForwardSensitivity.of(CurrencyPair.of(USD, KRW), USD, FWD.PaymentDate, 1d); assertEquals(computed, expected); }
//------------------------------------------------------------------------- public virtual void coverage() { FxForwardSensitivity test1 = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); coverImmutableBean(test1); FxForwardSensitivity test2 = FxForwardSensitivity.of(CurrencyPair.of(USD, JPY), JPY, date(2015, 9, 27), 4.25d); coverBeanEquals(test1, test2); }
//------------------------------------------------------------------------- public virtual void test_mapSensitivity() { FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); FxForwardSensitivity test = @base.mapSensitivity(s => 1d / s); FxForwardSensitivity expected = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, 1d / SENSITIVITY); assertEquals(test, expected); }
//------------------------------------------------------------------------- public virtual void test_toFxForwardSensitivity() { FxIndexSensitivity test = FxIndexSensitivity.of(GBP_USD_WM_OBS, GBP, USD, SENSITIVITY_VALUE); LocalDate maturityDate = GBP_USD_WM.calculateMaturityFromFixing(FIXING_DATE, REF_DATA); FxForwardSensitivity expected = FxForwardSensitivity.of(CurrencyPair.of(GBP, USD), GBP, maturityDate, USD, SENSITIVITY_VALUE); assertEquals(test.toFxForwardSensitivity(), expected); }
//------------------------------------------------------------------------- public virtual void test_buildInto() { FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); MutablePointSensitivities combo = new MutablePointSensitivities(); MutablePointSensitivities test = @base.buildInto(combo); assertSame(test, combo); assertEquals(test.Sensitivities, ImmutableList.of(@base)); }
public virtual void test_combinedWith_mutable() { FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); MutablePointSensitivities expected = new MutablePointSensitivities(); expected.add(@base); PointSensitivityBuilder test = @base.combinedWith(new MutablePointSensitivities()); assertEquals(test, expected); }
public int compareKey(PointSensitivity other) { if (other is FxForwardSensitivity) { FxForwardSensitivity otherFx = (FxForwardSensitivity)other; return(ComparisonChain.start().compare(currencyPair.ToString(), otherFx.currencyPair.ToString()).compare(currency, otherFx.currency).compare(referenceCurrency, otherFx.referenceCurrency).compare(referenceDate, otherFx.referenceDate).result()); } return(this.GetType().Name.CompareTo(other.GetType().Name)); }
//------------------------------------------------------------------------- public virtual void test_combinedWith() { FxForwardSensitivity base1 = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); FxForwardSensitivity base2 = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, 1.56d); MutablePointSensitivities expected = new MutablePointSensitivities(); expected.add(base1).add(base2); PointSensitivityBuilder test = base1.combinedWith(base2); assertEquals(test, expected); }
public virtual void test_of_withoutCurrency() { FxForwardSensitivity test = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); assertEquals(test.Currency, EUR); assertEquals(test.CurrencyPair, CURRENCY_PAIR); assertEquals(test.ReferenceCounterCurrency, EUR); assertEquals(test.ReferenceCurrency, GBP); assertEquals(test.ReferenceDate, REFERENCE_DATE); assertEquals(test.Sensitivity, SENSITIVITY); }
//------------------------------------------------------------------------- //proper end-to-end tests are elsewhere public virtual void test_parameterSensitivity() { DiscountFxForwardRates test = DiscountFxForwardRates.of(CURRENCY_PAIR, FX_RATE, DFCURVE_GBP, DFCURVE_USD); FxForwardSensitivity point = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, DATE_VAL, 1d); assertEquals(test.parameterSensitivity(point).size(), 2); FxForwardSensitivity point2 = FxForwardSensitivity.of(CURRENCY_PAIR, USD, DATE_VAL, 1d); assertEquals(test.parameterSensitivity(point2).size(), 2); }
public virtual void test_withCurrency_other() { FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); FxForwardSensitivity test = @base.withCurrency(USD); assertEquals(test.Currency, USD); assertEquals(test.CurrencyPair, CURRENCY_PAIR); assertEquals(test.ReferenceCounterCurrency, EUR); assertEquals(test.ReferenceCurrency, GBP); assertEquals(test.ReferenceDate, REFERENCE_DATE); assertEquals(test.Sensitivity, SENSITIVITY); }
//------------------------------------------------------------------------- public virtual void test_convertedTo() { FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); double rate = 1.4d; FxMatrix matrix = FxMatrix.of(CurrencyPair.of(EUR, USD), rate); FxForwardSensitivity test1 = (FxForwardSensitivity) @base.convertedTo(USD, matrix); FxForwardSensitivity expected = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, USD, SENSITIVITY * rate); assertEquals(test1, expected); FxForwardSensitivity test2 = (FxForwardSensitivity) @base.convertedTo(EUR, matrix); assertEquals(test2, @base); }
//----------------------------------------------------------------------- public override bool Equals(object obj) { if (obj == this) { return(true); } if (obj != null && obj.GetType() == this.GetType()) { FxForwardSensitivity other = (FxForwardSensitivity)obj; return(JodaBeanUtils.equal(currencyPair, other.currencyPair) && JodaBeanUtils.equal(referenceCurrency, other.referenceCurrency) && JodaBeanUtils.equal(referenceDate, other.referenceDate) && JodaBeanUtils.equal(currency, other.currency) && JodaBeanUtils.equal(sensitivity, other.sensitivity)); } return(false); }
//------------------------------------------------------------------------- public virtual void test_compareKey() { FxForwardSensitivity a1 = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, EUR, SENSITIVITY); FxForwardSensitivity a2 = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, EUR, SENSITIVITY); FxForwardSensitivity b = FxForwardSensitivity.of(CurrencyPair.of(GBP, USD), GBP, REFERENCE_DATE, EUR, SENSITIVITY); FxForwardSensitivity c = FxForwardSensitivity.of(CURRENCY_PAIR, EUR, REFERENCE_DATE, GBP, SENSITIVITY); FxForwardSensitivity d = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, JPY, SENSITIVITY); FxForwardSensitivity e = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, date(2015, 9, 27), SENSITIVITY); ZeroRateSensitivity other = ZeroRateSensitivity.of(GBP, 2d, SENSITIVITY); assertEquals(a1.compareKey(a2), 0); assertEquals(a1.compareKey(b) < 0, true); assertEquals(b.compareKey(a1) > 0, true); assertEquals(a1.compareKey(c) < 0, true); assertEquals(c.compareKey(a1) > 0, true); assertEquals(a1.compareKey(d) < 0, true); assertEquals(d.compareKey(a1) > 0, true); assertEquals(a1.compareKey(e) > 0, true); assertEquals(e.compareKey(a1) < 0, true); assertEquals(a1.compareKey(other) < 0, true); assertEquals(other.compareKey(a1) > 0, true); }
//------------------------------------------------------------------------- public CurrencyParameterSensitivities parameterSensitivity(FxForwardSensitivity pointSensitivity) { // use the specified base currency to determine the desired currency pair // then derive sensitivity from discount factors based off desired currency pair, not that of the index CurrencyPair currencyPair = pointSensitivity.CurrencyPair; Currency refBaseCurrency = pointSensitivity.ReferenceCurrency; Currency refCounterCurrency = pointSensitivity.ReferenceCounterCurrency; Currency sensitivityCurrency = pointSensitivity.Currency; LocalDate referenceDate = pointSensitivity.ReferenceDate; bool inverse = refBaseCurrency.Equals(currencyPair.Counter); DiscountFactors discountFactorsRefBase = (inverse ? counterCurrencyDiscountFactors : baseCurrencyDiscountFactors); DiscountFactors discountFactorsRefCounter = (inverse ? baseCurrencyDiscountFactors : counterCurrencyDiscountFactors); double dfCcyBaseAtMaturity = discountFactorsRefBase.discountFactor(referenceDate); double dfCcyCounterAtMaturityInv = 1d / discountFactorsRefCounter.discountFactor(referenceDate); double fxRate = fxRateProvider.fxRate(refBaseCurrency, refCounterCurrency); ZeroRateSensitivity dfCcyBaseAtMaturitySensitivity = discountFactorsRefBase.zeroRatePointSensitivity(referenceDate, sensitivityCurrency).multipliedBy(fxRate * dfCcyCounterAtMaturityInv * pointSensitivity.Sensitivity); ZeroRateSensitivity dfCcyCounterAtMaturitySensitivity = discountFactorsRefCounter.zeroRatePointSensitivity(referenceDate, sensitivityCurrency).multipliedBy(-fxRate * dfCcyBaseAtMaturity * dfCcyCounterAtMaturityInv * dfCcyCounterAtMaturityInv * pointSensitivity.Sensitivity); return(discountFactorsRefBase.parameterSensitivity(dfCcyBaseAtMaturitySensitivity).combinedWith(discountFactorsRefCounter.parameterSensitivity(dfCcyCounterAtMaturitySensitivity))); }
public MultiCurrencyAmount currencyExposure(FxForwardSensitivity pointSensitivity) { ArgChecker.isTrue(pointSensitivity.Currency.Equals(pointSensitivity.ReferenceCurrency), "Currency exposure defined only when sensitivity currency equal reference currency"); Currency ccyRef = pointSensitivity.ReferenceCurrency; CurrencyPair pair = pointSensitivity.CurrencyPair; double s = pointSensitivity.Sensitivity; LocalDate d = pointSensitivity.ReferenceDate; double f = fxRateProvider.fxRate(pair.Base, pair.Counter); double pA = baseCurrencyDiscountFactors.discountFactor(d); double pB = counterCurrencyDiscountFactors.discountFactor(d); if (ccyRef.Equals(pair.Base)) { CurrencyAmount amountCounter = CurrencyAmount.of(pair.Base, s * f * pA / pB); CurrencyAmount amountBase = CurrencyAmount.of(pair.Counter, -s * f * f * pA / pB); return(MultiCurrencyAmount.of(amountBase, amountCounter)); } else { CurrencyAmount amountBase = CurrencyAmount.of(pair.Base, -s * pB / (pA * f * f)); CurrencyAmount amountCounter = CurrencyAmount.of(pair.Counter, s * pB / (pA * f)); return(MultiCurrencyAmount.of(amountBase, amountCounter)); } }
//------------------------------------------------------------------------- public virtual void test_cloned() { FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); FxForwardSensitivity test = @base.cloned(); assertSame(test, @base); }
//------------------------------------------------------------------------- public virtual void test_build() { FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); PointSensitivities test = @base.build(); assertEquals(test.Sensitivities, ImmutableList.of(@base)); }
//------------------------------------------------------------------------- public PointSensitivityBuilder ratePointSensitivity(Currency baseCurrency, LocalDate referenceDate) { ArgChecker.isTrue(currencyPair.contains(baseCurrency), "Currency {} invalid for CurrencyPair {}", baseCurrency, currencyPair); return(FxForwardSensitivity.of(currencyPair, baseCurrency, referenceDate, 1d)); }
//------------------------------------------------------------------------- public virtual void test_withCurrency_same() { FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); FxForwardSensitivity test = @base.withCurrency(EUR); assertEquals(test, @base); }
public virtual void test_serialization() { FxForwardSensitivity test = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); assertSerialization(test); }
public virtual void test_of_wrongRefCurrency() { assertThrowsIllegalArg(() => FxForwardSensitivity.of(CURRENCY_PAIR, USD, REFERENCE_DATE, SENSITIVITY)); assertThrowsIllegalArg(() => FxForwardSensitivity.of(CURRENCY_PAIR, USD, REFERENCE_DATE, USD, SENSITIVITY)); }
//------------------------------------------------------------------------- public virtual void test_normalize() { FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY); FxForwardSensitivity test = @base.normalize(); assertEquals(test, @base); }
//------------------------------------------------------------------------- /// <summary> /// Converts this sensitivity to an {@code FxForwardSensitivity}. /// <para> /// The time series, fixing date and FX index are lost by this conversion. /// Instead, maturity date and currency pair are contained in <seealso cref="FxForwardSensitivity"/>. /// /// </para> /// </summary> /// <returns> the FX forward sensitivity </returns> public FxForwardSensitivity toFxForwardSensitivity() { return(FxForwardSensitivity.of(observation.CurrencyPair, referenceCurrency, observation.MaturityDate, currency, sensitivity)); }