private static CalculationPeriod Create(DateTime periodStartDate, DateTime periodEndDate
, CalculationPeriodFrequency frequency, BusinessDayAdjustments dateAdjustments
, IBusinessCalendar paymentCalendar, bool isFirstPeriodCreated)
{
var calculationPeriod = new CalculationPeriod();
// Apply ROLL CONVENTION (NOT A BUSINESS DAY CONVENTION!) to unadjusted period start and end dates.
//
DateTime rollConventionPeriodStartDate = periodStartDate;
DateTime rollConventionPeriodEndDate = periodEndDate;
var frequencyPeriod = EnumHelper.Parse <PeriodEnum>(frequency.period, true);
if (frequencyPeriod != PeriodEnum.D)//adjust if the frequency is NOT expressed in days
{
rollConventionPeriodStartDate = RollConventionEnumHelper.AdjustDate(frequency.rollConvention, periodStartDate);
rollConventionPeriodEndDate = RollConventionEnumHelper.AdjustDate(frequency.rollConvention, periodEndDate);
}
CalculationPeriodHelper.SetUnadjustedDates(calculationPeriod, rollConventionPeriodStartDate, rollConventionPeriodEndDate);
// Set adjusted period dates
//
DateTime adjustedPeriodStartDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, rollConventionPeriodStartDate, dateAdjustments);
DateTime adjustedPeriodEndDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, rollConventionPeriodEndDate, dateAdjustments);
if (isFirstPeriodCreated)
{
adjustedPeriodEndDate = periodEndDate;
}
CalculationPeriodHelper.SetAdjustedDates(calculationPeriod, adjustedPeriodStartDate, adjustedPeriodEndDate);
return(calculationPeriod);
}
private static void GeneratePeriodsBackward(DateTime firstRollDate, CalculationPeriodFrequency frequency,
BusinessDayAdjustments calculationPeriodDatesAdjustments,
CalculationPeriodsPrincipalExchangesAndStubs result,
DateTime adjustedEffectiveDate, StubPeriodTypeEnum?initialStubType
, IBusinessCalendar paymentCalendar)
{
DateTime periodEndDate = firstRollDate;
DateTime periodStartDate = AddPeriod(periodEndDate, IntervalHelper.FromFrequency(frequency), -1);
bool encounteredShortInitialStub = false;
//if (paymentCalendar == null)
//{
// paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, calculationPeriodDatesAdjustments.businessCenters);
//}
do
{
var calculationPeriod = new CalculationPeriod();
// Apply ROLL CONVENTION (NOT A BUSINESS DAY CONVENTION!) to unadjusted period start and end dates.
//
DateTime rollConventionAdjustedPeriodStartDate = periodStartDate;
DateTime rollConventionAdjustedPeriodEndDate = periodEndDate;
var frequencyPeriod = EnumHelper.Parse <PeriodEnum>(frequency.period, true);
if (frequencyPeriod != PeriodEnum.D)//adjust if the frequency is NOT expressed in days
{
rollConventionAdjustedPeriodStartDate = RollConventionEnumHelper.AdjustDate(frequency.rollConvention, periodStartDate);
rollConventionAdjustedPeriodEndDate = RollConventionEnumHelper.AdjustDate(frequency.rollConvention, periodEndDate);
}
CalculationPeriodHelper.SetUnadjustedDates(calculationPeriod, rollConventionAdjustedPeriodStartDate, rollConventionAdjustedPeriodEndDate);
// Set adjusted period dates
//
DateTime adjustedPeriodStartDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, rollConventionAdjustedPeriodStartDate, calculationPeriodDatesAdjustments);
DateTime adjustedPeriodEndDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, rollConventionAdjustedPeriodEndDate, calculationPeriodDatesAdjustments);
CalculationPeriodHelper.SetAdjustedDates(calculationPeriod, adjustedPeriodStartDate, adjustedPeriodEndDate);
//if (calculationPeriod.unadjustedStartDate > adjustedEffectiveDate)
if (calculationPeriod.adjustedStartDate > adjustedEffectiveDate)
{
result.InsertFirst(calculationPeriod);
periodEndDate = periodStartDate;
periodStartDate = AddPeriod(periodEndDate, IntervalHelper.FromFrequency(frequency), -1);
}
//else if (calculationPeriod.unadjustedStartDate == adjustedEffectiveDate)//first period - not stub
else if (calculationPeriod.adjustedStartDate == adjustedEffectiveDate)//first period - not stub
{
result.InsertFirst(calculationPeriod);
break;
}
else//first period - short stub (merge with next period if a long stub specified)
{
encounteredShortInitialStub = true;
//calculationPeriod.unadjustedStartDate = adjustedEffectiveDate;
calculationPeriod.adjustedStartDate = adjustedEffectiveDate;
result.InitialStubCalculationPeriod = calculationPeriod;
break;
}
} while (true);
if (encounteredShortInitialStub && initialStubType == StubPeriodTypeEnum.LongInitial)
{
result.CreateLongInitialStub();
}
}
public List <DateTime> BuildDates(ILogger logger, ICoreCache cache, String nameSpace, BillSwapPricerDatesRange billSwapPricerDatesRange, IBusinessCalendar paymentCalendar)
{
CalculationPeriodFrequency frequency = CalculationPeriodFrequencyHelper.Parse(billSwapPricerDatesRange.RollFrequency, billSwapPricerDatesRange.RollConvention);
StubPeriodTypeEnum? initialStub = null;
if (!String.IsNullOrEmpty(billSwapPricerDatesRange.InitialStubPeriod))
{
initialStub = EnumHelper.Parse <StubPeriodTypeEnum>(billSwapPricerDatesRange.InitialStubPeriod);
}
StubPeriodTypeEnum?finalStub = null;
if (!String.IsNullOrEmpty(billSwapPricerDatesRange.FinalStubPeriod))
{
finalStub = EnumHelper.Parse <StubPeriodTypeEnum>(billSwapPricerDatesRange.FinalStubPeriod);
}
//BusinessDayAdjustments adjustments = BusinessDayAdjustmentsHelper.Create(BusinessDayConventionEnum.NONE, "");
//if (paymentCalendar == null)
//{
// paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, adjustments.businessCenters);//Make sure this builds a valid calendar!
//}
BusinessDayAdjustments calculationPeriodDayAdjustments = BusinessDayAdjustmentsHelper.Create(billSwapPricerDatesRange.BusinessDayConvention, billSwapPricerDatesRange.Calendar);
if (paymentCalendar == null)
{
paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, calculationPeriodDayAdjustments.businessCenters, nameSpace);
}
CalculationPeriodsPrincipalExchangesAndStubs result = CalculationPeriodGenerator.GenerateAdjustedCalculationPeriods(
billSwapPricerDatesRange.StartDate,
billSwapPricerDatesRange.EndDate,
billSwapPricerDatesRange.FirstRegularPeriodStartDate,
frequency,
calculationPeriodDayAdjustments,
initialStub,
finalStub,
paymentCalendar
);
foreach (CalculationPeriod regularCalculationPeriod in result.GetRegularAndStubPeriods())
{
// Adjust both startDate & endDate of period
//
CalculationPeriodHelper.SetAdjustedDates(regularCalculationPeriod,
AdjustedDateHelper.ToAdjustedDate(paymentCalendar, regularCalculationPeriod.unadjustedStartDate, calculationPeriodDayAdjustments),
AdjustedDateHelper.ToAdjustedDate(paymentCalendar, regularCalculationPeriod.unadjustedEndDate, calculationPeriodDayAdjustments));
}
var listResult = result.GetRegularAndStubPeriods().Select(regularCalculationPeriod => regularCalculationPeriod.adjustedStartDate).ToList();
listResult.Add(result.GetRegularAndStubPeriods()[result.GetRegularAndStubPeriods().Count - 1].adjustedEndDate);
return(listResult);
}
private static CalculationPeriod CreateStub(DateTime periodStartDate, DateTime periodEndDate
, BusinessDayAdjustments dateAdjustments, IBusinessCalendar paymentCalendar)
{
var calculationPeriod = new CalculationPeriod();
// Apply ROLL CONVENTION (NOT A BUSINESS DAY CONVENTION!) to unadjusted period start and end dates.
//
CalculationPeriodHelper.SetUnadjustedDates(calculationPeriod, periodStartDate, periodEndDate);
// Set adjusted period dates
//
DateTime adjustedPeriodStartDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, periodStartDate, dateAdjustments);
DateTime adjustedPeriodEndDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, periodEndDate, dateAdjustments);
CalculationPeriodHelper.SetAdjustedDates(calculationPeriod, adjustedPeriodStartDate, adjustedPeriodEndDate);
return(calculationPeriod);
}
/// <summary>
/// Don't generate stubs?
/// </summary>
/// <param name="interestRateStream"></param>
/// <param name="rollDates">from #1st roll date to last roll date (last roll dates is effectively the end of the swap)</param>
/// <param name="paymentCalendar"></param>
/// <returns></returns>
public static CalculationPeriodsPrincipalExchangesAndStubs GenerateCalculationPeriodsPrincipalExchangesAndStubsFromRollDates(InterestRateStream interestRateStream,
List <DateTime> rollDates,
IBusinessCalendar paymentCalendar)
{
CalculationPeriodDates calculationPeriodDates = interestRateStream.calculationPeriodDates;
AdjustableDate adjustableEffectiveDate = XsdClassesFieldResolver.CalculationPeriodDatesGetEffectiveDate(calculationPeriodDates);
var result = new CalculationPeriodsPrincipalExchangesAndStubs();
for (int rollDateIndex = 0; rollDateIndex < rollDates.Count - 1; ++rollDateIndex)
{
DateTime startOfThePeriod = rollDates[rollDateIndex];
DateTime endOfThePeriod = rollDates[rollDateIndex + 1];
var calculationPeriod = new CalculationPeriod();
// Set adjusted period dates
//
CalculationPeriodHelper.SetAdjustedDates(calculationPeriod,
startOfThePeriod,
endOfThePeriod);
result.Add(calculationPeriod);
}
// Add principle exchanges if this need is defined in parametric representation of the interest rate steam.
//
if (null != interestRateStream.principalExchanges)
{
// Initial PE
//
if (interestRateStream.principalExchanges.initialExchange)
{
//if (paymentCalendar == null)
//{
// paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, adjustableEffectiveDate.dateAdjustments.businessCenters);
//}
PrincipalExchange initialExchange = PrincipalExchangeHelper.Create(AdjustedDateHelper.ToAdjustedDate(paymentCalendar, adjustableEffectiveDate));
result.InitialPrincipalExchange = initialExchange;
}
// intermediatory PE
//
if (interestRateStream.principalExchanges.intermediateExchange)
{
// Generate a list of intermediatory PE exchanges
//
Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(interestRateStream.calculationPeriodAmount);
Notional notionalSchedule = XsdClassesFieldResolver.CalculationGetNotionalSchedule(calculation);
if (null != notionalSchedule.notionalStepSchedule.step)//there should be steps - otherwise NO interm. exchanges.
{
foreach (DateTime stepDate in ScheduleHelper.GetStepDates(notionalSchedule.notionalStepSchedule))
{
PrincipalExchange intermediatoryExchange = PrincipalExchangeHelper.Create(stepDate);
result.Add(intermediatoryExchange);
}
}
}
//AdjustableDate adjustableTerminationDate = XsdClassesFieldResolver.CalculationPeriodDates_GetTerminationDate(calculationPeriodDates);
DateTime lastRollDate = rollDates[rollDates.Count - 1];
// Final PE
//
if (interestRateStream.principalExchanges.finalExchange)
{
//PrincipalExchange finalExchange = PrincipalExchangeHelper.Create(DateTypesHelper.ToAdjustedDate(adjustableTerminationDate));
PrincipalExchange finalExchange = PrincipalExchangeHelper.Create(lastRollDate);
result.FinalPrincipalExchange = finalExchange;
}
}
return(result);
}
