/// <summary>
/// Create a pay leg.
/// <para>
/// The pay leg created is periodic fixed rate payments without compounding.
/// The Ibor index is used to specify the payment frequency.
///
/// </para>
/// </summary>
/// <param name="index"> the Ibor index </param>
/// <param name="startDate"> the start date </param>
/// <param name="endDate"> the end date </param>
/// <param name="fixedRate"> the fixed rate </param>
/// <param name="notional"> the notional </param>
/// <param name="payRec"> pay or receive </param>
/// <returns> the instance </returns>
public static SwapLeg createFixedPayLegUnresolved(IborIndex index, LocalDate startDate, LocalDate endDate, double fixedRate, double notional, PayReceive payRec)
{
Frequency frequency = Frequency.of(index.Tenor.Period);
PeriodicSchedule accSchedule = PeriodicSchedule.of(startDate, endDate, frequency, BUSINESS_ADJ, StubConvention.NONE, RollConventions.NONE);
return(RateCalculationSwapLeg.builder().payReceive(payRec).accrualSchedule(accSchedule).calculation(FixedRateCalculation.of(fixedRate, ACT_360)).paymentSchedule(PaymentSchedule.builder().paymentFrequency(frequency).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(NotionalSchedule.of(CurrencyAmount.of(EUR, notional))).build());
}
public TestingIborIndexRates(IborIndex index, LocalDate valuationDate, LocalDateDoubleTimeSeries rates, LocalDateDoubleTimeSeries fixings, IborRateSensitivity sens)
{
this.index = index;
this.valuationDate = valuationDate;
this.rates = rates;
this.fixings = fixings;
this.sens = sens;
}
/// <summary>
/// Creates an Ibor cap/floor leg.
/// <para>
/// The Ibor index should be {@code EUR_EURIBOR_3M} or {@code EUR_EURIBOR_6M} to match the availability of the curve
/// data in <seealso cref="IborCapletFloorletDataSet"/>.
///
/// </para>
/// </summary>
/// <param name="index"> the index </param>
/// <param name="startDate"> the start date </param>
/// <param name="endDate"> the end date </param>
/// <param name="strikeSchedule"> the strike </param>
/// <param name="notionalSchedule"> the notional </param>
/// <param name="putCall"> cap or floor </param>
/// <param name="payRec"> pay or receive </param>
/// <returns> the instance </returns>
public static IborCapFloorLeg createCapFloorLegUnresolved(IborIndex index, LocalDate startDate, LocalDate endDate, ValueSchedule strikeSchedule, ValueSchedule notionalSchedule, PutCall putCall, PayReceive payRec)
{
Frequency frequency = Frequency.of(index.Tenor.Period);
PeriodicSchedule paySchedule = PeriodicSchedule.of(startDate, endDate, frequency, BUSINESS_ADJ, StubConvention.NONE, RollConventions.NONE);
IborRateCalculation rateCalculation = IborRateCalculation.of(index);
if (putCall.Call)
{
return(IborCapFloorLeg.builder().calculation(rateCalculation).capSchedule(strikeSchedule).notional(notionalSchedule).paymentSchedule(paySchedule).payReceive(payRec).build());
}
return(IborCapFloorLeg.builder().calculation(rateCalculation).floorSchedule(strikeSchedule).notional(notionalSchedule).paymentSchedule(paySchedule).payReceive(payRec).build());
}
//-------------------------------------------------------------------------
// calculates market quote bucketed PV01 for all scenarios
internal ScenarioArray <CurrencyParameterSensitivities> pv01MarketQuoteBucketed(ResolvedIborFutureOptionTrade trade, RatesScenarioMarketData ratesMarketData, IborFutureOptionScenarioMarketData optionMarketData)
{
IborIndex index = trade.Product.UnderlyingFuture.Index;
return(ScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01MarketQuoteBucketed(trade, ratesMarketData.scenario(i).ratesProvider(), optionMarketData.scenario(i).volatilities(index))));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "floatLeg") public void test_float_leg(FixedIborSwapConvention convention, com.opengamma.strata.basics.index.IborIndex floatLeg)
public virtual void test_float_leg(FixedIborSwapConvention convention, IborIndex floatLeg)
{
assertEquals(convention.FloatingLeg.Index, floatLeg);
}
// For vanilla swaps the holidays calendars on the fixed leg should be
// consistent with the maturity calendars on the floating leg
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "floatLeg") public void test_holiday_calendars_match(FixedIborSwapConvention convention, com.opengamma.strata.basics.index.IborIndex floatLeg)
public virtual void test_holiday_calendars_match(FixedIborSwapConvention convention, IborIndex floatLeg)
{
assertEquals(convention.FixedLeg.AccrualBusinessDayAdjustment.Calendar, floatLeg.MaturityDateOffset.Adjustment.Calendar);
}
//-------------------------------------------------------------------------
// calculates market quote bucketed PV01 for all scenarios
internal ScenarioArray <CurrencyParameterSensitivities> pv01RatesMarketQuoteBucketed(ResolvedCmsTrade trade, RatesScenarioMarketData ratesMarketData, SwaptionScenarioMarketData swaptionMarketData)
{
IborIndex index = cmsLegIborIndex(trade);
return(ScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01RatesMarketQuoteBucketed(trade, ratesMarketData.scenario(i).ratesProvider(), swaptionMarketData.scenario(i).volatilities(index))));
}
/// <summary>
/// Creates volatilities provider with specified date and index.
/// </summary>
/// <param name="valuationDate"> the valuation date </param>
/// <param name="index"> the index </param>
/// <returns> the volatilities provider </returns>
public static NormalIborCapletFloorletExpiryStrikeVolatilities createNormalVolatilities(ZonedDateTime valuationDate, IborIndex index)
{
return(NormalIborCapletFloorletExpiryStrikeVolatilities.of(index, valuationDate, NORMAL_SURFACE_EXP_STR));
}
//-------------------------------------------------------------------------
// build conventions
private static OvernightIborSwapConvention makeConvention(string name, OvernightIndex onIndex, IborIndex iborIndex, DayCount dayCount, Frequency frequency, int paymentLag, int cutOffDays, OvernightAccrualMethod accrual)
{
HolidayCalendarId calendarOn = onIndex.FixingCalendar;
DaysAdjustment paymentDateOffset = DaysAdjustment.ofBusinessDays(paymentLag, calendarOn);
return(ImmutableOvernightIborSwapConvention.of(name, OvernightRateSwapLegConvention.builder().index(onIndex).accrualMethod(accrual).accrualFrequency(frequency).paymentFrequency(frequency).paymentDateOffset(paymentDateOffset).stubConvention(StubConvention.SMART_INITIAL).rateCutOffDays(cutOffDays).build(), IborRateSwapLegConvention.of(iborIndex)));
}
//-------------------------------------------------------------------------
/// <summary>
/// Create a pay leg.
/// <para>
/// The pay leg created is periodic fixed rate payments without compounding.
/// The Ibor index is used to specify the payment frequency.
///
/// </para>
/// </summary>
/// <param name="index"> the Ibor index </param>
/// <param name="startDate"> the start date </param>
/// <param name="endDate"> the end date </param>
/// <param name="fixedRate"> the fixed rate </param>
/// <param name="notional"> the notional </param>
/// <param name="payRec"> pay or receive </param>
/// <returns> the instance </returns>
public static ResolvedSwapLeg createFixedPayLeg(IborIndex index, LocalDate startDate, LocalDate endDate, double fixedRate, double notional, PayReceive payRec)
{
SwapLeg leg = createFixedPayLegUnresolved(index, startDate, endDate, fixedRate, notional, payRec);
return(leg.resolve(REF_DATA));
}
//-------------------------------------------------------------------------
public virtual IborIndexRates iborIndexRates(IborIndex index)
{
throw new System.NotSupportedException();
}
// parse the row to a trade
private static FraTrade parseRow(CsvRow row, TradeInfo info, TradeCsvInfoResolver resolver)
{
BuySell buySell = LoaderUtils.parseBuySell(row.getValue(BUY_SELL_FIELD));
double notional = LoaderUtils.parseDouble(row.getValue(NOTIONAL_FIELD));
double fixedRate = LoaderUtils.parseDoublePercent(row.getValue(FIXED_RATE_FIELD));
Optional <FraConvention> conventionOpt = row.findValue(CONVENTION_FIELD).map(s => FraConvention.of(s));
Optional <Period> periodToStartOpt = row.findValue(PERIOD_TO_START_FIELD).map(s => LoaderUtils.parsePeriod(s));
Optional <LocalDate> startDateOpt = row.findValue(START_DATE_FIELD).map(s => LoaderUtils.parseDate(s));
Optional <LocalDate> endDateOpt = row.findValue(END_DATE_FIELD).map(s => LoaderUtils.parseDate(s));
Optional <IborIndex> indexOpt = row.findValue(INDEX_FIELD).map(s => IborIndex.of(s));
Optional <IborIndex> interpolatedOpt = row.findValue(INTERPOLATED_INDEX_FIELD).map(s => IborIndex.of(s));
Optional <DayCount> dayCountOpt = row.findValue(DAY_COUNT_FIELD).map(s => LoaderUtils.parseDayCount(s));
BusinessDayConvention dateCnv = row.findValue(DATE_ADJ_CNV_FIELD).map(s => LoaderUtils.parseBusinessDayConvention(s)).orElse(BusinessDayConventions.MODIFIED_FOLLOWING);
Optional <HolidayCalendarId> dateCalOpt = row.findValue(DATE_ADJ_CAL_FIELD).map(s => HolidayCalendarId.of(s));
// not parsing paymentDate, fixingDateOffset, discounting
// use convention if available
if (conventionOpt.Present)
{
if (indexOpt.Present || interpolatedOpt.Present || dayCountOpt.Present)
{
throw new System.ArgumentException("Fra trade had invalid combination of fields. When '" + CONVENTION_FIELD + "' is present these fields must not be present: " + ImmutableList.of(INDEX_FIELD, INTERPOLATED_INDEX_FIELD, DAY_COUNT_FIELD));
}
FraConvention convention = conventionOpt.get();
// explicit dates take precedence over relative ones
if (startDateOpt.Present && endDateOpt.Present)
{
if (periodToStartOpt.Present)
{
throw new System.ArgumentException("Fra trade had invalid combination of fields. When these fields are found " + ImmutableList.of(CONVENTION_FIELD, START_DATE_FIELD, END_DATE_FIELD) + " then these fields must not be present " + ImmutableList.of(PERIOD_TO_START_FIELD));
}
LocalDate startDate = startDateOpt.get();
LocalDate endDate = endDateOpt.get();
// NOTE: payment date assumed to be the start date
FraTrade trade = convention.toTrade(info, startDate, endDate, startDate, buySell, notional, fixedRate);
return(adjustTrade(trade, dateCnv, dateCalOpt));
}
// relative dates
if (periodToStartOpt.Present && info.TradeDate.Present)
{
if (startDateOpt.Present || endDateOpt.Present)
{
throw new System.ArgumentException("Fra trade had invalid combination of fields. When these fields are found " + ImmutableList.of(CONVENTION_FIELD, PERIOD_TO_START_FIELD, TRADE_DATE_FIELD) + " then these fields must not be present " + ImmutableList.of(START_DATE_FIELD, END_DATE_FIELD));
}
LocalDate tradeDate = info.TradeDate.get();
Period periodToStart = periodToStartOpt.get();
FraTrade trade = convention.createTrade(tradeDate, periodToStart, buySell, notional, fixedRate, resolver.ReferenceData);
trade = trade.toBuilder().info(info).build();
return(adjustTrade(trade, dateCnv, dateCalOpt));
}
}
else if (startDateOpt.Present && endDateOpt.Present && indexOpt.Present)
{
LocalDate startDate = startDateOpt.get();
LocalDate endDate = endDateOpt.get();
IborIndex index = indexOpt.get();
Fra.Builder builder = Fra.builder().buySell(buySell).notional(notional).startDate(startDate).endDate(endDate).fixedRate(fixedRate).index(index);
interpolatedOpt.ifPresent(interpolated => builder.indexInterpolated(interpolated));
dayCountOpt.ifPresent(dayCount => builder.dayCount(dayCount));
return(adjustTrade(FraTrade.of(info, builder.build()), dateCnv, dateCalOpt));
}
// no match
throw new System.ArgumentException("Fra trade had invalid combination of fields. These fields are mandatory:" + ImmutableList.of(BUY_SELL_FIELD, NOTIONAL_FIELD, FIXED_RATE_FIELD) + " and one of these combinations is mandatory: " + ImmutableList.of(CONVENTION_FIELD, TRADE_DATE_FIELD, PERIOD_TO_START_FIELD) + " or " + ImmutableList.of(CONVENTION_FIELD, START_DATE_FIELD, END_DATE_FIELD) + " or " + ImmutableList.of(START_DATE_FIELD, END_DATE_FIELD, INDEX_FIELD));
}
// fixed rate leg
private static SwapLeg iborLeg(LocalDate start, LocalDate end, IborIndex index, PayReceive payReceive, NotionalSchedule notional, StubConvention stubConvention)
{
Frequency freq = Frequency.of(index.Tenor.Period);
return(RateCalculationSwapLeg.builder().payReceive(payReceive).accrualSchedule(PeriodicSchedule.builder().startDate(start).endDate(end).frequency(freq).businessDayAdjustment(BDA_MF).stubConvention(stubConvention).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(freq).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(notional).calculation(IborRateCalculation.builder().index(index).fixingDateOffset(DaysAdjustment.ofBusinessDays(-2, index.FixingCalendar, BDA_P)).build()).build());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "flatLeg") public void test_flat_leg(IborIborSwapConvention convention, com.opengamma.strata.basics.index.IborIndex index)
public virtual void test_flat_leg(IborIborSwapConvention convention, IborIndex index)
{
assertEquals(convention.FlatLeg.Index, index);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "spreadLegIndex") public void test_float_leg(XCcyIborIborSwapConvention convention, com.opengamma.strata.basics.index.IborIndex index)
public virtual void test_float_leg(XCcyIborIborSwapConvention convention, IborIndex index)
{
assertEquals(convention.SpreadLeg.Index, index);
}
/// <summary>
/// Obtains a convention based on the specified index.
/// <para>
/// This uses the index name to find the matching convention.
/// By default, this will always return a convention, however configuration may be added
/// to restrict the conventions that are registered.
///
/// </para>
/// </summary>
/// <param name="index"> the index, from which the index name is used to find the matching convention </param>
/// <returns> the convention </returns>
/// <exception cref="IllegalArgumentException"> if no convention is registered for the index </exception>
public static FraConvention of(IborIndex index)
{
return(FraConvention.of(index));
}
//-------------------------------------------------------------------------
// calculates calibrated sum PV01 for all scenarios
internal MultiCurrencyScenarioArray pv01RatesCalibratedSum(ResolvedCmsTrade trade, RatesScenarioMarketData ratesMarketData, SwaptionScenarioMarketData swaptionMarketData)
{
IborIndex index = cmsLegIborIndex(trade);
return(MultiCurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01RatesCalibratedSum(trade, ratesMarketData.scenario(i).ratesProvider(), swaptionMarketData.scenario(i).volatilities(index))));
}
//-------------------------------------------------------------------------
// calculates unit price for all scenarios
internal DoubleScenarioArray unitPrice(ResolvedIborFutureOptionTrade trade, RatesScenarioMarketData ratesMarketData, IborFutureOptionScenarioMarketData optionMarketData)
{
IborIndex index = trade.Product.UnderlyingFuture.Index;
return(DoubleScenarioArray.of(ratesMarketData.ScenarioCount, i => unitPrice(trade, ratesMarketData.scenario(i).ratesProvider(), optionMarketData.scenario(i).volatilities(index))));
}
//-------------------------------------------------------------------------
/// <summary>
/// Creates an Ibor cap/floor leg.
/// <para>
/// The Ibor index should be {@code EUR_EURIBOR_3M} or {@code EUR_EURIBOR_6M} to match the availability of the curve
/// data in <seealso cref="IborCapletFloorletDataSet"/>.
///
/// </para>
/// </summary>
/// <param name="index"> the index </param>
/// <param name="startDate"> the start date </param>
/// <param name="endDate"> the end date </param>
/// <param name="strikeSchedule"> the strike </param>
/// <param name="notionalSchedule"> the notional </param>
/// <param name="putCall"> cap or floor </param>
/// <param name="payRec"> pay or receive </param>
/// <returns> the instance </returns>
public static ResolvedIborCapFloorLeg createCapFloorLeg(IborIndex index, LocalDate startDate, LocalDate endDate, ValueSchedule strikeSchedule, ValueSchedule notionalSchedule, PutCall putCall, PayReceive payRec)
{
IborCapFloorLeg leg = createCapFloorLegUnresolved(index, startDate, endDate, strikeSchedule, notionalSchedule, putCall, payRec);
return(leg.resolve(REF_DATA));
}
//-------------------------------------------------------------------------
// calculates calibrated sum PV01 for all scenarios
internal MultiCurrencyScenarioArray pv01CalibratedSum(ResolvedIborFutureOptionTrade trade, RatesScenarioMarketData ratesMarketData, IborFutureOptionScenarioMarketData optionMarketData)
{
IborIndex index = trade.Product.UnderlyingFuture.Index;
return(MultiCurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01CalibratedSum(trade, ratesMarketData.scenario(i).ratesProvider(), optionMarketData.scenario(i).volatilities(index))));
}
//-------------------------------------------------------------------------
// calculates calibrated sum PV01 for all scenarios
internal MultiCurrencyScenarioArray pv01RatesCalibratedSum(ResolvedIborCapFloorTrade trade, RatesScenarioMarketData ratesMarketData, IborCapFloorScenarioMarketData capFloorMarketData)
{
IborIndex index = trade.Product.CapFloorLeg.Index;
return(MultiCurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01RatesCalibratedSum(trade, ratesMarketData.scenario(i).ratesProvider(), capFloorMarketData.scenario(i).volatilities(index))));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "iborLeg") public void test_ibor_leg(OvernightIborSwapConvention convention, com.opengamma.strata.basics.index.IborIndex iborLeg)
public virtual void test_ibor_leg(OvernightIborSwapConvention convention, IborIndex iborLeg)
{
assertEquals(convention.IborLeg.Index, iborLeg);
}
/// <summary>
/// Creates shifted Black volatilities provider with specified date and index.
/// </summary>
/// <param name="valuationDate"> the valuation date </param>
/// <param name="index"> the index </param>
/// <returns> the volatilities provider </returns>
public static ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities createShiftedBlackVolatilities(ZonedDateTime valuationDate, IborIndex index)
{
return(ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities.of(index, valuationDate, SHIFTED_BLACK_SURFACE_EXP_STR, SHIFT_CURVE));
}
//-------------------------------------------------------------------------
// calculates calibrated bucketed PV01 for all scenarios
internal ScenarioArray <CurrencyParameterSensitivities> pv01RatesCalibratedBucketed(ResolvedSwaptionTrade trade, RatesScenarioMarketData ratesMarketData, SwaptionScenarioMarketData swaptionMarketData)
{
IborIndex index = trade.Product.Index;
return(ScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01RatesCalibratedBucketed(trade, ratesMarketData.scenario(i).ratesProvider(), swaptionMarketData.scenario(i).volatilities(index))));
}
/// <summary>
/// Creates rates provider with specified valuation date and time series of the index.
/// </summary>
/// <param name="valuationDate"> the valuation date </param>
/// <param name="index"> the index </param>
/// <param name="timeSeries"> the time series </param>
/// <returns> the rates provider </returns>
public static ImmutableRatesProvider createRatesProvider(LocalDate valuationDate, IborIndex index, LocalDateDoubleTimeSeries timeSeries)
{
return(ImmutableRatesProvider.builder(valuationDate).discountCurves(ImmutableMap.of(EUR, DSC_CURVE)).indexCurves(ImmutableMap.of(EUR_EURIBOR_3M, FWD3_CURVE, EUR_EURIBOR_6M, FWD6_CURVE)).fxRateProvider(FxMatrix.empty()).timeSeries(index, timeSeries).build());
}
//-------------------------------------------------------------------------
// calculates present value for all scenarios
internal CurrencyScenarioArray presentValue(ResolvedSwaptionTrade trade, RatesScenarioMarketData ratesMarketData, SwaptionScenarioMarketData swaptionMarketData)
{
IborIndex index = trade.Product.Index;
return(CurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => presentValue(trade, ratesMarketData.scenario(i).ratesProvider(), swaptionMarketData.scenario(i).volatilities(index))));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "flatFloatingLeg") public void test_flat_floating_leg(ThreeLegBasisSwapConvention convention, com.opengamma.strata.basics.index.IborIndex index)
public virtual void test_flat_floating_leg(ThreeLegBasisSwapConvention convention, IborIndex index)
{
assertEquals(convention.FlatFloatingLeg.Index, index);
}
//-------------------------------------------------------------------------
// calculates calibrated bucketed PV01 for all scenarios
internal ScenarioArray <CurrencyParameterSensitivities> pv01RatesCalibratedBucketed(ResolvedIborCapFloorTrade trade, RatesScenarioMarketData ratesMarketData, IborCapFloorScenarioMarketData capFloorMarketData)
{
IborIndex index = trade.Product.CapFloorLeg.Index;
return(ScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01RatesCalibratedBucketed(trade, ratesMarketData.scenario(i).ratesProvider(), capFloorMarketData.scenario(i).volatilities(index))));
}
/// <summary>
/// Creates volatilities provider with specified date and index.
/// </summary>
/// <param name="valuationDate"> the valuation date </param>
/// <param name="index"> the index </param>
/// <returns> the volatilities provider </returns>
public static BlackIborCapletFloorletExpiryStrikeVolatilities createBlackVolatilities(ZonedDateTime valuationDate, IborIndex index)
{
return(BlackIborCapletFloorletExpiryStrikeVolatilities.of(index, valuationDate, BLACK_SURFACE_EXP_STR));
}
