/** * Gets the inverse rate. * <p> * The inverse rate has the same currencies but in reverse order. * The rate is the reciprocal of the original. * * @return the inverse pair */ public FxRate inverse() { return new FxRate(pair.inverse(), 1d / rate); }
/** * Returns the market convention currency pair for the currencies in the pair. * <p> * If {@link #isConventional()} is {@code true} this method returns {@code this}, otherwise * it returns the {@link #inverse} pair. * * @return the market convention currency pair for the currencies in the pair */ public CurrencyPair toConventional() { return isConventional() ? this : inverse(); }
/** * Gets the number of digits in the rate. * <p> * If this rate is a conventional currency pair defined in configuration, * then the number of digits in a market FX rate quote is returned. * <p> * If the currency pair is not defined in configuration the sum of the * {@link Currency#getMinorUnitDigits() minor unit digits} from the two currencies is returned. * * @return the number of digits in the FX rate */ public int getRateDigits() { Integer digits = CONFIGURED.get(this); if (digits != null) { return digits; } Integer inverseDigits = CONFIGURED.get(inverse()); if (inverseDigits != null) { return inverseDigits; } return base.getMinorUnitDigits() + counter.getMinorUnitDigits(); }
public void test_inverse() { CurrencyPair test = CurrencyPair.of(GBP, USD); assertEquals(test.inverse(), CurrencyPair.of(USD, GBP)); }
public void test_inverse_same() { CurrencyPair test = CurrencyPair.of(GBP, GBP); assertEquals(test.inverse(), CurrencyPair.of(GBP, GBP)); }
/** * Obtains an instance from currency pair, reference currency, reference date and sensitivity value. * <p> * The sensitivity currency is defaulted to be a currency of the currency pair that is not the reference currency. * * @param currencyPair the currency pair * @param referenceCurrency the reference currency * @param referenceDate the reference date * @param sensitivity the value of the sensitivity * @return the point sensitivity object */ public static FxForwardSensitivity of( CurrencyPair currencyPair, Currency referenceCurrency, LocalDate referenceDate, double sensitivity) { boolean inverse = referenceCurrency.equals(currencyPair.getCounter()); CurrencyPair pair = inverse ? currencyPair.inverse() : currencyPair; Currency sensitivityCurrency = pair.getCounter(); return new FxForwardSensitivity(currencyPair, referenceCurrency, referenceDate, sensitivityCurrency, sensitivity); }
public void test_volatility_inverse() { for (int i = 0; i < NB_EXPIRY; i++) { double expiryTime = VOLS.relativeTime(TEST_EXPIRY[i]); for (int j = 0; j < NB_STRIKE; ++j) { double volExpected = SMILE_TERM.volatility(expiryTime, TEST_STRIKE[j], FORWARD[i]); double volComputed = VOLS.volatility(CURRENCY_PAIR.inverse(), TEST_EXPIRY[i], 1d / TEST_STRIKE[j], 1d / FORWARD[i]); assertEquals(volComputed, volExpected, TOLERANCE); } } }
public void test_volatility_inverse() { for (int i = 0; i < NB_EXPIRY; i++) { double expiryTime = VOLS.relativeTime(TEST_EXPIRY[i]); for (int j = 0; j < NB_STRIKE; ++j) { double volExpected = SURFACE.zValue(expiryTime, TEST_STRIKE[j]); double volComputed = VOLS .volatility(CURRENCY_PAIR.inverse(), TEST_EXPIRY[i], 1d / TEST_STRIKE[j], 1d / FORWARD[i]); assertEquals(volComputed, volExpected, TOLERANCE); } } }
public void test_volatility_inverse() { for (int i = 0; i < NB_EXPIRY; i++) { double expiryTime = VOLS.relativeTime(TEST_EXPIRY[i]); for (int j = 0; j < NB_STRIKE; ++j) { double volExpected = CURVE.yValue(expiryTime); double volComputed = VOLS .volatility(CURRENCY_PAIR.inverse(), TEST_EXPIRY[i], 1d / TEST_STRIKE[j], 1d / FORWARD[i]); assertEquals(volComputed, volExpected, TOLERANCE); } } }
public void coverage() { BlackFxOptionSurfaceVolatilities test1 = BlackFxOptionSurfaceVolatilities.of(CURRENCY_PAIR, VAL_DATE_TIME, SURFACE); coverImmutableBean(test1); BlackFxOptionSurfaceVolatilities test2 = BlackFxOptionSurfaceVolatilities.of( CURRENCY_PAIR.inverse(), ZonedDateTime.of(2015, 12, 21, 11, 15, 0, 0, ZoneId.of("Z")), SURFACE); coverBeanEquals(test1, test2); }
public void coverage() { BlackFxOptionFlatVolatilities test1 = BlackFxOptionFlatVolatilities.of(CURRENCY_PAIR, VAL_DATE_TIME, CURVE); coverImmutableBean(test1); BlackFxOptionFlatVolatilities test2 = BlackFxOptionFlatVolatilities.of( CURRENCY_PAIR.inverse(), ZonedDateTime.of(2015, 12, 21, 11, 15, 0, 0, ZoneId.of("Z")), CURVE); coverBeanEquals(test1, test2); }
/** * Obtains an instance from the observation, reference currency and sensitivity value. * <p> * The sensitivity currency is defaulted to be the counter currency of queried currency pair. * * @param observation the rate observation, including the fixing date * @param referenceCurrency the reference currency * @param sensitivity the value of the sensitivity * @return the point sensitivity object */ public static FxIndexSensitivity of(FxIndexObservation observation, Currency referenceCurrency, double sensitivity) { CurrencyPair obsPair = observation.getCurrencyPair(); boolean inverse = referenceCurrency.equals(obsPair.getCounter()); CurrencyPair queriedPair = inverse ? obsPair.inverse() : obsPair; Currency sensiCurrency = queriedPair.getCounter(); return new FxIndexSensitivity(observation, referenceCurrency, sensiCurrency, sensitivity); }
public void coverage() { BlackFxOptionSmileVolatilities test1 = BlackFxOptionSmileVolatilities.of(NAME, CURRENCY_PAIR, VAL_DATE_TIME, SMILE_TERM); coverImmutableBean(test1); BlackFxOptionSmileVolatilities test2 = BlackFxOptionSmileVolatilities.of( FxOptionVolatilitiesName.of("Boo"), CURRENCY_PAIR.inverse(), ZonedDateTime.of(2015, 12, 21, 11, 15, 0, 0, ZoneId.of("Z")), SMILE_TERM); coverBeanEquals(test1, test2); }
if (isIdentity() || other.isIdentity() || this.equals(other) || this.equals(other.inverse())) { return Optional.empty();
public void test_parameterSensitivity_inverse() { for (int i = 0; i < NB_EXPIRY; i++) { for (int j = 0; j < NB_STRIKE; ++j) { double timeToExpiry = VOLS.relativeTime(TEST_EXPIRY[i]); FxOptionSensitivity sensi = FxOptionSensitivity.of( VOLS.getName(), CURRENCY_PAIR.inverse(), timeToExpiry, 1d / TEST_STRIKE[j], 1d / FORWARD[i], GBP, 1d); CurrencyParameterSensitivities computed = VOLS.parameterSensitivity(sensi); for (int k = 0; k < TIMES.size(); k++) { double value = computed.getSensitivities().get(0).getSensitivity().get(k); double nodeExpiry = TIMES.get(k); double expected = nodeSensitivity( VOLS, CURRENCY_PAIR.inverse(), TEST_EXPIRY[i], 1d / TEST_STRIKE[j], 1d / FORWARD[i], nodeExpiry); assertEquals(value, expected, EPS); } } } }
public void test_surfaceParameterSensitivity_inverse() { for (int i = 0; i < NB_EXPIRY; i++) { for (int j = 0; j < NB_STRIKE; ++j) { double timeToExpiry = VOLS.relativeTime(TEST_EXPIRY[i]); FxOptionSensitivity sensi = FxOptionSensitivity.of( VOLS.getName(), CURRENCY_PAIR.inverse(), timeToExpiry, 1d / TEST_STRIKE[j], 1d / FORWARD[i], GBP, 1d); CurrencyParameterSensitivity computed = VOLS.parameterSensitivity(sensi).getSensitivities().get(0); Iterator<ParameterMetadata> itr = computed.getParameterMetadata().iterator(); for (double value : computed.getSensitivity().toArray()) { FxVolatilitySurfaceYearFractionParameterMetadata meta = ((FxVolatilitySurfaceYearFractionParameterMetadata) itr.next()); double nodeExpiry = meta.getYearFraction(); double nodeDelta = meta.getStrike().getValue(); double expected = nodeSensitivity(VOLS, CURRENCY_PAIR.inverse(), TEST_EXPIRY[i], 1d / TEST_STRIKE[j], 1d / FORWARD[i], nodeExpiry, nodeDelta); assertEquals(value, expected, EPS); } } } }
public void test_nodeSensitivity_inverse() { for (int i = 0; i < NB_EXPIRY; i++) { for (int j = 0; j < NB_STRIKE; ++j) { double timeToExpiry = VOLS.relativeTime(TEST_EXPIRY[i]); FxOptionSensitivity sensi = FxOptionSensitivity.of( VOLS.getName(), CURRENCY_PAIR.inverse(), timeToExpiry, 1d / TEST_STRIKE[j], 1d / FORWARD[i], GBP, 1d); CurrencyParameterSensitivities computed = VOLS.parameterSensitivity(sensi); for (int k = 0; k < SURFACE.getParameterCount(); k++) { double value = computed.getSensitivities().get(0).getSensitivity().get(k); double nodeExpiry = SURFACE.getXValues().get(k); double nodeStrike = SURFACE.getYValues().get(k); double expected = nodeSensitivity(VOLS, CURRENCY_PAIR.inverse(), TEST_EXPIRY[i], 1d / TEST_STRIKE[j], 1d / FORWARD[i], nodeExpiry, nodeStrike); assertEquals(value, expected, EPS); } } } }