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();
}
}
/// <summary>
/// Gets the adjusted calculation period start dates.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="firstRegularPeriodDate">The first regular period date.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <param name="businessCalendar">The businessCalendar.</param>
/// <param name="businessDayConvention">The business day convention.</param>
/// <returns>A vertical range of dates.</returns>
public static DateTime[] GetAdjustedCalculationPeriodDates(DateTime effectiveDate, DateTime terminationDate,
string periodInterval, string rollConvention, DateTime firstRegularPeriodDate, string stubPeriodType,
IBusinessCalendar businessCalendar, string businessDayConvention)
{
const string dateToReturn = "unadjustedStartDate";
StubPeriodTypeEnum?stubType = null;
if (!string.IsNullOrEmpty(stubPeriodType))
{
stubType = (StubPeriodTypeEnum)Enum.Parse(typeof(StubPeriodTypeEnum), stubPeriodType, true);
}
var periods = CalculationPeriodHelper.GenerateUnadjustedCalculationDates(effectiveDate, terminationDate, firstRegularPeriodDate, PeriodHelper.Parse(periodInterval), RollConventionEnumHelper.Parse(rollConvention), stubType);
var dates = CalculationPeriodHelper.GetCalculationPeriodsProperty <DateTime>(periods, dateToReturn);
var newDates = new DateTime[dates.Count];
var index = 0;
foreach (var date in dates)
{
var newDate = BusinessCalendarHelper.Advance(businessCalendar, date, "Calendar", "0D", businessDayConvention);
newDates[index] = newDate;
index++;
}
var result = newDates;
return(result);
}
/// <summary>
/// Generates the unadjusted calculation dates.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="calculationPeriodDates">The calculation period dates.</param>
/// <returns></returns>
static public List <CalculationPeriod> GenerateUnadjustedCalculationDates(DateTime effectiveDate, DateTime terminationDate, CalculationPeriodDates calculationPeriodDates)
{
DateTime startDate = effectiveDate;
DateTime endDate = terminationDate;
var unadjustedDatePeriods = new List <CalculationPeriod>();
AdjustableDate firstPeriodStartDate = calculationPeriodDates.firstPeriodStartDate;
if (firstPeriodStartDate != null)
{
// Use the firstPeriodStartDate as the start date if it has been specified
if ((firstPeriodStartDate.unadjustedDate != null) && (firstPeriodStartDate.unadjustedDate.Value != effectiveDate))
{
startDate = firstPeriodStartDate.unadjustedDate.Value;
}
}
DateTime firstRegularPeriodDate = startDate;
if (calculationPeriodDates.firstRegularPeriodStartDateSpecified)
{
firstRegularPeriodDate = calculationPeriodDates.firstRegularPeriodStartDate;
}
StubPeriodTypeEnum?stubPeriodType = null;
stubPeriodType = calculationPeriodDates.stubPeriodTypeSpecified ? calculationPeriodDates.stubPeriodType : stubPeriodType;
if (calculationPeriodDates.firstRegularPeriodStartDateSpecified && calculationPeriodDates.lastRegularPeriodEndDateSpecified)
{
//Dates must converge
Boolean bContainsIrregularPeriod;
List <CalculationPeriod> periods = GetForwardRegularPeriods(calculationPeriodDates.firstRegularPeriodStartDate, endDate, calculationPeriodDates.calculationPeriodFrequency, out bContainsIrregularPeriod);
if ((periods.Count > 0) && (periods[periods.Count - 1].unadjustedEndDate != calculationPeriodDates.lastRegularPeriodEndDate))
{
throw new ArgumentOutOfRangeException("Irregular period found between the first regular period start and last regular period end");
}
unadjustedDatePeriods = GenerateUnadjustedCalculationDates(startDate, endDate, firstRegularPeriodDate, calculationPeriodDates.calculationPeriodFrequency, stubPeriodType);
}
else if (calculationPeriodDates.firstRegularPeriodStartDateSpecified)
{
unadjustedDatePeriods = GenerateUnadjustedCalculationDates(startDate, endDate, firstRegularPeriodDate, calculationPeriodDates.calculationPeriodFrequency, stubPeriodType);
}
else if (calculationPeriodDates.lastRegularPeriodEndDateSpecified)
{
Period periodInterval = CalculationPeriodFrequencyToInterval(calculationPeriodDates.calculationPeriodFrequency);
unadjustedDatePeriods = GenerateUnadjustedCalculationDatesFromTermDate(startDate, endDate, periodInterval, calculationPeriodDates.lastRegularPeriodEndDate, calculationPeriodDates.calculationPeriodFrequency.rollConvention, stubPeriodType);
}
return(unadjustedDatePeriods);
}
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);
}
/// <summary>
/// Returns the unadjusted the calculation dates
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="intervalToFirstRegularPeriodStart">The interval to first regular period start.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <returns></returns>
public static DateTime[] UnadjustedCalculationDatesFromFirstRegularInterval(DateTime effectiveDate, DateTime terminationDate, string intervalToFirstRegularPeriodStart, string periodInterval, string rollConvention, string stubPeriodType)
{
const string dateToReturn = "unadjustedStartDate";
StubPeriodTypeEnum?stubType = null;
if (!string.IsNullOrEmpty(stubPeriodType))
{
stubType = (StubPeriodTypeEnum)Enum.Parse(typeof(StubPeriodTypeEnum), stubPeriodType, true);
}
var periods = CalculationPeriodHelper.GenerateUnadjustedCalculationDates(effectiveDate, terminationDate, PeriodHelper.Parse(periodInterval), PeriodHelper.Parse(intervalToFirstRegularPeriodStart), RollConventionEnumHelper.Parse(rollConvention), stubType);
var dates = CalculationPeriodHelper.GetCalculationPeriodsProperty <DateTime>(periods, dateToReturn);
var result = dates.ToArray();
return(result);
}
public static CalculationPeriodsPrincipalExchangesAndStubs GenerateAdjustedCalculationPeriods(
DateTime unadjustedEffectiveDate,
DateTime unadjustedTerminationDate,
DateTime unadjustedFirstRollDate, //this one is still UN adjusted
CalculationPeriodFrequency frequency,
BusinessDayAdjustments calculationPeriodDatesAdjustments,
StubPeriodTypeEnum?initialStubType,
StubPeriodTypeEnum?finalStubType,
IBusinessCalendar paymentCalendar)
{
#region Param check
if (initialStubType.HasValue)
{
if ((initialStubType != StubPeriodTypeEnum.LongInitial) && (initialStubType != StubPeriodTypeEnum.ShortInitial))
{
throw new ArgumentOutOfRangeException(nameof(initialStubType), initialStubType, "Wrong stub type.");
}
}
if (finalStubType.HasValue)
{
if ((finalStubType == StubPeriodTypeEnum.LongFinal) && (initialStubType == StubPeriodTypeEnum.ShortFinal))
{
throw new ArgumentOutOfRangeException(nameof(finalStubType), finalStubType, "Wrong stub type.");
}
}
// if (!RollConventionEnumHelper.IsAdjusted(frequency.rollConvention, unadjustedFirstRollDate))
// {
// string message = String.Format("First roll date {0}, should be pre-adjusted according to RollConvention {1}", unadjustedFirstRollDate, frequency.rollConvention);
// throw new Exception(message);
// }
#endregion
var result = new CalculationPeriodsPrincipalExchangesAndStubs();
// Start calculations from 'first roll date' and generate dates backwards and forwards
//
// Generate periods backwards (toward the unadjustedEffectiveDate)
//
GeneratePeriodsBackward(unadjustedFirstRollDate, frequency, calculationPeriodDatesAdjustments, result, unadjustedEffectiveDate, initialStubType, paymentCalendar);
// Generate periods forwards (toward the unadjustedTerminationDate)
//
GeneratePeriodsForward(unadjustedFirstRollDate, frequency, calculationPeriodDatesAdjustments, result, unadjustedTerminationDate, finalStubType, paymentCalendar);
return(result);
}
/// <summary>
/// Generates the unadjusted calculation dates.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="intervalToTerminationDate">The interval to termination date.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <returns></returns>
public static List <CalculationPeriod> GenerateUnadjustedCalculationDates(DateTime effectiveDate, Period intervalToTerminationDate, Period periodInterval, RollConventionEnum rollConvention)
{
DateTime startDate = effectiveDate;
// Adjust the effective date
if (rollConvention != RollConventionEnum.NONE)
{
startDate = RollConventionEnumHelper.AdjustDate(rollConvention, effectiveDate);
}
Double divisor = IntervalHelper.Div(intervalToTerminationDate, periodInterval);
// The divisor has to be a whole number (i.e. the period must roll to the term date interval
if ((divisor % 1) != 0)
{
throw new ArithmeticException("The period frequency will not roll to the supplied termination date interval");
}
DateTime terminationDate = intervalToTerminationDate.Add(startDate);
StubPeriodTypeEnum?stubPeriodType = null;
return(GenerateUnadjustedCalculationDates(startDate, terminationDate, effectiveDate, periodInterval, rollConvention, stubPeriodType));
}
/// <summary>
/// Gets the unadjusted calculation date schedule from term date.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="lastRegularPeriodEndDate">The last regular period end date.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <returns></returns>
public List <CalculationPeriod> GetUnadjustedCalculationDateScheduleFromTermDate(DateTime effectiveDate, DateTime terminationDate, Period periodInterval, DateTime lastRegularPeriodEndDate, RollConventionEnum rollConvention, StubPeriodTypeEnum?stubPeriodType)
{
CalculationPeriodDates = null;
PeriodInterval = periodInterval;
_effectiveDate = effectiveDate;
_termDate = terminationDate;
RollConvention = rollConvention;
_unadjustedDateScheduleList = CalculationPeriodHelper.GenerateUnadjustedCalculationDatesFromTermDate(effectiveDate, terminationDate, periodInterval, lastRegularPeriodEndDate, rollConvention, stubPeriodType);
return(_unadjustedDateScheduleList);
}
/// <summary>
/// Gets the unadjusted calculation date schedule.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="regularPeriodStartDate">The regular period start date.</param>
/// <param name="periodFrequency">The period frequency.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <returns></returns>
public List <CalculationPeriod> GetUnadjustedCalculationDateSchedule(DateTime effectiveDate, DateTime terminationDate, DateTime regularPeriodStartDate, CalculationPeriodFrequency periodFrequency, StubPeriodTypeEnum?stubPeriodType)
{
CalculationPeriodDates = null;
PeriodInterval = CalculationPeriodHelper.CalculationPeriodFrequencyToInterval(periodFrequency);
_effectiveDate = effectiveDate;
_termDate = terminationDate;
RollConvention = periodFrequency.rollConvention;
_unadjustedDateScheduleList = CalculationPeriodHelper.GenerateUnadjustedCalculationDates(effectiveDate, terminationDate, regularPeriodStartDate, periodFrequency, stubPeriodType);
return(_unadjustedDateScheduleList);
}
/// <summary>
/// Generates the unadjusted calculation dates from term date.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="lastRegularPeriodEndDate">The last regular period end date.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <returns></returns>
static public List <CalculationPeriod> GenerateUnadjustedCalculationDatesFromTermDate(DateTime effectiveDate, DateTime terminationDate, Period periodInterval, DateTime lastRegularPeriodEndDate, RollConventionEnum rollConvention, StubPeriodTypeEnum?stubPeriodType)
{
var unadjustedPeriodDates = new List <CalculationPeriod>();
DateTime lastRegularPeriodStartDate = AddPeriod(lastRegularPeriodEndDate, periodInterval, -1);
if (lastRegularPeriodStartDate > effectiveDate)
{
Boolean bHasIrregularInitial;
List <CalculationPeriod> regularPeriods = GetBackwardRegularPeriods(lastRegularPeriodStartDate, effectiveDate, periodInterval, rollConvention, out bHasIrregularInitial);
if (regularPeriods.Count > 0)
{
DateTime firstRegularPeriodStartDate = regularPeriods[0].unadjustedStartDate;
unadjustedPeriodDates = GenerateUnadjustedCalculationDates(effectiveDate, terminationDate, firstRegularPeriodStartDate, periodInterval, rollConvention, stubPeriodType);
}
}
return(unadjustedPeriodDates);
}
/// <summary>
/// Generates the unadjusted calculation dates.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="intervalToFirstRegularPeriodStartDate">The interval to first regular period start date.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <returns></returns>
static public List <CalculationPeriod> GenerateUnadjustedCalculationDates(DateTime effectiveDate, DateTime terminationDate, Period periodInterval, Period intervalToFirstRegularPeriodStartDate, RollConventionEnum rollConvention, StubPeriodTypeEnum?stubPeriodType)
{
DateTime firstRegularPeriodStartDate = GetFirstRegularPeriodStartDate(intervalToFirstRegularPeriodStartDate, rollConvention, effectiveDate);
return(GenerateUnadjustedCalculationDates(effectiveDate, terminationDate, firstRegularPeriodStartDate, periodInterval, rollConvention, stubPeriodType));
}
/// <summary>
/// Generates the unadjusted calculation dates.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="regularPeriodStartDate">The regular period start date.</param>
/// <param name="calculationPeriodFrequency">The calculation period frequency.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <returns></returns>
static public List <CalculationPeriod> GenerateUnadjustedCalculationDates(DateTime effectiveDate, DateTime terminationDate, DateTime regularPeriodStartDate, CalculationPeriodFrequency calculationPeriodFrequency, StubPeriodTypeEnum?stubPeriodType)
{
Period periodInterval = CalculationPeriodFrequencyToInterval(calculationPeriodFrequency);
return(GenerateUnadjustedCalculationDates(effectiveDate, terminationDate, regularPeriodStartDate, periodInterval, calculationPeriodFrequency.rollConvention, stubPeriodType));
}
/// <summary>
/// Generates the unadjusted calculation dates.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="regularPeriodStartDate">The regular period start date.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <returns></returns>
static public List <CalculationPeriod> GenerateUnadjustedCalculationDates(DateTime effectiveDate, DateTime terminationDate, DateTime regularPeriodStartDate, Period periodInterval, RollConventionEnum rollConvention, StubPeriodTypeEnum?stubPeriodType)
{
DateTime startDate = effectiveDate;
DateTime endDate = terminationDate;
Boolean bContainsIrregularFinalPeriod;
List <CalculationPeriod> forwardRegularPeriods = GetForwardRegularPeriods(regularPeriodStartDate, endDate, periodInterval, rollConvention, out bContainsIrregularFinalPeriod);
if (bContainsIrregularFinalPeriod)
{
if (forwardRegularPeriods.Count == 0)
{
CalculationPeriod calculationPeriod = CreateUnadjustedCalculationPeriod(regularPeriodStartDate, endDate);
forwardRegularPeriods.Add(calculationPeriod);
}
else
{
forwardRegularPeriods = SetFinalIrregularStubPeriod(forwardRegularPeriods, endDate, stubPeriodType ?? StubPeriodTypeEnum.LongFinal);
}
}
var backwardRegularPeriods = new List <CalculationPeriod>();
if (regularPeriodStartDate > startDate)
{
var irregularInitialStubType = StubPeriodTypeEnum.ShortInitial;
Boolean bContainsIrregularInitialPeriod;
backwardRegularPeriods = GetBackwardRegularPeriods(regularPeriodStartDate, startDate, periodInterval, rollConvention, out bContainsIrregularInitialPeriod);
if ((bContainsIrregularInitialPeriod && stubPeriodType != null) && (stubPeriodType != StubPeriodTypeEnum.ShortInitial && stubPeriodType != StubPeriodTypeEnum.LongInitial))
{
DateTime normalPeriodStart = AddPeriod(startDate, periodInterval, 1);
if (regularPeriodStartDate > normalPeriodStart)
{
irregularInitialStubType = StubPeriodTypeEnum.LongInitial;
}
}
else if ((bContainsIrregularInitialPeriod && stubPeriodType != null) && (stubPeriodType == StubPeriodTypeEnum.ShortInitial || stubPeriodType == StubPeriodTypeEnum.LongInitial))
{
irregularInitialStubType = (StubPeriodTypeEnum)stubPeriodType;
}
if (bContainsIrregularInitialPeriod)
{
if (backwardRegularPeriods.Count == 0)
{
CalculationPeriod calculationPeriod = CreateUnadjustedCalculationPeriod(startDate, regularPeriodStartDate);
backwardRegularPeriods.Add(calculationPeriod);
}
else
{
backwardRegularPeriods = SetInitialIrregularStubPeriod(backwardRegularPeriods, startDate, irregularInitialStubType);
}
}
}
return(MergeCalculationPeriods(backwardRegularPeriods, forwardRegularPeriods));
}
/// <summary>
/// Sets the final irregular stub period.
/// </summary>
/// <param name="regularPeriods">The regular periods.</param>
/// <param name="endDate">The end date.</param>
/// <param name="stubPeriodType">Type of the stub period.</param>
/// <returns></returns>
static private List <CalculationPeriod> SetFinalIrregularStubPeriod(List <CalculationPeriod> regularPeriods, DateTime endDate, StubPeriodTypeEnum?stubPeriodType)
{
if (stubPeriodType == null)
{
throw new ArgumentNullException("stubPeriodType");
}
CalculationPeriod lastRegularPeriod = regularPeriods[regularPeriods.Count - 1];
if (lastRegularPeriod.unadjustedEndDate < endDate)
{
CalculationPeriod finalStub = CreateUnadjustedCalculationPeriod(lastRegularPeriod.unadjustedStartDate, endDate);
if (stubPeriodType == StubPeriodTypeEnum.LongFinal)
{
regularPeriods.Remove(lastRegularPeriod);
regularPeriods.Add(finalStub);
}
else
{
finalStub.unadjustedStartDate = lastRegularPeriod.unadjustedEndDate;
regularPeriods.Add(finalStub);
}
}
return(regularPeriods);
}
/// <summary>
/// Sets the initial irregular stub period.
/// </summary>
/// <param name="regularPeriods">The regular periods.</param>
/// <param name="startDate">The start date.</param>
/// <param name="stubType">Type of the stub.</param>
/// <returns></returns>
static internal List <CalculationPeriod> SetInitialIrregularStubPeriod(List <CalculationPeriod> regularPeriods, DateTime startDate, StubPeriodTypeEnum?stubType)
{
CalculationPeriod firstRegularPeriod = regularPeriods[0];
if (firstRegularPeriod.unadjustedStartDate > startDate)
{
CalculationPeriod initialStub = CreateUnadjustedCalculationPeriod(startDate, firstRegularPeriod.unadjustedEndDate);
if (stubType == StubPeriodTypeEnum.LongInitial)
{
regularPeriods.Remove(firstRegularPeriod);
regularPeriods.Add(initialStub);
}
else
{
//initialStub.unadjustedEndDate = firstRegularPeriod.unadjustedStartDate;
regularPeriods.Add(initialStub);
}
}
return(regularPeriods);
}