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(); } }
/// <summary> /// Parses the specified interval as string. /// </summary> /// <param name="intervalAsString"><example>3M,3m,14d,6Y</example></param> /// <param name="rollConventionAsString">The roll convention.</param> /// <returns></returns> public static CalculationPeriodFrequency Parse(string intervalAsString, string rollConventionAsString) { var result = new CalculationPeriodFrequency(); Period interval = PeriodHelper.Parse(intervalAsString); result.periodMultiplier = interval.periodMultiplier; result.period = interval.period.ToString(); result.rollConvention = RollConventionEnumHelper.Parse(rollConventionAsString); return(result); }
/// <summary> /// Calculations the period frequency to interval. /// </summary> /// <param name="calculationPeriodFrequency">The calculation period frequency.</param> /// <returns></returns> static public Period CalculationPeriodFrequencyToInterval(CalculationPeriodFrequency calculationPeriodFrequency) { var periodInterval = new Period { period = EnumHelper.Parse <PeriodEnum>(calculationPeriodFrequency.period, true), periodMultiplier = calculationPeriodFrequency.periodMultiplier }; return(periodInterval); }
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); }
public void LongFinalStubSpecifiedButNoStub() { DateTime startDate = new DateTime(2007, 01, 5); DateTime endDate = new DateTime(2012, 01, 5); RollConventionEnum rollConvention = RollConventionEnum.Item5; CalculationPeriodFrequency periodFrequency = CalculationPeriodFrequencyHelper.Parse("3M", rollConvention.ToString()); CalculationPeriodSchedule cps = new CalculationPeriodSchedule(); Period periodInterval = CalculationPeriodHelper.CalculationPeriodFrequencyToInterval(periodFrequency); List <CalculationPeriod> unadjustedCalcPeriods = cps.GetUnadjustedCalculationDateSchedule(startDate, endDate, periodInterval, rollConvention, StubPeriodTypeEnum.LongFinal); Assert.AreEqual(unadjustedCalcPeriods.Count, 20); Assert.IsFalse(cps.HasFinalStub); Assert.IsFalse(cps.HasInitialStub); }
public void LongInitialStubSpecified() { DateTime startDate = new DateTime(2007, 01, 5); DateTime endDate = new DateTime(2012, 01, 5); RollConventionEnum rollConvention = RollConventionEnum.Item26; CalculationPeriodFrequency periodFrequency = CalculationPeriodFrequencyHelper.Parse("3M", rollConvention.ToString()); DateTime firstRegularPeriodDate = new DateTime(2007, 4, 26); CalculationPeriodSchedule cps = new CalculationPeriodSchedule(); List <CalculationPeriod> unadjustedCalcPeriods = cps.GetUnadjustedCalculationDateSchedule(startDate, endDate, firstRegularPeriodDate, periodFrequency, StubPeriodTypeEnum.LongInitial); Assert.AreEqual(unadjustedCalcPeriods.Count, 20); Assert.IsTrue(cps.HasFinalStub); Assert.IsTrue(cps.HasInitialStub); Assert.IsTrue(CalculationPeriodHelper.IsLongStub(unadjustedCalcPeriods[0], cps.PeriodInterval)); }
public void ShortFinalStubSpecifiedFromTermination() { DateTime startDate = new DateTime(2007, 01, 5); DateTime endDate = new DateTime(2010, 01, 5); RollConventionEnum rollConvention = RollConventionEnum.Item12; CalculationPeriodFrequency periodFrequency = CalculationPeriodFrequencyHelper.Parse("3M", rollConvention.ToString()); Period periodInterval = CalculationPeriodHelper.CalculationPeriodFrequencyToInterval(periodFrequency); CalculationPeriodSchedule cps = new CalculationPeriodSchedule(); DateTime lastRegularPeriodEndDate = new DateTime(2009, 8, 12); List <CalculationPeriod> unadjustedCalcPeriods = cps.GetUnadjustedCalculationDateScheduleFromTermDate(startDate, endDate, periodInterval, lastRegularPeriodEndDate, rollConvention, StubPeriodTypeEnum.ShortFinal); Assert.AreEqual(unadjustedCalcPeriods.Count, 13); Assert.IsTrue(cps.HasFinalStub); Assert.IsTrue(cps.HasInitialStub); Assert.IsTrue(CalculationPeriodHelper.IsShortStub(unadjustedCalcPeriods[unadjustedCalcPeriods.Count - 1], cps.PeriodInterval)); }
public void RegularPeriodFrequencyUnadjustedDates() { // 5 year 3 month cash flow DateTime startDate = new DateTime(2007, 01, 5); RollConventionEnum rollConvention = RollConventionEnum.Item26; CalculationPeriodFrequency frequencyToMaturity = CalculationPeriodFrequencyHelper.Parse("5Y", rollConvention.ToString()); CalculationPeriodFrequency periodFrequency = CalculationPeriodFrequencyHelper.Parse("3M", rollConvention.ToString()); CalculationPeriodSchedule cps = new CalculationPeriodSchedule(); List <CalculationPeriod> unadjustedCalcPeriods = cps.GetUnadjustedCalculationDateSchedule(startDate, frequencyToMaturity, periodFrequency); List <DateTime> dates = CalculationPeriodHelper.GetCalculationPeriodsProperty <DateTime>(unadjustedCalcPeriods, "unadjustedStartDate"); Assert.AreEqual(unadjustedCalcPeriods.Count, 20); Assert.IsFalse(cps.HasInitialStub); Assert.IsFalse(cps.HasFinalStub); }
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); }
//public static CalculationPeriodsPrincipalExchangesAndStubs GenerateUnadjustedCalculationPeriods( // IBusinessCalendar paymentCalendar, // DateTime unadjustedStartDate, // DateTime unadjustedEndDate, // CalculationPeriodFrequency frequency, // StubPeriodTypeEnum? initialStubType, // StubPeriodTypeEnum? finalStubType // ) //{ // // If first roll date not specified - calculate it from the start date. // // // DateTime unadjustedFirstRollDate = AddPeriod(unadjustedStartDate, frequency, 1); // return GenerateUnadjustedCalculationPeriods(unadjustedStartDate, unadjustedEndDate, unadjustedFirstRollDate, frequency, initialStubType, finalStubType); //} public static CalculationPeriodsPrincipalExchangesAndStubs GenerateAdjustedCalculationPeriods( DateTime unadjustedStartDate, DateTime unadjustedTerminationDate, DateTime?firstUnadjustedRegularPeriodStartDate, DateTime?lastUnadjustedRegularPeriodEndDate, CalculationPeriodFrequency frequency, BusinessDayAdjustments calculationPeriodDatesAdjustments, IBusinessCalendar paymentCalendar) { var result = new CalculationPeriodsPrincipalExchangesAndStubs(); // Generate periods backwards (toward the unadjustedEffectiveDate) // GeneratePeriods(unadjustedStartDate, unadjustedTerminationDate, firstUnadjustedRegularPeriodStartDate, lastUnadjustedRegularPeriodEndDate, frequency, calculationPeriodDatesAdjustments, result, paymentCalendar); result.CalculationPeriods.Sort((calculationPeriod1, calculationPeriod2) => calculationPeriod1.adjustedEndDate.CompareTo(calculationPeriod2.adjustedEndDate)); return(result); }
/// <summary> /// Gets the backward regular periods. /// </summary> /// <param name="startDate">The start date.</param> /// <param name="endDate">The end date.</param> /// <param name="calculationPeriodFrequency">The calculation period frequency.</param> /// <param name="hasIrregularPeriod">if set to <c>true</c> [has irregular period].</param> /// <returns></returns> static public List <CalculationPeriod> GetBackwardRegularPeriods(DateTime startDate, DateTime endDate, CalculationPeriodFrequency calculationPeriodFrequency, out Boolean hasIrregularPeriod) { return(GetBackwardRegularPeriods(startDate, endDate, CalculationPeriodFrequencyToInterval(calculationPeriodFrequency), calculationPeriodFrequency.rollConvention, out hasIrregularPeriod)); }
/// <summary> /// Gets the last regular period end date. /// </summary> /// <param name="frequencyToLastRegularPeriodEndDate">The frequency to last regular period end date.</param> /// <param name="endDate">The end date.</param> /// <returns></returns> public static DateTime GetLastRegularPeriodEndDate(CalculationPeriodFrequency frequencyToLastRegularPeriodEndDate, DateTime endDate) { Period periodInterval = CalculationPeriodFrequencyToInterval(frequencyToLastRegularPeriodEndDate); return(GetLastRegularPeriodEndDate(periodInterval, frequencyToLastRegularPeriodEndDate.rollConvention, endDate)); }
/// <summary> /// Gets the first regular period start date. /// </summary> /// <param name="calculationPeriodFrequency">The calculation period frequency.</param> /// <param name="startDate">The start date.</param> /// <returns></returns> public static DateTime GetFirstRegularPeriodStartDate(CalculationPeriodFrequency calculationPeriodFrequency, DateTime startDate) { Period periodInterval = CalculationPeriodFrequencyToInterval(calculationPeriodFrequency); return(GetFirstRegularPeriodStartDate(periodInterval, calculationPeriodFrequency.rollConvention, startDate)); }
public static void GeneratePeriods(DateTime unadjustedStartDate, DateTime unadjustedTerminationDate, DateTime?firstUnadjustedRegularPeriodStartDate, DateTime?lastUnadjustedRegularPeriodEndDate, //StubPeriodTypeEnum? initialStubType, //StubPeriodTypeEnum? finalStubType, CalculationPeriodFrequency frequency, BusinessDayAdjustments calculationPeriodDatesAdjustments, CalculationPeriodsPrincipalExchangesAndStubs result, IBusinessCalendar paymentCalendar) { DateTime periodEndDate = unadjustedTerminationDate; DateTime periodStartDate; bool isInitialStub = firstUnadjustedRegularPeriodStartDate != null; var startDate = unadjustedStartDate; if (isInitialStub) { startDate = (DateTime)firstUnadjustedRegularPeriodStartDate; } var isFinalStub = lastUnadjustedRegularPeriodEndDate != null; if (isFinalStub) { periodStartDate = (DateTime)lastUnadjustedRegularPeriodEndDate; } else { periodStartDate = AddPeriod(periodEndDate, IntervalHelper.FromFrequency(frequency), -1); } var isFirstPeriod = true; do { var calculationPeriod = Create(periodStartDate, periodEndDate, frequency, calculationPeriodDatesAdjustments, paymentCalendar, isFirstPeriod); isFirstPeriod = false; //adjust for roll convention. periodStartDate = calculationPeriod.unadjustedStartDate; periodEndDate = calculationPeriod.unadjustedEndDate; if (isFinalStub)//Always at least one period. { result.FinalStubCalculationPeriod = calculationPeriod; periodEndDate = periodStartDate; periodStartDate = AddPeriod(periodEndDate, IntervalHelper.FromFrequency(frequency), -1); isFinalStub = false; } else if (calculationPeriod.unadjustedStartDate.Date >= startDate.Date) { result.Add(calculationPeriod); periodEndDate = periodStartDate; periodStartDate = AddPeriod(periodEndDate, IntervalHelper.FromFrequency(frequency), -1); } else if (calculationPeriod.unadjustedStartDate.Date == startDate.Date)//first period - not stub { result.Add(calculationPeriod); break; } else if (calculationPeriod.unadjustedStartDate.Date < startDate.Date)//first period - not stub { var number = result.CalculationPeriods.Count; result.CalculationPeriods[number - 1].unadjustedStartDate = startDate.Date; result.CalculationPeriods[number - 1].adjustedStartDate = startDate.Date; break; } if (calculationPeriod.unadjustedEndDate.Date <= startDate.Date)//first period - not stub { break; } } while (true); if (isInitialStub)//TODO -Fix the unadjustedstartdate which is affected by the roll convention. { var calculationPeriod = CreateStub(unadjustedStartDate, startDate.Date, calculationPeriodDatesAdjustments, paymentCalendar); result.InitialStubCalculationPeriod = calculationPeriod; } }
/// <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> /// Gets the unadjusted calculation date schedule. /// </summary> /// <param name="effectiveDate">The effective date.</param> /// <param name="periodToTerminationDate">The period to termination date.</param> /// <param name="periodFrequency">The period frequency.</param> /// <returns></returns> public List <CalculationPeriod> GetUnadjustedCalculationDateSchedule(DateTime effectiveDate, CalculationPeriodFrequency periodToTerminationDate, CalculationPeriodFrequency periodFrequency) { CalculationPeriodDates = null; PeriodInterval = CalculationPeriodHelper.CalculationPeriodFrequencyToInterval(periodFrequency); _effectiveDate = effectiveDate; _termDate = PeriodInterval.Add(effectiveDate); RollConvention = periodFrequency.rollConvention; _unadjustedDateScheduleList = CalculationPeriodHelper.GenerateUnadjustedCalculationDates(effectiveDate, periodToTerminationDate, periodFrequency); return(_unadjustedDateScheduleList); }
/// <summary> /// Generates the unadjusted calculation dates. /// </summary> /// <param name="effectiveDate">The effective date.</param> /// <param name="periodToTerminationDate">The period to termination date.</param> /// <param name="periodFrequecy">The period frequecy.</param> /// <returns></returns> static public List <CalculationPeriod> GenerateUnadjustedCalculationDates(DateTime effectiveDate, CalculationPeriodFrequency periodToTerminationDate, CalculationPeriodFrequency periodFrequecy) { Period intervalToTerminationDate = CalculationPeriodFrequencyToInterval(periodToTerminationDate); Period periodInterval = CalculationPeriodFrequencyToInterval(periodFrequecy); return(GenerateUnadjustedCalculationDates(effectiveDate, intervalToTerminationDate, periodInterval, periodFrequecy.rollConvention)); }
/// <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)); }