public static Money GetFutureValue(CapFloor capFloor, string baseParty)
{
var list = new List <Money>();
InterestRateStream stream = capFloor.capFloorStream;
Money futureValueOfStream = CashflowsHelper.GetForecastValue(stream.cashflows);
list.AddRange(GetValue(stream.payerPartyReference.href, stream.receiverPartyReference.href, baseParty, futureValueOfStream));
Money futureValueOfAdditionalPayments = GetValueOfAdditionalPayments(capFloor, baseParty);
list.Add(futureValueOfAdditionalPayments);
return(MoneyHelper.Sum(list));
}
private static Cashflows GetCashfows(
InterestRateStream interestRateStream, CalculationPeriodsPrincipalExchangesAndStubs calculationPeriodsPrincipalExchangesAndStubs,
IBusinessCalendar paymentCalendar)
{
// Assign notionals, rates, cap/floor rate, etc
//
StreamCashflowsGenerator.UpdateCalculationPeriodsData(interestRateStream, calculationPeriodsPrincipalExchangesAndStubs);
List <PaymentCalculationPeriod> paymentCalculationPeriods = StreamCashflowsGenerator.GetPaymentCalculationPeriods(interestRateStream, calculationPeriodsPrincipalExchangesAndStubs, paymentCalendar);
Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(interestRateStream.calculationPeriodAmount);
UpdateNumberOfDaysAndYearFraction(paymentCalculationPeriods, calculation);
return(CashflowsFactory.Create(paymentCalculationPeriods, calculationPeriodsPrincipalExchangesAndStubs.GetAllPrincipalExchanges(), true));//TODO THe cashflowsmatch paraqmeter at the end could be a problem!
}
private static void SetEffectiveAndTerminationDates(InterestRateStream stream,
DateTime rawEffectiveDate,
DateTime rawTerminationDate,
string terminationDateBusinessDayAdjustments,
string terminationDateBusinessDayCalendar)
{
AdjustableDate effectiveDate = DateTypesHelper.ToAdjustableDate(rawEffectiveDate);
XsdClassesFieldResolver.CalculationPeriodDatesSetEffectiveDate(stream.calculationPeriodDates, effectiveDate);
AdjustableDate terminationDate = DateTypesHelper.ToAdjustableDate(rawTerminationDate, terminationDateBusinessDayAdjustments, terminationDateBusinessDayCalendar);
XsdClassesFieldResolver.CalculationPeriodDatesSetTerminationDate(stream.calculationPeriodDates, terminationDate);
}
/// <summary>
///
/// </summary>
/// <param name="leg1Parameters"></param>
/// <param name="leg2Parameters"></param>
/// <returns></returns>
public static Swap GenerateDefiniton(
SwapLegParametersRange leg1Parameters,
SwapLegParametersRange leg2Parameters)
{
InterestRateStream stream1 = InterestRateStreamParametricDefinitionGenerator.GenerateStreamDefinition(leg1Parameters);
InterestRateStreamHelper.SetPayerAndReceiver(stream1, leg1Parameters.Payer, leg1Parameters.Receiver);
InterestRateStream stream2 = InterestRateStreamParametricDefinitionGenerator.GenerateStreamDefinition(leg2Parameters);
InterestRateStreamHelper.SetPayerAndReceiver(stream2, leg2Parameters.Payer, leg2Parameters.Receiver);
return(SwapFactory.Create(stream1, stream2));
}
private static InterestRateStream GetCashflowsScheduleWithNotionalSchedule(
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
SwapLegParametersRange_Old legParametersRange,
NonNegativeAmountSchedule notionalSchedule)
{
InterestRateStream stream = InterestRateStreamParametricDefinitionGenerator.GenerateStreamDefinition(legParametersRange);
InterestRateStreamParametricDefinitionGenerator.SetNotionalSchedule(stream, notionalSchedule);
Cashflows cashflows = FixedAndFloatingRateStreamCashflowGenerator.GetCashflows(stream, fixingCalendar, paymentCalendar);
stream.cashflows = cashflows;
return(stream);
}
public static CapFloor GenerateDefiniton(CapFloorLegParametersRange_Old capFloorLeg,
Schedule spreadSchedule,
Schedule capOrFloorSchedule,
NonNegativeSchedule notionalSchedule)
{
InterestRateStream capFloorStream = InterestRateStreamParametricDefinitionGenerator.GenerateStreamDefinition(capFloorLeg);
InterestRateStreamHelper.SetPayerAndReceiver(capFloorStream, capFloorLeg.Payer, capFloorLeg.Receiver);
var capFloor = new CapFloor {
capFloorStream = capFloorStream
};
return(capFloor);
}
internal static Pair <ValuationResultRange, Swap> GetPriceAndGeneratedFpMLSwap(
ILogger logger,
ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
ValuationRange valuationRange,
TradeRange tradeRange,
SwapLegParametersRange_Old leg1ParametersRange,
List <DetailedCashflowRangeItem> leg1DetailedCashflowsList,
List <PrincipalExchangeCashflowRangeItem> leg1PrincipalExchangeCashflowList,
List <AdditionalPaymentRangeItem> leg1AdditionalPaymentList)
{
InterestRateStream stream1 = GetCashflowsSchedule(fixingCalendar, paymentCalendar, leg1ParametersRange);//parametric definiton + cashflows schedule
var swap = SwapFactory.Create(stream1);
// Update FpML cashflows
//
UpdateCashflowsWithDetailedCashflows(stream1.cashflows, leg1DetailedCashflowsList);
// Update PE
//
if (null != leg1PrincipalExchangeCashflowList)
{
CreatePrincipalExchangesFromListOfRanges(stream1.cashflows, leg1PrincipalExchangeCashflowList);
}
// Add bullet payments...
//
if (null != leg1AdditionalPaymentList)
{
swap.additionalPayment = leg1AdditionalPaymentList.Select(bulletPaymentRangeItem => new Payment
{
payerPartyReference = PartyReferenceFactory.Create(leg1ParametersRange.Payer),
receiverPartyReference = PartyReferenceFactory.Create(leg1ParametersRange.Receiver),
paymentAmount = MoneyHelper.GetNonNegativeAmount(bulletPaymentRangeItem.Amount),
paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(bulletPaymentRangeItem.PaymentDate)
}).ToArray();
}
// Update FpML cashflows with DF,FV,PV, etc (LegParametersRange needed to access curve functionality)
//
UpdateCashflowsWithAmounts(logger, cache, nameSpace, stream1, leg1ParametersRange, valuationRange);
// Update additional payments
//
var leg1DiscountCurve = CurveLoader.LoadInterestRateCurve(logger, cache, nameSpace, leg1ParametersRange.DiscountCurve);
SwapGenerator.UpdatePaymentsAmounts(logger, cache, nameSpace, swap, leg1ParametersRange, leg1DiscountCurve, valuationRange.ValuationDate, paymentCalendar);
//~ Update additional payments
string baseParty = valuationRange.BaseParty;
return(new Pair <ValuationResultRange, Swap>(CreateValuationRange(swap, baseParty), swap));
}
public static void UpdateStreamCashflowsAmounts(SwapLegParametersRange_Old legParameters,
InterestRateStream stream,
ISwapLegEnvironment marketEnvironment,
DateTime valuationDate)
{
IRateCurve forecastCurve = null;
if (!String.IsNullOrEmpty(legParameters.ForecastCurve))
{
forecastCurve = marketEnvironment.GetForecastRateCurve();
}
IRateCurve discountingCurve = marketEnvironment.GetDiscountRateCurve();
FixedAndFloatingRateStreamCashflowGenerator.UpdateCashflowsAmounts(stream, forecastCurve, discountingCurve, valuationDate);
}
public static InterestRateStream GenerateStreamDefinition(CapFloorLegParametersRange legParametersRange)
{
InterestRateStream stream = GenerateCapFloorStreamDefinition(legParametersRange);
// Payer/Receiver references
//
stream.payerPartyReference = PartyReferenceFactory.Create(legParametersRange.Payer);
stream.receiverPartyReference = PartyReferenceFactory.Create(legParametersRange.Receiver);
// Principal exchanges
//
stream.principalExchanges = new PrincipalExchanges();
stream.principalExchanges.initialExchange =
stream.principalExchanges.finalExchange =
stream.principalExchanges.intermediateExchange = legParametersRange.GeneratePrincipalExchanges;
return(stream);
}
public static Money GetPayFutureValue(CapFloor capFloor, string baseParty)
{
var list = new List <Money>();
InterestRateStream stream = capFloor.capFloorStream;
{
Money presentValueOfStream = CashflowsHelper.GetForecastValue(stream.cashflows);
if (baseParty == stream.payerPartyReference.href)
{
list.Add(presentValueOfStream);
}
}
Money payFutureValueOfAdditionalPayments = GetPayFutureValueOfAdditionalPayments(capFloor, baseParty);
list.Add(payFutureValueOfAdditionalPayments);
return(MoneyHelper.Sum(list));
}
private static void UpdateCashflowsWithAmounts(ILogger logger, ICoreCache cache,
String nameSpace, InterestRateStream stream,
CapFloorLegParametersRange_Old legParametersRange, ValuationRange valuationRange)
{
// Get a forecast curve
//
IRateCurve forecastCurve = null;
if (!String.IsNullOrEmpty(legParametersRange.ForecastCurve) && legParametersRange.ForecastCurve.ToLower() != "none")
{
forecastCurve = CurveLoader.LoadInterestRateCurve(logger, cache, nameSpace, legParametersRange.ForecastCurve);
}
// Get a discount curve
//
var discountCurve = CurveLoader.LoadInterestRateCurve(logger, cache, nameSpace, legParametersRange.DiscountCurve);
FixedAndFloatingRateStreamCashflowGenerator.UpdateCashflowsAmounts(stream, forecastCurve, discountCurve, valuationRange.ValuationDate);
}
private static InterestRateStream CreateGenericStream(PayRelativeToEnum paymentDateRelativeTo)
{
InterestRateStream stream = new InterestRateStream();
CalculationPeriodDates calculationPeriodDates = new CalculationPeriodDates();
stream.calculationPeriodDates = calculationPeriodDates;
PaymentDates paymentDates = new PaymentDates();
stream.paymentDates = paymentDates;
paymentDates.payRelativeTo = paymentDateRelativeTo;
CalculationPeriodAmount calculationPeriodAmount = new CalculationPeriodAmount();
stream.calculationPeriodAmount = calculationPeriodAmount;
Calculation calculation = new Calculation();
stream.calculationPeriodAmount.Item = calculation;
return(stream);
}
public List <DetailedCashflowRangeItem> GetDetailedCashflowsWithNotionalSchedule(
ILogger logger,
ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
SwapLegParametersRange_Old legParametersRange,
List <DateTimeDoubleRangeItem> notionalValueItems,
ValuationRange valuationRange)
{
var tempList = notionalValueItems.Select(item => new Pair <DateTime, decimal>(item.DateTime, Convert.ToDecimal(item.Value))).ToList();
NonNegativeSchedule notionalScheduleFpML = NonNegativeScheduleHelper.Create(tempList);
Currency currency = CurrencyHelper.Parse(legParametersRange.Currency);
NonNegativeAmountSchedule amountSchedule = NonNegativeAmountScheduleHelper.Create(notionalScheduleFpML, currency);
InterestRateStream interestRateStream = GetCashflowsScheduleWithNotionalSchedule(fixingCalendar, paymentCalendar, legParametersRange, amountSchedule);
UpdateCashflowsWithAmounts(logger, cache, nameSpace, interestRateStream, legParametersRange, valuationRange);
var list = new List <DetailedCashflowRangeItem>();
//int periodNumber = 1;
foreach (PaymentCalculationPeriod paymentCalculationPeriod in interestRateStream.cashflows.paymentCalculationPeriod)
{
var detailedCashflowRangeItem = new DetailedCashflowRangeItem();
list.Add(detailedCashflowRangeItem);
detailedCashflowRangeItem.PaymentDate = paymentCalculationPeriod.adjustedPaymentDate;
detailedCashflowRangeItem.StartDate = PaymentCalculationPeriodHelper.GetCalculationPeriodStartDate(paymentCalculationPeriod);
detailedCashflowRangeItem.EndDate = PaymentCalculationPeriodHelper.GetCalculationPeriodEndDate(paymentCalculationPeriod);
//detailedCashflowRangeItem.NumberOfDays = PaymentCalculationPeriodHelper.GetNumberOfDays(paymentCalculationPeriod);
//detailedCashflowRangeItem.FutureValue = MoneyHelper.ToDouble(paymentCalculationPeriod.forecastPaymentAmount);
//detailedCashflowRangeItem.PresentValue = MoneyHelper.ToDouble(paymentCalculationPeriod.presentValueAmount);
//detailedCashflowRangeItem.DiscountFactor = (double)paymentCalculationPeriod.discountFactor;
detailedCashflowRangeItem.NotionalAmount = (double)PaymentCalculationPeriodHelper.GetNotionalAmount(paymentCalculationPeriod);
detailedCashflowRangeItem.CouponType = GetCouponType(paymentCalculationPeriod);
detailedCashflowRangeItem.Rate = (double)PaymentCalculationPeriodHelper.GetRate(paymentCalculationPeriod);
// If floating rate - retrieve the spread.
//
if (legParametersRange.IsFloatingLegType())
{
detailedCashflowRangeItem.Spread = (double)PaymentCalculationPeriodHelper.GetSpread(paymentCalculationPeriod);
}
}
return(list);
}
/// <summary>
/// </summary>
/// <param name="cache"></param>
/// <param name="interestRateStream"></param>
/// <param name="listAdjustedResetDates"></param>
/// <param name="businessCalendar"></param>
/// <param name="nameSpace"></param>
/// <returns></returns>
/// <exception cref="NotSupportedException"></exception>
public static List <DateTime> GetAdjustedFixingDates(ICoreCache cache, InterestRateStream interestRateStream, List <DateTime> listAdjustedResetDates, IBusinessCalendar businessCalendar, string nameSpace)
{
var result = new List <DateTime>();
RelativeDateOffset fixingDatesOffset = interestRateStream.resetDates.fixingDates;
int numberOfDays = int.Parse(fixingDatesOffset.periodMultiplier);
// Only NON-POSITIVE offset expressed in BUSINESS DAYS is supported.
//
if (!(fixingDatesOffset.dayType == DayTypeEnum.Business & fixingDatesOffset.period == PeriodEnum.D & numberOfDays <= 0))
{
string exceptionMessage =
$"[{fixingDatesOffset.dayType} {fixingDatesOffset.period} {numberOfDays} days] fixing day offset is not supported.";
throw new NotSupportedException(exceptionMessage);
}
var businessDayAdjustments = new BusinessDayAdjustments
{
businessCenters = fixingDatesOffset.businessCenters,
businessDayConvention =
fixingDatesOffset.businessDayConvention
};
if (businessCalendar == null)
{
businessCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, businessDayAdjustments.businessCenters, nameSpace);
}
foreach (DateTime adjustedResetDate in listAdjustedResetDates)
{
int offsetInBusinessDays = numberOfDays;
DateTime adjustedFixingDate = adjustedResetDate;
while (offsetInBusinessDays++ < 0)
{
// Adjust fixing date for one days back.
//
do
{
adjustedFixingDate = adjustedFixingDate.AddDays(-1);
} while (!businessCalendar.IsBusinessDay(adjustedFixingDate));
// adjustedFixingDate has been adjusted for 1 BUSINESS DAY
}
result.Add(adjustedFixingDate);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="nameSpace"></param>
/// <param name="leg1Parameters"></param>
/// <param name="leg1Calendars"></param>
/// <param name="leg2Parameters"></param>
/// <param name="leg2Calendars"></param>
/// <param name="fixedRateSchedule"></param>
/// <param name="spreadSchedule"></param>
/// <param name="notionalSchedule"></param>
/// <param name="marketEnvironment"></param>
/// <param name="valuationDate"></param>
/// <returns></returns>
public static Swap GenerateDefinitionCashflowsAmounts(ILogger logger, ICoreCache cache,
string nameSpace, SwapLegParametersRange_Old leg1Parameters,
Pair <IBusinessCalendar, IBusinessCalendar> leg1Calendars,
SwapLegParametersRange_Old leg2Parameters,
Pair <IBusinessCalendar, IBusinessCalendar> leg2Calendars,
Schedule fixedRateSchedule,
Schedule spreadSchedule,
NonNegativeAmountSchedule notionalSchedule,
ISwapLegEnvironment marketEnvironment,
DateTime valuationDate)
{
var swap = GenerateDefinitionCashflows(logger, cache, nameSpace, leg1Parameters, leg1Calendars, leg2Parameters, leg2Calendars, fixedRateSchedule, spreadSchedule, notionalSchedule);
InterestRateStream stream1 = swap.swapStream[0];
InterestRateStream stream2 = swap.swapStream[1];
UpdateStreamCashflowsAmounts(leg1Parameters, stream1, marketEnvironment, valuationDate);
UpdateStreamCashflowsAmounts(leg2Parameters, stream2, marketEnvironment, valuationDate);
return(swap);
}
/// <summary>
/// Builds this instance.
/// </summary>
/// <returns></returns>
public InterestRateStream Build()
{
var irstream = new InterestRateStream
{
cashflows = BuildCashflows(),
payerPartyReference = PartyReferenceFactory.Create(Payer),
receiverPartyReference = PartyReferenceFactory.Create(Receiver),
calculationPeriodDates = CalculationPeriodDates,
calculationPeriodAmount = CalculationPeriodAmount,
id = Id,
paymentDates = PaymentDates,
principalExchanges = PrincipalExchanges,
resetDates = ResetDates,
settlementProvision = SettlementProvision,
stubCalculationPeriodAmount = StubCalculationPeriodAmount
};
return(irstream);
}
internal static ValuationResultRange GetPriceOld(
ILogger logger,
ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
SwapLegParametersRange_Old leg1ParametersRange,
SwapLegParametersRange_Old leg2ParametersRange,
ValuationRange valuationRange)
{
string baseParty = valuationRange.BaseParty;
InterestRateStream stream1 = GetCashflowsSchedule(fixingCalendar, paymentCalendar, leg1ParametersRange); //pay leg
InterestRateStream stream2 = GetCashflowsSchedule(fixingCalendar, paymentCalendar, leg2ParametersRange); //receive leg
var swap = SwapFactory.Create(stream1, stream2);
UpdateCashflowsWithAmounts(logger, cache, nameSpace, stream1, leg1ParametersRange, valuationRange);
UpdateCashflowsWithAmounts(logger, cache, nameSpace, stream2, leg2ParametersRange, valuationRange);
ValuationResultRange resultRange = CreateValuationRange(swap, baseParty);
return(resultRange);
}
public static List <DetailedCashflowRangeItem> GetDetailedCashflowsTestOnly(
ILogger logger,
ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
SwapLegParametersRange_Old legParametersRange,
ValuationRange valuationRange)
{
InterestRateStream interestRateStream = GetCashflowsSchedule(fixingCalendar, paymentCalendar, legParametersRange);
UpdateCashflowsWithAmounts(logger, cache, nameSpace, interestRateStream, legParametersRange, valuationRange);
var list = new List <DetailedCashflowRangeItem>();
foreach (PaymentCalculationPeriod paymentCalculationPeriod in interestRateStream.cashflows.paymentCalculationPeriod)
{
var detailedCashflowRangeItem = new DetailedCashflowRangeItem();
list.Add(detailedCashflowRangeItem);
detailedCashflowRangeItem.PaymentDate = paymentCalculationPeriod.adjustedPaymentDate;
detailedCashflowRangeItem.StartDate = PaymentCalculationPeriodHelper.GetCalculationPeriodStartDate(paymentCalculationPeriod);
detailedCashflowRangeItem.EndDate = PaymentCalculationPeriodHelper.GetCalculationPeriodEndDate(paymentCalculationPeriod);
//detailedCashflowRangeItem.NumberOfDays = PaymentCalculationPeriodHelper.GetNumberOfDays(paymentCalculationPeriod);
//detailedCashflowRangeItem.FutureValue = MoneyHelper.ToDouble(paymentCalculationPeriod.forecastPaymentAmount);
//detailedCashflowRangeItem.PresentValue = MoneyHelper.ToDouble(paymentCalculationPeriod.presentValueAmount);
//detailedCashflowRangeItem.DiscountFactor = (double)paymentCalculationPeriod.discountFactor;
detailedCashflowRangeItem.NotionalAmount = (double)PaymentCalculationPeriodHelper.GetNotionalAmount(paymentCalculationPeriod);
detailedCashflowRangeItem.CouponType = GetCouponType(paymentCalculationPeriod);
detailedCashflowRangeItem.Rate = (double)PaymentCalculationPeriodHelper.GetRate(paymentCalculationPeriod);
// If floating rate - retrieve a spread.
//
if (legParametersRange.IsFloatingLegType())
{
detailedCashflowRangeItem.Spread = (double)PaymentCalculationPeriodHelper.GetSpread(paymentCalculationPeriod);
}
}
return(list);
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableCapFloorStream"/> class. All the cashflows must be signed.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="cache">The cache.</param>
/// <param name="stream">The stream.</param>
/// <param name="nameSpace">The nameSpace</param>
/// <param name="payerIsBase">The flag for whether the payerreference is the base party.</param>
/// <param name="forecastRateInterpolation">ForwardEndDate = forecastRateInterpolation ? AccrualEndDate
/// : AdjustedDateHelper.ToAdjustedDate(forecastRateIndex.indexTenor.Add(AccrualStartDate), AccrualBusinessDayAdjustments);</param>
/// <param name="fixingCalendar">The fixingCalendar.</param>
/// <param name="paymentCalendar">The paymentCalendar.</param>
public PriceableCapFloorStream(ILogger logger, ICoreCache cache, String nameSpace
, bool payerIsBase, InterestRateStream stream, bool forecastRateInterpolation
, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar)
: base(logger
, cache
, nameSpace
, payerIsBase
, stream
, forecastRateInterpolation
, fixingCalendar
, paymentCalendar)
{
if (Calculation.Items == null)
{
return;
}
var floatingRateCalculation = (FloatingRateCalculation)Calculation.Items[0];
var floatingRateIndex = floatingRateCalculation.floatingRateIndex;
var indexTenor = floatingRateCalculation.indexTenor.ToString();
var forecastRate = ForecastRateIndexHelper.Parse(floatingRateIndex.Value, indexTenor);
VolatilitySurfaceName = CurveNameHelpers.GetRateVolatilityMatrixName(forecastRate);
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableInterestRateStream"/> class. All the cashflows must be signed.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="cache">The cache.</param>
/// <param name="stream">The stream.</param>
/// <param name="nameSpace">The namespace</param>
/// <param name="payerIsBase">The flag for whether the payerreference is the base party.</param>
/// <param name="forecastRateInterpolation">ForwardEndDate = forecastRateInterpolation ? AccrualEndDate
/// : AdjustedDateHelper.ToAdjustedDate(forecastRateIndex.indexTenor.Add(AccrualStartDate), AccrualBusinessDayAdjustments);</param>
/// <param name="fixingCalendar">The fixingCalendar.</param>
/// <param name="paymentCalendar">The paymentCalendar.</param>
public PriceableInterestRateStream(ILogger logger, ICoreCache cache, String nameSpace
, bool payerIsBase, InterestRateStream stream, bool forecastRateInterpolation
, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar)
: this(logger
, cache
, nameSpace
, stream.id
, stream.payerPartyReference.href
, stream.receiverPartyReference.href
, payerIsBase
, stream.calculationPeriodDates
, stream.paymentDates
, stream.resetDates
, stream.principalExchanges
, stream.calculationPeriodAmount
, stream.stubCalculationPeriodAmount
, BuildCashflow(stream, fixingCalendar, paymentCalendar)
, stream.settlementProvision
, forecastRateInterpolation
, fixingCalendar
, paymentCalendar)
{
}
public static void UpdateStubCalculationPeriod(InterestRateStream interestRateStream, CalculationPeriod stubCalculationPeriod, StubValue stubValue)
{
if (XsdClassesFieldResolver.StubValueHasStubRateArray(stubValue))
{
Decimal fixedRate = XsdClassesFieldResolver.GetStubValueStubRateArray(stubValue)[0];
// Fixed rate
//
XsdClassesFieldResolver.SetCalculationPeriodFixedRate(stubCalculationPeriod, fixedRate);
}
//else if (XsdClassesFieldResolver.StubValue_HasFloatingRateArray(stubValue))
//{
// //Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmount_GetCalculation(interestRateStream.calculationPeriodAmount);
// //FloatingRate floatingRate = XsdClassesFieldResolver.GetStubValue_FloatingRateArray(stubValue)[0];
// //FloatingRateDefinition floatingRateDefinition = ForecastRateHelper.UpdateFloatingRateDefinition(floatingRate,
// // calculation.dayCountFraction,
// // stubCalculationPeriod);
// // no observed, no calculated rate, spread == 0.0
// //
// FloatingRateDefinition floatingRateDefinition = ForecastRateHelper.CreateFloatingRateDefinition(stubCalculationPeriod);
// XsdClassesFieldResolver.CalculationPeriod_SetFloatingRateDefinition(stubCalculationPeriod, floatingRateDefinition);
// //// Floating rate is set on UpdateCashflows phase.
// ////
// //XsdClassesFieldResolver.CalculationPeriod_SetFloatingRateDefinition(stubCalculationPeriod, floatingRateDefinition);
// //throw new NotImplementedException("");
//}
else if (XsdClassesFieldResolver.StubValueHasStubAmountArray(stubValue))
{
throw new NotImplementedException("stubCalculationPeriodAmount with stubAmount is not implemented.");
}
}
private bool StreamIsNABReceives(InterestRateStream stream)
{
return(stream.receiverPartyReference.href.Equals("NAB"));
}
private static string GetInterestRateStreamType(InterestRateStream interestRateStream)
{
Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(interestRateStream.calculationPeriodAmount);
return(XsdClassesFieldResolver.CalculationHasFloatingRateCalculation(calculation) ? "float" : "fixed");
}
public List <DetailedCashflowRangeItem> GetDetailedCashflowsWithNotionalSchedule(
ILogger logger, ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
CapFloorLegParametersRange_Old legParametersRange,
List <DateTimeDoubleRangeItem> notionalValueItems,
ValuationRange valuationRange)
{
//Check if the calendars are null. If not build them!
var list1 = notionalValueItems.Select(item => new Pair <DateTime, decimal>(item.DateTime, Convert.ToDecimal(item.Value))).ToList();
NonNegativeSchedule notionalScheduleFpML = NonNegativeScheduleHelper.Create(list1);
Currency currency = CurrencyHelper.Parse(legParametersRange.Currency);
NonNegativeAmountSchedule amountSchedule = NonNegativeAmountScheduleHelper.Create(notionalScheduleFpML, currency);
InterestRateStream interestRateStream = GetCashflowsScheduleWithNotionalSchedule(fixingCalendar, paymentCalendar, legParametersRange, amountSchedule);
//Add the principal exchanges to the cashflows.
var principalExchangeList = list1.Select(cashflow => new PrincipalExchange
{
adjustedPrincipalExchangeDate = cashflow.First, adjustedPrincipalExchangeDateSpecified = true, principalExchangeAmount = cashflow.Second, principalExchangeAmountSpecified = true
}).ToArray();
interestRateStream.cashflows.principalExchange = principalExchangeList;
UpdateCashflowsWithAmounts(logger, cache, nameSpace, interestRateStream, legParametersRange, valuationRange);
var list = new List <DetailedCashflowRangeItem>();
foreach (PaymentCalculationPeriod paymentCalculationPeriod in interestRateStream.cashflows.paymentCalculationPeriod)
{
var detailedCashflowRangeItem = new DetailedCashflowRangeItem();
detailedCashflowRangeItem.PaymentDate = paymentCalculationPeriod.adjustedPaymentDate;
detailedCashflowRangeItem.StartDate = PaymentCalculationPeriodHelper.GetCalculationPeriodStartDate(paymentCalculationPeriod);
detailedCashflowRangeItem.EndDate = PaymentCalculationPeriodHelper.GetCalculationPeriodEndDate(paymentCalculationPeriod);
detailedCashflowRangeItem.NumberOfDays = PaymentCalculationPeriodHelper.GetNumberOfDays(paymentCalculationPeriod);
detailedCashflowRangeItem.FutureValue = MoneyHelper.ToDouble(paymentCalculationPeriod.forecastPaymentAmount);
detailedCashflowRangeItem.PresentValue = MoneyHelper.ToDouble(paymentCalculationPeriod.presentValueAmount);
detailedCashflowRangeItem.DiscountFactor = (double)paymentCalculationPeriod.discountFactor;
detailedCashflowRangeItem.NotionalAmount = (double)PaymentCalculationPeriodHelper.GetNotionalAmount(paymentCalculationPeriod);
detailedCashflowRangeItem.CouponType = GetCouponType(paymentCalculationPeriod);
detailedCashflowRangeItem.Rate = (double)PaymentCalculationPeriodHelper.GetRate(paymentCalculationPeriod);
CalculationPeriod calculationPeriod = PaymentCalculationPeriodHelper.GetCalculationPeriods(paymentCalculationPeriod)[0];
FloatingRateDefinition floatingRateDefinition = XsdClassesFieldResolver.CalculationPeriodGetFloatingRateDefinition(calculationPeriod);
switch (detailedCashflowRangeItem.CouponType.ToLower())
{
case "cap":
{
Strike strike = floatingRateDefinition.capRate[0];
detailedCashflowRangeItem.StrikeRate = (double)strike.strikeRate;
break;
}
case "floor":
{
Strike strike = floatingRateDefinition.floorRate[0];
detailedCashflowRangeItem.StrikeRate = (double)strike.strikeRate;
break;
}
default:
{
string message =
String.Format("Specified coupon type : '{0}' is not supported. Please use one of these: 'cap, floor'", detailedCashflowRangeItem.CouponType.ToLower());
throw new NotSupportedException(message);
}
}
// If floating rate - retrieve the spread.
//
detailedCashflowRangeItem.Spread = (double)PaymentCalculationPeriodHelper.GetSpread(paymentCalculationPeriod);
var fixingDate = new DateTime();
var tempDate = PaymentCalculationPeriodHelper.GetFirstFloatingFixingDate(paymentCalculationPeriod);
if (tempDate != null)
{
fixingDate = (DateTime)tempDate;
}
detailedCashflowRangeItem.FixingDate = fixingDate;
detailedCashflowRangeItem.Currency = "Not Specified";
if (currency != null)
{
detailedCashflowRangeItem.Currency = currency.Value;
}
list.Add(detailedCashflowRangeItem);
}
return(list);
}
public static InterestRateStream CreateFixedRateStream(PayRelativeToEnum paymentDateRelativeTo)
{
InterestRateStream fixedRateStream = CreateGenericStream(paymentDateRelativeTo);
return(fixedRateStream);
}
public static Pair <ValuationResultRange, CapFloor> GetPriceAndGeneratedFpML(
ILogger logger, ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
ValuationRange valuationRange, TradeRange tradeRange,
CapFloorLegParametersRange_Old leg1ParametersRange,
List <InputCashflowRangeItem> leg1DetailedCashflowsList,
List <InputPrincipalExchangeCashflowRangeItem> legPrincipalExchangeCashflowListArray,
List <AdditionalPaymentRangeItem> leg1AdditionalPaymentList,
List <FeePaymentRangeItem> feePaymentList
)
{
//Check if the calendars are null. If not build them!
InterestRateStream stream1 = GetCashflowsSchedule(fixingCalendar, paymentCalendar, leg1ParametersRange);//parametric definiton + cashflows schedule
// Update FpML cashflows
//
stream1.cashflows = UpdateCashflowsWithDetailedCashflows(leg1DetailedCashflowsList);
if (null != legPrincipalExchangeCashflowListArray)
{
// create principal exchanges
//
InterestRateSwapPricer.CreatePrincipalExchangesFromListOfRanges(stream1.cashflows, legPrincipalExchangeCashflowListArray);
}
// Add bullet payments...
//
var bulletPaymentList = new List <Payment>();
if (null != leg1AdditionalPaymentList)
{
bulletPaymentList.AddRange(leg1AdditionalPaymentList.Select(bulletPaymentRangeItem => new Payment
{
payerPartyReference = PartyReferenceFactory.Create(leg1ParametersRange.Payer),
receiverPartyReference = PartyReferenceFactory.Create(leg1ParametersRange.Receiver),
paymentAmount = MoneyHelper.GetNonNegativeAmount(bulletPaymentRangeItem.Amount, bulletPaymentRangeItem.Currency),
paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(bulletPaymentRangeItem.PaymentDate)
}));
}
CapFloor capFloor = CapFloorFactory.Create(stream1);
capFloor.additionalPayment = bulletPaymentList.ToArray();
var feeList = new List <Payment>();
if (null != feePaymentList)
{
feeList.AddRange(feePaymentList.Select(feePaymentRangeItem => new Payment
{
paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(feePaymentRangeItem.PaymentDate),
paymentAmount = MoneyHelper.GetNonNegativeAmount(feePaymentRangeItem.Amount, feePaymentRangeItem.Currency),
payerPartyReference = PartyReferenceFactory.Create(feePaymentRangeItem.Payer),
receiverPartyReference = PartyReferenceFactory.Create(feePaymentRangeItem.Receiver)
}));
}
capFloor.premium = feeList.ToArray();
// Update FpML cashflows with DF,FV,PV, etc (LegParametersRange needed to access curve functionality)
//
UpdateCashflowsWithAmounts(logger, cache, nameSpace, stream1, leg1ParametersRange, valuationRange);
// Update additional payments
//
var leg1DiscountCurve = CurveLoader.LoadInterestRateCurve(logger, cache, nameSpace, leg1ParametersRange.DiscountCurve);
CapFloorGenerator.UpdatePaymentsAmounts(paymentCalendar, capFloor, leg1ParametersRange, leg1DiscountCurve, valuationRange.ValuationDate);
//~ Update additional payments
string baseParty = valuationRange.BaseParty;
return(new Pair <ValuationResultRange, CapFloor>(CreateValuationRange(capFloor, baseParty), capFloor));
}
/// <summary>
/// Return a Cashflows object containing array of the payment calculation periods and array of principal exchanges.
/// </summary>
/// <param name="paymentCalendar"> </param>
/// <param name="interestRateStream">The interest rate stream.</param>
/// <param name="rollDates">The list of roll dates.</param>
/// <returns></returns>
public static Cashflows GetCashflows(List <DateTime> rollDates, IBusinessCalendar paymentCalendar, InterestRateStream interestRateStream)
{
CalculationPeriodsPrincipalExchangesAndStubs calculationPeriodsPrincipalExchangesAndStubs =
StreamCashflowsGenerator.GenerateCalculationPeriodsPrincipalExchangesAndStubsFromRollDates(interestRateStream, rollDates, paymentCalendar);
return(GetCashfows(interestRateStream, calculationPeriodsPrincipalExchangesAndStubs, paymentCalendar));
}
public static void SetFixedRateSchedule(InterestRateStream stream, Schedule fixedRateSchedule)
{
Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(stream.calculationPeriodAmount);
XsdClassesFieldResolver.CalculationSetFixedRateSchedule(calculation, fixedRateSchedule);
}
public static void SetPayerAndReceiver(InterestRateStream stream, string payer, string receiver)
{
stream.payerPartyReference = PartyReferenceFactory.Create(payer);
stream.receiverPartyReference = PartyReferenceFactory.Create(receiver);
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableInterestRateStream"/> class. All the cashflows must be signed.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="cache">The cache.</param>
/// <param name="stream">The stream.</param>
/// <param name="nameSpace">The namespace</param>
/// <param name="payerIsBase">The flag for whether the payerreference is the base party.</param>
/// <param name="fixingCalendar">The fixingCalendar.</param>
/// <param name="paymentCalendar">The paymentCalendar.</param>
public PriceableInterestRateStream(ILogger logger, ICoreCache cache
, String nameSpace, bool payerIsBase, InterestRateStream stream
, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar)
: this(logger, cache, nameSpace, payerIsBase, stream, true, fixingCalendar, paymentCalendar)
{
}
