// calculate the last fixing date
private LocalDate calculateLastFixingDate(LocalDate valuationDate, ReferenceData refData)
{
SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData);
SwapLeg inflationLeg = trade.Product.getLegs(SwapLegType.INFLATION).get(0);
ResolvedSwapLeg inflationLegExpanded = inflationLeg.resolve(refData);
IList <SwapPaymentPeriod> periods = inflationLegExpanded.PaymentPeriods;
int nbPeriods = periods.Count;
RatePaymentPeriod lastPeriod = (RatePaymentPeriod)periods[nbPeriods - 1];
IList <RateAccrualPeriod> accruals = lastPeriod.AccrualPeriods;
int nbAccruals = accruals.Count;
RateAccrualPeriod lastAccrual = accruals[nbAccruals - 1];
if (lastAccrual.RateComputation is InflationMonthlyRateComputation)
{
return(((InflationMonthlyRateComputation)lastAccrual.RateComputation).EndObservation.FixingMonth.atEndOfMonth());
}
if (lastAccrual.RateComputation is InflationInterpolatedRateComputation)
{
return(((InflationInterpolatedRateComputation)lastAccrual.RateComputation).EndSecondObservation.FixingMonth.atEndOfMonth());
}
if (lastAccrual.RateComputation is InflationEndMonthRateComputation)
{
return(((InflationEndMonthRateComputation)lastAccrual.RateComputation).EndObservation.FixingMonth.atEndOfMonth());
}
if (lastAccrual.RateComputation is InflationEndInterpolatedRateComputation)
{
return(((InflationEndInterpolatedRateComputation)lastAccrual.RateComputation).EndSecondObservation.FixingMonth.atEndOfMonth());
}
throw new System.ArgumentException("Rate computation type not supported for last fixing date of an inflation swap.");
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(enabled = true) public void log_normal_atm()
public virtual void log_normal_atm()
{
double beta = 0.50;
Surface betaSurface = ConstantSurface.of("Beta", beta).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).zValueType(ValueType.SABR_BETA).surfaceName("Beta").build());
double shift = 0.0000;
Surface shiftSurface = ConstantSurface.of("Shift", shift).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).surfaceName("Shift").build());
SabrParametersSwaptionVolatilities calibratedSmile = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, DATA_SPARSE, MULTICURVE, betaSurface, shiftSurface);
SabrParametersSwaptionVolatilities calibratedAtm = SABR_CALIBRATION.calibrateAlphaWithAtm(NAME_SABR, calibratedSmile, MULTICURVE, ATM_LOGNORMAL_SIMPLE, TENORS_SIMPLE, EXPIRIES_SIMPLE_2, INTERPOLATOR_2D);
int nbExp = EXPIRIES_SIMPLE_2.size();
int nbTenor = TENORS_SIMPLE.size();
for (int loopexpiry = 0; loopexpiry < nbExp; loopexpiry++)
{
for (int looptenor = 0; looptenor < nbTenor; looptenor++)
{
double tenor = TENORS_SIMPLE.get(looptenor).get(ChronoUnit.YEARS);
LocalDate expiry = EUR_FIXED_1Y_EURIBOR_6M.FloatingLeg.StartDateBusinessDayAdjustment.adjust(CALIBRATION_DATE.plus(EXPIRIES_SIMPLE_2.get(loopexpiry)), REF_DATA);
LocalDate effectiveDate = EUR_FIXED_1Y_EURIBOR_6M.calculateSpotDateFromTradeDate(expiry, REF_DATA);
LocalDate endDate = effectiveDate.plus(TENORS_SIMPLE.get(looptenor));
SwapTrade swap = EUR_FIXED_1Y_EURIBOR_6M.toTrade(CALIBRATION_DATE, effectiveDate, endDate, BuySell.BUY, 1.0, 0.0);
double parRate = SWAP_PRICER.parRate(swap.resolve(REF_DATA).Product, MULTICURVE);
ZonedDateTime expiryDateTime = expiry.atTime(11, 0).atZone(ZoneId.of("Europe/Berlin"));
double time = calibratedAtm.relativeTime(expiryDateTime);
double volBlack = calibratedAtm.volatility(expiryDateTime, tenor, parRate, parRate);
double priceComputed = calibratedAtm.price(time, tenor, PutCall.CALL, parRate, parRate, volBlack);
double priceBlack = BlackFormulaRepository.price(parRate, parRate, time, DATA_LOGNORMAL_ATM_SIMPLE[looptenor + loopexpiry * nbTenor], true);
assertEquals(priceComputed, priceBlack, TOLERANCE_PRICE_CALIBRATION_ROOT);
}
}
}
//-------------------------------------------------------------------------
public Trade parseTrade(FpmlDocument document, XmlElement tradeEl)
{
// supported elements:
// 'swapStream+'
// 'swapStream/buyerPartyReference'
// 'swapStream/sellerPartyReference'
// 'swapStream/calculationPeriodDates'
// 'swapStream/paymentDates'
// 'swapStream/resetDates?'
// 'swapStream/calculationPeriodAmount'
// 'swapStream/stubCalculationPeriodAmount?'
// 'swapStream/principalExchanges?'
// 'swapStream/calculationPeriodAmount/knownAmountSchedule'
// ignored elements:
// 'Product.model?'
// 'swapStream/cashflows?'
// 'swapStream/settlementProvision?'
// 'swapStream/formula?'
// 'earlyTerminationProvision?'
// 'cancelableProvision?'
// 'extendibleProvision?'
// 'additionalPayment*'
// 'additionalTerms?'
// rejected elements:
// 'swapStream/calculationPeriodAmount/calculation/fxLinkedNotionalSchedule'
// 'swapStream/calculationPeriodAmount/calculation/futureValueNotional'
TradeInfoBuilder tradeInfoBuilder = document.parseTradeInfo(tradeEl);
Swap swap = parseSwap(document, tradeEl, tradeInfoBuilder);
return(SwapTrade.builder().info(tradeInfoBuilder.build()).product(swap).build());
}
private const double TOLERANCE_PRICE_CALIBRATION_LS = 5.0E-4; // Calibration Least Square; result not exact
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void normal_cube()
public virtual void normal_cube()
{
double beta = 0.50;
Surface betaSurface = ConstantSurface.of("Beta", beta).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).zValueType(ValueType.SABR_BETA).surfaceName("Beta").build());
double shift = 0.0300;
Surface shiftSurface = ConstantSurface.of("Shift", shift).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).surfaceName("Shift").build());
SabrParametersSwaptionVolatilities calibrated = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, DATA_SPARSE, MULTICURVE, betaSurface, shiftSurface);
for (int looptenor = 0; looptenor < TENORS.size(); looptenor++)
{
double tenor = TENORS.get(looptenor).get(ChronoUnit.YEARS);
for (int loopexpiry = 0; loopexpiry < EXPIRIES.size(); loopexpiry++)
{
LocalDate expiry = EUR_FIXED_1Y_EURIBOR_6M.FloatingLeg.StartDateBusinessDayAdjustment.adjust(CALIBRATION_DATE.plus(EXPIRIES.get(loopexpiry)), REF_DATA);
LocalDate effectiveDate = EUR_FIXED_1Y_EURIBOR_6M.calculateSpotDateFromTradeDate(expiry, REF_DATA);
LocalDate endDate = effectiveDate.plus(TENORS.get(looptenor));
SwapTrade swap = EUR_FIXED_1Y_EURIBOR_6M.toTrade(CALIBRATION_DATE, effectiveDate, endDate, BuySell.BUY, 1.0, 0.0);
double parRate = SWAP_PRICER.parRate(swap.resolve(REF_DATA).Product, MULTICURVE);
ZonedDateTime expiryDateTime = expiry.atTime(11, 0).atZone(ZoneId.of("Europe/Berlin"));
double time = calibrated.relativeTime(expiryDateTime);
for (int loopmoney = 0; loopmoney < MONEYNESS.size(); loopmoney++)
{
if (!double.IsNaN(DATA_ARRAY_SPARSE[looptenor][loopexpiry][loopmoney]))
{
double strike = parRate + MONEYNESS.get(loopmoney);
double volBlack = calibrated.volatility(expiryDateTime, tenor, strike, parRate);
double priceComputed = BlackFormulaRepository.price(parRate + shift, parRate + MONEYNESS.get(loopmoney) + shift, time, volBlack, true);
double priceNormal = NormalFormulaRepository.price(parRate, parRate + MONEYNESS.get(loopmoney), time, DATA_ARRAY_SPARSE[looptenor][loopexpiry][loopmoney], PutCall.CALL);
assertEquals(priceComputed, priceNormal, TOLERANCE_PRICE_CALIBRATION_LS);
}
}
}
}
}
// variable notional
private static SwapTrade parseVariableNotional(SwapTrade trade, IList <CsvRow> variableRows)
{
// parse notionals
ImmutableList.Builder <ValueStep> stepBuilder = ImmutableList.builder();
foreach (CsvRow row in variableRows)
{
LocalDate date = LoaderUtils.parseDate(row.getValue(START_DATE_FIELD));
row.findValue(NOTIONAL_FIELD).map(str => LoaderUtils.parseDouble(str)).ifPresent(notional => stepBuilder.add(ValueStep.of(date, ValueAdjustment.ofReplace(notional))));
}
ImmutableList <ValueStep> varNotionals = stepBuilder.build();
if (varNotionals.Empty)
{
return(trade);
}
// adjust the trade, inserting the variable notionals
ImmutableList.Builder <SwapLeg> legBuilder = ImmutableList.builder();
foreach (SwapLeg swapLeg in trade.Product.Legs)
{
RateCalculationSwapLeg leg = (RateCalculationSwapLeg)swapLeg;
NotionalSchedule notionalSchedule = leg.NotionalSchedule.toBuilder().amount(ValueSchedule.of(leg.NotionalSchedule.Amount.InitialValue, varNotionals)).build();
legBuilder.add(leg.toBuilder().notionalSchedule(notionalSchedule).build());
}
return(replaceLegs(trade, legBuilder.build()));
}
// variable fixed rate
private static SwapTrade parseVariableRates(SwapTrade trade, IList <CsvRow> variableRows)
{
ImmutableList.Builder <ValueStep> stepBuilder = ImmutableList.builder();
foreach (CsvRow row in variableRows)
{
LocalDate date = LoaderUtils.parseDate(row.getValue(START_DATE_FIELD));
row.findValue(FIXED_RATE_FIELD).map(str => LoaderUtils.parseDoublePercent(str)).ifPresent(fixedRate => stepBuilder.add(ValueStep.of(date, ValueAdjustment.ofReplace(fixedRate))));
}
ImmutableList <ValueStep> varRates = stepBuilder.build();
if (varRates.Empty)
{
return(trade);
}
// adjust the trade, inserting the variable rates
ImmutableList.Builder <SwapLeg> legBuilder = ImmutableList.builder();
foreach (SwapLeg swapLeg in trade.Product.Legs)
{
RateCalculationSwapLeg leg = (RateCalculationSwapLeg)swapLeg;
if (leg.Calculation is FixedRateCalculation)
{
FixedRateCalculation baseCalc = (FixedRateCalculation)leg.Calculation;
FixedRateCalculation calc = baseCalc.toBuilder().rate(ValueSchedule.of(baseCalc.Rate.InitialValue, varRates)).build();
legBuilder.add(leg.toBuilder().calculation(calc).build());
}
else
{
legBuilder.add(leg);
}
}
return(replaceLegs(trade, legBuilder.build()));
}
private SwapTrade getMtmTrade(bool initialExchange, bool intermediateExchange, bool finalExchange, double?initialNotional)
{
SwapLeg payLeg = RateCalculationSwapLeg.builder().payReceive(PAY).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 1, 24)).endDate(LocalDate.of(2016, 1, 24)).frequency(P3M).businessDayAdjustment(BDA_MF).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(P3M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(NotionalSchedule.builder().finalExchange(finalExchange).initialExchange(initialExchange).amount(ValueSchedule.of(NOTIONAL_EUR)).currency(EUR).build()).calculation(IborRateCalculation.builder().index(EUR_EURIBOR_3M).fixingDateOffset(DaysAdjustment.ofBusinessDays(-2, CalendarUSD.NYC, BDA_P)).spread(ValueSchedule.of(0.0020)).build()).build();
SwapLeg receiveLeg = RateCalculationSwapLeg.builder().payReceive(RECEIVE).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 1, 24)).endDate(LocalDate.of(2016, 1, 24)).frequency(P3M).businessDayAdjustment(BDA_MF).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(P3M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(NotionalSchedule.builder().finalExchange(finalExchange).initialExchange(initialExchange).intermediateExchange(intermediateExchange).amount(ValueSchedule.of(NOTIONAL_USD)).currency(USD).fxReset(FxResetCalculation.builder().fixingDateOffset(DaysAdjustment.ofBusinessDays(-2, CalendarUSD.NYC, BDA_P)).referenceCurrency(EUR).index(EUR_USD_WM).initialNotionalValue(initialNotional).build()).build()).calculation(IborRateCalculation.builder().index(USD_LIBOR_3M).fixingDateOffset(DaysAdjustment.ofBusinessDays(-2, CalendarUSD.NYC, BDA_P)).build()).build();
return(SwapTrade.builder().info(TradeInfo.builder().tradeDate(LocalDate.of(2014, 9, 10)).build()).product(Swap.of(payLeg, receiveLeg)).build());
}
// create a cross-currency GBP libor 3m vs USD libor 3m swap with spread
private static Trade createXCcyGbpLibor3mVsUsdLibor3mSwap()
{
SwapLeg payLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.PAY).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 1, 24)).endDate(LocalDate.of(2021, 1, 24)).frequency(Frequency.P3M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.GBLO)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P3M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(NotionalSchedule.of(Currency.GBP, 61_600_000)).calculation(IborRateCalculation.of(IborIndices.GBP_LIBOR_3M)).build();
SwapLeg receiveLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.RECEIVE).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 1, 24)).endDate(LocalDate.of(2021, 1, 24)).frequency(Frequency.P3M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P3M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(NotionalSchedule.of(Currency.USD, 100_000_000)).calculation(IborRateCalculation.builder().index(IborIndices.USD_LIBOR_3M).spread(ValueSchedule.of(0.0091)).build()).build();
return(SwapTrade.builder().product(Swap.of(receiveLeg, payLeg)).info(TradeInfo.builder().id(StandardId.of("example", "14")).addAttribute(AttributeType.DESCRIPTION, "GBP Libor 3m vs USD Libor 3m").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 1, 24)).build()).build());
}
// create a cross-currency USD fixed vs GBP libor 3m swap with initial and final notional exchange
private static SwapTrade createNotionalExchangeSwap()
{
SwapLeg payLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.PAY).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 1, 24)).endDate(LocalDate.of(2021, 1, 24)).frequency(Frequency.P6M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.GBLO)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P6M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(NotionalSchedule.builder().currency(Currency.USD).amount(ValueSchedule.of(100_000_000)).initialExchange(true).finalExchange(true).build()).calculation(FixedRateCalculation.of(0.03, DayCounts.THIRTY_U_360)).build();
SwapLeg receiveLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.RECEIVE).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 1, 24)).endDate(LocalDate.of(2021, 1, 24)).frequency(Frequency.P3M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.GBLO)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P3M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(NotionalSchedule.builder().currency(Currency.GBP).amount(ValueSchedule.of(61_600_000)).initialExchange(true).finalExchange(true).build()).calculation(IborRateCalculation.of(IborIndices.GBP_LIBOR_3M)).build();
return(SwapTrade.builder().product(Swap.of(payLeg, receiveLeg)).info(TradeInfo.builder().id(StandardId.of("example", "16")).addAttribute(AttributeType.DESCRIPTION, "USD fixed vs GBP Libor 3m (notional exchange)").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 1, 24)).build()).build());
}
/// <summary>
/// Parses from the CSV row.
/// </summary>
/// <param name="row"> the CSV row </param>
/// <param name="info"> the trade info </param>
/// <param name="resolver"> the resolver used to parse additional information </param>
/// <returns> the parsed trade </returns>
internal static SwapTrade parse(CsvRow row, IList <CsvRow> variableRows, TradeInfo info, TradeCsvInfoResolver resolver)
{
SwapTrade trade = parseRow(row, info, resolver);
trade = parseVariableNotional(trade, variableRows);
trade = parseVariableRates(trade, variableRows);
return(resolver.completeTrade(row, trade));
}
// Create a fixed vs libor 6m swap
private static Trade createInterpolatedStub4mFixedVsLibor6mSwap()
{
NotionalSchedule notional = NotionalSchedule.of(Currency.USD, 100_000_000);
SwapLeg payLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.PAY).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 9, 12)).endDate(LocalDate.of(2016, 7, 12)).frequency(Frequency.P6M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).stubConvention(StubConvention.SHORT_INITIAL).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P6M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(notional).calculation(IborRateCalculation.builder().index(IborIndices.USD_LIBOR_6M).initialStub(IborRateStubCalculation.ofIborInterpolatedRate(IborIndices.USD_LIBOR_3M, IborIndices.USD_LIBOR_6M)).build()).build();
SwapLeg receiveLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.RECEIVE).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 9, 12)).endDate(LocalDate.of(2016, 7, 12)).stubConvention(StubConvention.SHORT_INITIAL).frequency(Frequency.P6M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P6M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(notional).calculation(FixedRateCalculation.of(0.01, DayCounts.THIRTY_U_360)).build();
return(SwapTrade.builder().product(Swap.of(payLeg, receiveLeg)).info(TradeInfo.builder().id(StandardId.of("example", "9")).addAttribute(AttributeType.DESCRIPTION, "Fixed vs Libor 6m (interpolated 4m short initial stub)").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 9, 12)).build()).build());
}
// Create a compounding fixed vs fed funds swap
private static Trade createCompoundingFixedVsFedFundsSwap()
{
NotionalSchedule notional = NotionalSchedule.of(Currency.USD, 100_000_000);
SwapLeg payLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.PAY).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 2, 5)).endDate(LocalDate.of(2014, 4, 7)).frequency(Frequency.TERM).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.TERM).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(notional).calculation(FixedRateCalculation.of(0.00123, DayCounts.ACT_360)).build();
SwapLeg receiveLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.RECEIVE).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 2, 5)).endDate(LocalDate.of(2014, 4, 7)).frequency(Frequency.TERM).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).stubConvention(StubConvention.SHORT_INITIAL).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.TERM).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(notional).calculation(OvernightRateCalculation.of(OvernightIndices.USD_FED_FUND)).build();
return(SwapTrade.builder().product(Swap.of(payLeg, receiveLeg)).info(TradeInfo.builder().id(StandardId.of("example", "11")).addAttribute(AttributeType.DESCRIPTION, "Compounding fixed vs fed funds").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 2, 5)).build()).build());
}
// Create a compounding libor 6m vs libor 3m swap
private static Trade createCompoundingLibor6mVsLibor3mSwap()
{
NotionalSchedule notional = NotionalSchedule.of(Currency.USD, 100_000_000);
SwapLeg payLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.PAY).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 8, 27)).endDate(LocalDate.of(2024, 8, 27)).frequency(Frequency.P6M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P6M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(notional).calculation(IborRateCalculation.of(IborIndices.USD_LIBOR_6M)).build();
SwapLeg receiveLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.RECEIVE).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 8, 27)).endDate(LocalDate.of(2024, 8, 27)).frequency(Frequency.P3M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P6M).paymentDateOffset(DaysAdjustment.NONE).compoundingMethod(CompoundingMethod.STRAIGHT).build()).notionalSchedule(notional).calculation(IborRateCalculation.of(IborIndices.USD_LIBOR_3M)).build();
return(SwapTrade.builder().product(Swap.of(payLeg, receiveLeg)).info(TradeInfo.builder().id(StandardId.of("example", "13")).addAttribute(AttributeType.DESCRIPTION, "Compounding libor 6m vs libor 3m").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 8, 27)).build()).build());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "stubOn") public void test_stub_overnight(OvernightIborSwapConvention convention, com.opengamma.strata.basics.date.Tenor tenor)
public virtual void test_stub_overnight(OvernightIborSwapConvention convention, Tenor tenor)
{
LocalDate tradeDate = LocalDate.of(2015, 10, 20);
SwapTrade swap = convention.createTrade(tradeDate, tenor, BuySell.BUY, 1, 0.01, REF_DATA);
ResolvedSwap swapResolved = swap.Product.resolve(REF_DATA);
LocalDate endDate = swapResolved.getLeg(PayReceive.PAY).get().EndDate;
assertTrue(endDate.isAfter(tradeDate.plus(tenor).minusDays(7)));
assertTrue(endDate.isBefore(tradeDate.plus(tenor).plusDays(7)));
}
// Create an overnight averaged vs libor 3m swap with spread
private static Trade createOvernightAveragedWithSpreadVsLibor3mSwap()
{
NotionalSchedule notional = NotionalSchedule.of(Currency.USD, 100_000_000);
SwapLeg payLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.PAY).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 9, 12)).endDate(LocalDate.of(2020, 9, 12)).frequency(Frequency.P3M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P3M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(notional).calculation(IborRateCalculation.of(IborIndices.USD_LIBOR_3M)).build();
SwapLeg receiveLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.RECEIVE).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 9, 12)).endDate(LocalDate.of(2020, 9, 12)).frequency(Frequency.P3M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P3M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(notional).calculation(OvernightRateCalculation.builder().dayCount(DayCounts.ACT_360).index(OvernightIndices.USD_FED_FUND).accrualMethod(OvernightAccrualMethod.AVERAGED).spread(ValueSchedule.of(0.0025)).build()).build();
return(SwapTrade.builder().product(Swap.of(payLeg, receiveLeg)).info(TradeInfo.builder().id(StandardId.of("example", "3")).addAttribute(AttributeType.DESCRIPTION, "Fed Funds averaged + spread vs Libor 3m").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 9, 12)).build()).build());
}
public virtual void test_trade()
{
ThreeLegBasisSwapCurveNode node = ThreeLegBasisSwapCurveNode.of(TEMPLATE, QUOTE_ID, SPREAD);
double rate = 0.125;
double quantity = -1234.56;
MarketData marketData = ImmutableMarketData.builder(VAL_DATE).addValue(QUOTE_ID, rate).build();
SwapTrade trade = node.trade(quantity, marketData, REF_DATA);
SwapTrade expected = TEMPLATE.createTrade(VAL_DATE, BUY, -quantity, rate + SPREAD, REF_DATA);
assertEquals(trade, expected);
}
public virtual void test_trade()
{
XCcyIborIborSwapCurveNode node = XCcyIborIborSwapCurveNode.of(TEMPLATE, SPREAD_ID, SPREAD_ADJ);
double quantity = -1234.56;
SwapTrade trade = node.trade(quantity, MARKET_DATA, REF_DATA);
double rate = FX_EUR_USD.fxRate(Currency.EUR, Currency.USD);
SwapTrade expected = TEMPLATE.createTrade(VAL_DATE, BUY, -quantity, rate, SPREAD_XCS + SPREAD_ADJ, REF_DATA);
assertEquals(trade, expected);
assertEquals(node.resolvedTrade(quantity, MARKET_DATA, REF_DATA), trade.resolve(REF_DATA));
}
//-------------------------------------------------------------------------
public virtual void test_createTrade()
{
ThreeLegBasisSwapTemplate @base = ThreeLegBasisSwapTemplate.of(Period.ofMonths(3), TENOR_10Y, CONV);
LocalDate tradeDate = LocalDate.of(2015, 5, 5);
LocalDate startDate = date(2015, 8, 7);
LocalDate endDate = date(2025, 8, 7);
SwapTrade test = @base.createTrade(tradeDate, BUY, NOTIONAL_2M, 0.25d, REF_DATA);
Swap expected = Swap.of(FIXED.toLeg(startDate, endDate, PAY, NOTIONAL_2M, 0.25d), IBOR3M.toLeg(startDate, endDate, PAY, NOTIONAL_2M), IBOR6M.toLeg(startDate, endDate, RECEIVE, NOTIONAL_2M));
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
public virtual void test_toTrade_dates()
{
FixedOvernightSwapConvention @base = ImmutableFixedOvernightSwapConvention.of(NAME, FIXED, FFUND_LEG, PLUS_TWO_DAYS);
LocalDate tradeDate = LocalDate.of(2015, 5, 5);
LocalDate startDate = date(2015, 8, 5);
LocalDate endDate = date(2015, 11, 5);
SwapTrade test = @base.toTrade(tradeDate, startDate, endDate, BUY, NOTIONAL_2M, 0.25d);
Swap expected = Swap.of(FIXED.toLeg(startDate, endDate, PAY, NOTIONAL_2M, 0.25d), FFUND_LEG.toLeg(startDate, endDate, RECEIVE, NOTIONAL_2M));
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
//-------------------------------------------------------------------------
public virtual void test_toTrade_dates()
{
ImmutableFixedInflationSwapConvention @base = ImmutableFixedInflationSwapConvention.of(NAME, FIXED, INFL, PLUS_ONE_DAY);
LocalDate tradeDate = LocalDate.of(2015, 5, 5);
LocalDate startDate = date(2015, 8, 5);
LocalDate endDate = date(2017, 8, 5);
SwapTrade test = @base.toTrade(tradeDate, startDate, endDate, BUY, NOTIONAL_2M, 0.25d);
Swap expected = Swap.of(FIXED.toLeg(startDate, endDate, PAY, NOTIONAL_2M, 0.25d), INFL.toLeg(startDate, endDate, RECEIVE, NOTIONAL_2M));
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
public virtual void test_toTrade_periodTenor()
{
ImmutableXCcyIborIborSwapConvention @base = ImmutableXCcyIborIborSwapConvention.of(NAME, EUR3M, USD3M, PLUS_TWO_DAYS);
LocalDate tradeDate = LocalDate.of(2015, 5, 5);
LocalDate startDate = date(2015, 8, 7);
LocalDate endDate = date(2025, 8, 7);
SwapTrade test = @base.createTrade(tradeDate, Period.ofMonths(3), TENOR_10Y, BUY, NOTIONAL_2M, NOTIONAL_2M * FX_EUR_USD, 0.25d, REF_DATA);
Swap expected = Swap.of(EUR3M.toLeg(startDate, endDate, PAY, NOTIONAL_2M, 0.25d), USD3M.toLeg(startDate, endDate, RECEIVE, NOTIONAL_2M * FX_EUR_USD));
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
public virtual void test_trade()
{
FixedInflationSwapCurveNode node = FixedInflationSwapCurveNode.of(TEMPLATE, QUOTE_ID, SPREAD);
LocalDate tradeDate = LocalDate.of(2015, 1, 22);
double rate = 0.125;
double quantity = -1234.56;
MarketData marketData = ImmutableMarketData.builder(tradeDate).addValue(QUOTE_ID, rate).build();
SwapTrade trade = node.trade(quantity, marketData, REF_DATA);
SwapTrade expected = TEMPLATE.createTrade(tradeDate, BUY, -quantity, rate + SPREAD, REF_DATA);
assertEquals(trade, expected);
}
//-------------------------------------------------------------------------
public virtual void test_createTrade()
{
XCcyIborIborSwapTemplate @base = XCcyIborIborSwapTemplate.of(Period.ofMonths(3), TENOR_10Y, CONV);
LocalDate tradeDate = LocalDate.of(2015, 5, 5);
LocalDate startDate = date(2015, 8, 7);
LocalDate endDate = date(2025, 8, 7);
SwapTrade test = @base.createTrade(tradeDate, BUY, NOTIONAL_2M, NOTIONAL_2M * FX_EUR_USD, 0.25d, REF_DATA);
Swap expected = Swap.of(EUR3M.toLeg(startDate, endDate, PAY, NOTIONAL_2M, 0.25d), USD3M.toLeg(startDate, endDate, RECEIVE, NOTIONAL_2M * FX_EUR_USD));
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
public virtual void test_toTrade_dates()
{
ImmutableXCcyIborIborSwapConvention @base = ImmutableXCcyIborIborSwapConvention.of(NAME, EUR3M, USD3M, PLUS_TWO_DAYS);
LocalDate tradeDate = LocalDate.of(2015, 5, 5);
LocalDate startDate = date(2015, 8, 5);
LocalDate endDate = date(2015, 11, 5);
SwapTrade test = @base.toTrade(tradeDate, startDate, endDate, BUY, NOTIONAL_2M, NOTIONAL_2M * FX_EUR_USD, 0.25d);
Swap expected = Swap.of(EUR3M.toLeg(startDate, endDate, PAY, NOTIONAL_2M, 0.25d), USD3M.toLeg(startDate, endDate, RECEIVE, NOTIONAL_2M * FX_EUR_USD));
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
//-------------------------------------------------------------------------
public virtual void test_toTrade_tenor()
{
FixedIborSwapConvention @base = ImmutableFixedIborSwapConvention.of(NAME, FIXED, IBOR);
LocalDate tradeDate = LocalDate.of(2015, 5, 5);
LocalDate startDate = date(2015, 5, 7);
LocalDate endDate = date(2025, 5, 7);
SwapTrade test = @base.createTrade(tradeDate, TENOR_10Y, BUY, NOTIONAL_2M, 0.25d, REF_DATA);
Swap expected = Swap.of(FIXED.toLeg(startDate, endDate, PAY, NOTIONAL_2M, 0.25d), IBOR.toLeg(startDate, endDate, RECEIVE, NOTIONAL_2M));
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
//-------------------------------------------------------------------------
public virtual void test_toTrade_tenor()
{
OvernightIborSwapConvention @base = ImmutableOvernightIborSwapConvention.of(NAME, FFUND_LEG, USD_LIBOR_3M_LEG, PLUS_TWO_DAYS);
LocalDate tradeDate = LocalDate.of(2015, 5, 5);
LocalDate startDate = date(2015, 5, 7);
LocalDate endDate = date(2025, 5, 7);
SwapTrade test = @base.createTrade(tradeDate, TENOR_10Y, BUY, NOTIONAL_2M, 0.25d, REF_DATA);
Swap expected = Swap.of(FFUND_LEG.toLeg(startDate, endDate, PAY, NOTIONAL_2M, 0.25d), USD_LIBOR_3M_LEG.toLeg(startDate, endDate, RECEIVE, NOTIONAL_2M));
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
public virtual void test_toTrade_periodTenor()
{
ThreeLegBasisSwapConvention @base = ImmutableThreeLegBasisSwapConvention.of(NAME, FIXED, IBOR6M, IBOR12M);
LocalDate tradeDate = LocalDate.of(2015, 5, 5);
LocalDate startDate = date(2015, 8, 7);
LocalDate endDate = date(2025, 8, 7);
SwapTrade test = @base.createTrade(tradeDate, Period.ofMonths(3), TENOR_10Y, BUY, NOTIONAL_2M, 0.25d, REF_DATA);
Swap expected = Swap.of(FIXED.toLeg(startDate, endDate, PAY, NOTIONAL_2M, 0.25d), IBOR6M.toLeg(startDate, endDate, PAY, NOTIONAL_2M), IBOR12M.toLeg(startDate, endDate, RECEIVE, NOTIONAL_2M));
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
public virtual void test_toTrade_dates()
{
ThreeLegBasisSwapConvention @base = ImmutableThreeLegBasisSwapConvention.of(NAME, FIXED, IBOR6M, IBOR12M);
LocalDate tradeDate = LocalDate.of(2015, 5, 5);
LocalDate startDate = date(2015, 8, 5);
LocalDate endDate = date(2015, 11, 5);
SwapTrade test = @base.toTrade(tradeDate, startDate, endDate, BUY, NOTIONAL_2M, 0.25d);
Swap expected = Swap.of(FIXED.toLeg(startDate, endDate, PAY, NOTIONAL_2M, 0.25d), IBOR6M.toLeg(startDate, endDate, PAY, NOTIONAL_2M), IBOR12M.toLeg(startDate, endDate, RECEIVE, NOTIONAL_2M));
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
public virtual void test_toTrade_periodTenor()
{
FixedOvernightSwapConvention @base = ImmutableFixedOvernightSwapConvention.of(NAME, FIXED, FFUND_LEG, PLUS_TWO_DAYS);
LocalDate tradeDate = LocalDate.of(2015, 5, 5);
LocalDate startDate = date(2015, 8, 7);
LocalDate endDate = date(2025, 8, 7);
SwapTrade test = @base.createTrade(tradeDate, Period.ofMonths(3), TENOR_10Y, BUY, NOTIONAL_2M, 0.25d, REF_DATA);
Swap expected = Swap.of(FIXED.toLeg(startDate, endDate, PAY, NOTIONAL_2M, 0.25d), FFUND_LEG.toLeg(startDate, endDate, RECEIVE, NOTIONAL_2M));
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
//-------------------------------------------------------------------------
public SwapTrade toTrade(TradeInfo tradeInfo, LocalDate startDate, LocalDate endDate, BuySell buySell, double notional, double spread)
{
Optional <LocalDate> tradeDate = tradeInfo.TradeDate;
if (tradeDate.Present)
{
ArgChecker.inOrderOrEqual(tradeDate.get(), startDate, "tradeDate", "startDate");
}
SwapLeg leg1 = spreadLeg.toLeg(startDate, endDate, PayReceive.ofPay(buySell.Buy), notional, spread);
SwapLeg leg2 = flatLeg.toLeg(startDate, endDate, PayReceive.ofPay(buySell.Sell), notional);
return(SwapTrade.builder().info(tradeInfo).product(Swap.of(leg1, leg2)).build());
}
