/// <summary>Initializes a new instance of the <see cref="ForwardStartingTimeframeDescription"/> class. /// </summary> /// <param name="startDateTenor">The tenor use to calculate the start date.</param> /// <param name="tenor">The tenor that represents the time span.</param> /// <param name="spotDateAdjustment">A business day convention used to compute the spot date, i.e. reference date + a number of business days to settle (if <paramref name="startDateTenor"/> is regular).</param> /// <param name="startDateAdjustment">A business day convention used to compute the start date of the period.</param> /// <param name="endDateAdjustment">A business day convention used to compute the end date of the period.</param> /// <param name="businessDaysToSettle">The number of business days used to calculate the spot date; this parameter will be taken into if and only if <paramref name="startDateTenor"/> is a regular tenor (i.e. neigther overnight nor tomorrow-next).</param> /// <exception cref="ArgumentException">Thrown, if <paramref name="startDateTenor"/> or <paramref name="tenor"/> represents a negative time span or <paramref name="tenor"/> does not represents a regular tenor (<see cref="TenorType.RegularTenor"/>).</exception> /// <exception cref="ArgumentNullException">Thrown, if one of the <see cref="IBusinessDayConvention"/> arguments is <c>null</c>.</exception> public ForwardStartingTimeframeDescription(TenorTimeSpan startDateTenor, TenorTimeSpan tenor, IBusinessDayConvention spotDateAdjustment, IBusinessDayConvention startDateAdjustment, IBusinessDayConvention endDateAdjustment, int businessDaysToSettle = 0) { if (startDateTenor.IsPositive == false) { throw new ArgumentException(String.Format(ExceptionMessages.ArgumentIsInvalid, startDateTenor.ToString()), "startDateTenor"); } StartDateTenor = startDateTenor; if ((tenor.IsPositive == false) || (tenor.TenorType != TenorType.RegularTenor)) // ON, TN are not allowed { throw new ArgumentException(String.Format(ExceptionMessages.ArgumentIsInvalid, tenor.ToString()), "tenor"); } Tenor = tenor; if (spotDateAdjustment == null) { throw new ArgumentNullException("spotDateAdjustment"); } SpotDateAdjustment = spotDateAdjustment; if (startDateAdjustment == null) { throw new ArgumentNullException("startDateAdjustment"); } StartDateAdjustment = startDateAdjustment; if (endDateAdjustment == null) { throw new ArgumentNullException("endDateAdjustment"); } EndDateAdjustment = endDateAdjustment; BusinessDaysToSettle = businessDaysToSettle; }
/// <summary>Gets a date schedule frequency. /// </summary> /// <param name="frequency">The frequency in its <see cref="System.String"/> representation; perhaps a <see cref="TenorTimeSpan"/> in its <see cref="System.String"/> representation.</param> /// <param name="value">The date schedule frequency (output).</param> /// <param name="addIntoPool">If <paramref name="frequency"/> represents a individual frequency, /// the corresponding <see cref="IDateScheduleFrequency"/> will be added to the <see cref="DateScheduleFrequency"/> if set to <c>true</c>.</param> /// <returns>A value indicating whether <paramref name="value"/> contains valid data.</returns> /// <remarks>If <paramref name="frequency"/> does not represents an item of the pool, try to create to convert <paramref name="frequency"/> to a <see cref="TenorTimeSpan"/> object first.</remarks> public static bool TryGetValue(string frequency, out IDateScheduleFrequency value, bool addIntoPool = false) { if ((frequency == null) || (frequency.Length == 0)) { value = null; return(false); } if (sm_Pool.TryGetValue(frequency, out value) == true) { return(true); } TenorTimeSpan tenorFrequency; // try to generate a individual frequency: if (TenorTimeSpan.TryParse(frequency, out tenorFrequency) == false) { value = null; return(false); } if (IndividualDateScheduleFrequency.TryCreate(tenorFrequency, out value) == true) { if (addIntoPool) { sm_Pool.Add(value); } return(true); } value = null; return(false); }
/// <summary>Initializes a new instance of the <see cref="PeriodicInterestCompounding"/> class. /// </summary> /// <param name="frequency">The frequency of the compounding.</param> protected internal PeriodicInterestCompounding(IDateScheduleFrequency frequency) { if (frequency == null) { throw new ArgumentNullException("frequency"); } Frequency = frequency; TenorTimeSpan frequencyTenor = frequency.GetFrequencyTenor(); if (TenorTimeSpan.IsNull(frequencyTenor) == true) { throw new ArgumentException("frequency"); } if (frequencyTenor.Years != 0) { PaymentsPerYear = 1.0 / frequencyTenor.Years; } if (frequencyTenor.Months != 0) { PaymentsPerYear += 12.0 / frequencyTenor.Months; } if (frequencyTenor.Days != 0) { PaymentsPerYear += 365.0 / frequencyTenor.Days; } }
/// <summary>Initializes a new instance of the <see cref="SimpleThenPeriodicCompounding" /> class. /// </summary> /// <param name="frequency">The frequency of the compounding to apply after time-to-maturity of one year.</param> internal SimpleThenPeriodicCompounding(IDateScheduleFrequency frequency) { if (frequency == null) { throw new ArgumentNullException("frequency"); } Frequency = frequency; var frequencyTenor = frequency.GetFrequencyTenor(); if (TenorTimeSpan.IsNull(frequencyTenor) == true) { throw new ArgumentException("frequency"); } if (frequencyTenor.Years != 0) { PaymentsPerYear = 1.0 / frequencyTenor.Years; } if (frequencyTenor.Months != 0) { PaymentsPerYear += 12.0 / frequencyTenor.Months; } if (frequencyTenor.Days != 0) { PaymentsPerYear += 365.0 / frequencyTenor.Days; } Name = new IdentifierString(String.Format("Simple;{0}", Frequency.Name.String)); }
/// <summary>Creates a new <see cref="ITimeframeDescription"/> object. /// </summary> /// <param name="startDateTenor">The tenor use to calculate the start date.</param> /// <param name="tenor">The tenor that represents the time span.</param> /// <param name="businessDayConvention">The business day convention used to compute the spot date, start date as well as the end date of the timeframe.</param> /// <param name="businessDaysToSettle">The number of business days used to calculate the spot date; this parameter will be taken into account if and only if <paramref name="startDateTenor"/> is a regular tenor (i.e. neigther overnight nor tomorrow-next).</param> /// <returns>A <see cref="ITimeframeDescription"/> object where the implementation works in the following way: /// <para>The implementation works in the following way: /// <list type="number"> /// <item><description>Apply the SpotDateAdjustment to the reference date; call it spot date.</description></item> /// <item><description>For regular tenor with a number of business days to settle [in short: BD-ToSettle] != 0 or tomorrow-next, point the spot date to the /// next (or previous if BD-ToSettle is lesss than 0) business day and add BD-ToSettle business days. This is the final spot date.</description></item> /// <item><description>Apply the start tenor to the spot date and apply the StartDateAdjustment. This is the start date of the period.</description></item> /// <item><description>Add the tenor to the start date and apply the EndDateAdjustment which gives us the end date.</description></item> /// </list></para></returns> /// <exception cref="ArgumentException">Thrown, if <paramref name="startDateTenor"/> or <paramref name="tenor"/> represents a negative time span.</exception> /// <exception cref="ArgumentNullException">Thrown, if <paramref name="businessDayConvention"/> is <c>null</c>.</exception> public static ITimeframeDescription Create(TenorTimeSpan startDateTenor, TenorTimeSpan tenor, IBusinessDayConvention businessDayConvention, int businessDaysToSettle = 0) { if (businessDayConvention == null) { throw new ArgumentNullException("businessDayConvention"); } return(new ForwardStartingTimeframeDescription(startDateTenor, tenor, businessDayConvention, businessDayConvention, businessDayConvention, businessDaysToSettle)); }
public void ToRawYearFraction_7Y3M__1_5() { TenorTimeSpan tenorTimeSpan = new TenorTimeSpan(7, 3, 0); double actual = tenorTimeSpan.ToRawYearFraction(); double expected = 7.25; Assert.That(actual, Is.EqualTo(expected).Within(1E-6)); }
/// <summary>Gets a <see cref="IndividualDateScheduleFrequency"/> object. /// </summary> /// <param name="frequencyTenor">The frequency tenor.</param> /// <param name="individualDateScheduleFrequency">The individual date schedule frequency (output).</param> /// <returns>A value indicating whether <paramref name="individualDateScheduleFrequency"/> contains valid data.</returns> internal static bool TryCreate(TenorTimeSpan frequencyTenor, out IDateScheduleFrequency individualDateScheduleFrequency) { if (TenorTimeSpan.IsNull(frequencyTenor) || (frequencyTenor.IsPositive == false)) { individualDateScheduleFrequency = null; return(false); } individualDateScheduleFrequency = new IndividualDateScheduleFrequency(frequencyTenor); return(true); }
public void Parse_TestCase(string tenorString, int expectedYears, int expectedMonths, int expectedDays, bool expectedIsPositive, TenorType expectedTenorType) { TenorTimeSpan actualTenor = TenorTimeSpan.Parse(tenorString); Assert.That(actualTenor.Years, Is.EqualTo(expectedYears), "Years component"); Assert.That(actualTenor.Months, Is.EqualTo(expectedMonths), "Months component"); Assert.That(actualTenor.Days, Is.EqualTo(expectedDays), "Days component"); Assert.That(actualTenor.TenorType, Is.EqualTo(expectedTenorType), "Tenor type component"); Assert.That(actualTenor.IsPositive, Is.EqualTo(expectedIsPositive), "IsPositive component"); }
/// <summary>Initializes a new instance of the <see cref="IRCapletTenorConventionConstant"/> class. /// </summary> /// <param name="liborRateTenor">The (unique) libor rate tenor.</param> /// <exception cref="ArgumentException">Thrown, if <paramref name="liborRateTenor"/> represents a tenor leq or equal <c>0</c>.</exception> public IRCapletTenorConventionConstant(TenorTimeSpan liborRateTenor) { if (TenorTimeSpan.IsNull(liborRateTenor) || (liborRateTenor.IsPositive == false)) { throw new ArgumentException("liborRateTenor"); } m_LiborRateTenor = liborRateTenor.AsFrequency(); m_Name = new IdentifierString(String.Format("Constant caplet tenor {0}", liborRateTenor.ToString())); m_LongName = new IdentifierString(String.Format(IRCapletTenorConventionResources.ConstantTenorLongName, liborRateTenor.ToString())); }
/// <summary>Initializes a new instance of the <see cref="IndividualDateScheduleFrequency"/> class. /// </summary> /// <param name="frequencyTenor">The frequency tenor.</param> /// <exception cref="ArgumentException">Thrown, if <paramref name="frequencyTenor"/> represents a /// tenor with a negative sign or the null-tenor.</exception> /// <remarks>The <see cref="Name"/> will be set to the <see cref="System.String"/> representation of /// <paramref name="frequencyTenor"/>.</remarks> public IndividualDateScheduleFrequency(TenorTimeSpan frequencyTenor) { if (TenorTimeSpan.IsNull(frequencyTenor) || (frequencyTenor.IsPositive == false)) { throw new ArgumentException("frequencyTenor"); } m_FrequencyTenor = frequencyTenor; string frequencyTenorAsString = frequencyTenor.ToString(); m_Name = new IdentifierString(frequencyTenorAsString); m_LongName = new IdentifierString(String.Format(DateFactoryResources.IndividualLongName, frequencyTenorAsString)); }
/// <summary>Initializes a new instance of the <see cref="NextPeriod"/> class. /// </summary> /// <param name="tenor">The tenor that represents the time span.</param> /// <param name="startDateAdjustment">A business day convention used to compute the start date of the period, i.e. the IMM date.</param> /// <param name="endDateAdjustment">A business day convention used to compute the end date of the period.</param> public NextPeriod(TenorTimeSpan tenor, IBusinessDayConvention startDateAdjustment, IBusinessDayConvention endDateAdjustment) { Tenor = tenor; if (startDateAdjustment == null) { throw new ArgumentNullException("startDateAdjustment"); } StartDateAdjustment = startDateAdjustment; if (endDateAdjustment == null) { throw new ArgumentNullException("endDateAdjustment"); } EndDateAdjustment = endDateAdjustment; }
/// <summary>Initializes a new instance of the <see cref="SpecificPeriod"/> class. /// </summary> /// <param name="month">The month of the period start date in its <see cref="IMM.Month"/> representation.</param> /// <param name="periodStartYearOffset">The number of years to add to the reference date in <c>GetStartAndEndDate(.)</c> to take into account for the calculation of the specific IMM date.</param> /// <param name="tenor">The tenor that represents the time span.</param> /// <param name="startDateAdjustment">A business day convention used to compute the start date of the period, i.e. the IMM date.</param> /// <param name="endDateAdjustment">A business day convention used to compute the end date of the period.</param> public SpecificPeriod(Month month, int periodStartYearOffset, TenorTimeSpan tenor, IBusinessDayConvention startDateAdjustment, IBusinessDayConvention endDateAdjustment) { Tenor = tenor; PeriodStartMonth = month; PeriodStartYearOffset = periodStartYearOffset; if (startDateAdjustment == null) { throw new ArgumentNullException("startDateAdjustment"); } StartDateAdjustment = startDateAdjustment; if (endDateAdjustment == null) { throw new ArgumentNullException("endDateAdjustment"); } EndDateAdjustment = endDateAdjustment; }
/// <summary>Initializes a new instance of the <see cref="TenorTimeframeDescription"/> class. /// </summary> /// <param name="tenor">The tenor that represents the time span.</param> /// <param name="spotDateAdjustment">A business day convention used to compute the spot date, i.e. reference date + a number of business days to settle (if <paramref name="tenor"/> is regular).</param> /// <param name="startDateAdjustment">A business day convention used to compute the start date of the period.</param> /// <param name="endDateAdjustment">A business day convention used to compute the end date of the period.</param> /// <param name="businessDaysToSettle">The number of business days used to calculate the spot date; this parameter will be taken into if and only if <paramref name="tenor"/> is a regular tenor (i.e. neigther overnight nor tomorrow-next).</param> /// <exception cref="ArgumentException">Thrown, if <paramref name="tenor"/> represents a negative time span.</exception> /// <exception cref="ArgumentNullException">Thrown, if one of the <see cref="IBusinessDayConvention"/> arguments is <c>null</c>.</exception> public TenorTimeframeDescription(TenorTimeSpan tenor, IBusinessDayConvention spotDateAdjustment, IBusinessDayConvention startDateAdjustment, IBusinessDayConvention endDateAdjustment, int businessDaysToSettle = 0) { if (tenor.IsPositive == false) { throw new ArgumentException(String.Format(ExceptionMessages.ArgumentIsInvalid, tenor.ToString()), "tenor"); } Tenor = tenor; if (spotDateAdjustment == null) { throw new ArgumentNullException("spotDateAdjustment"); } SpotDateAdjustment = spotDateAdjustment; if (startDateAdjustment == null) { throw new ArgumentNullException("startDateAdjustment"); } StartDateAdjustment = startDateAdjustment; if (endDateAdjustment == null) { throw new ArgumentNullException("endDateAdjustment"); } EndDateAdjustment = endDateAdjustment; BusinessDaysToSettle = businessDaysToSettle; }
/// <summary>Creates a new <see cref="ITimeframeDescription"/> object. /// </summary> /// <param name="startDateTenor">The tenor use to calculate the start date.</param> /// <param name="tenor">The tenor that represents the time span.</param> /// <param name="spotDateAdjustment">A business day convention used to compute the spot date (= reference date + a number of business days to settle [if <paramref name="startDateTenor"/> is regular or one business day in the case of tomorrow-next]); if <c>null</c> no adjustment will be applied.</param> /// <param name="startDateAdjustment">A business day convention used to compute the start date of the timeframe; if <c>null</c> no adjustment will be applied.</param> /// <param name="endDateAdjustment">A business day convention used to compute the end date of the timeframe; if <c>null</c> no adjustment will be applied.</param> /// <param name="businessDaysToSettle">The number of business days used to calculate the spot date; this parameter will be taken into account if and only if <paramref name="startDateTenor"/> is a regular tenor (i.e. neigther overnight nor tomorrow-next).</param> /// <returns>A <see cref="ITimeframeDescription"/> object where the implementation works in the following way: /// <para>The implementation works in the following way: /// <list type="number"> /// <item><description>Apply the SpotDateAdjustment to the reference date; call it spot date.</description></item> /// <item><description>For regular tenor with a number of business days to settle [in short: BD-ToSettle] != 0 or tomorrow-next, point the spot date to the /// next (or previous if BD-ToSettle is lesss than 0) business day and add BD-ToSettle business days. This is the final spot date.</description></item> /// <item><description>Apply the start tenor to the spot date and apply the StartDateAdjustment. This is the start date of the period.</description></item> /// <item><description>Add the tenor to the start date and apply the EndDateAdjustment which gives us the end date.</description></item> /// </list></para></returns> /// <exception cref="ArgumentException">Thrown, if <paramref name="startDateTenor"/> or <paramref name="tenor"/> represents a negative time span.</exception> public static ITimeframeDescription Create(TenorTimeSpan startDateTenor, TenorTimeSpan tenor, IBusinessDayConvention spotDateAdjustment, IBusinessDayConvention startDateAdjustment, IBusinessDayConvention endDateAdjustment, int businessDaysToSettle = 0) { return(new ForwardStartingTimeframeDescription(startDateTenor, tenor, (spotDateAdjustment != null) ? spotDateAdjustment : sm_NoAdjustment, (startDateAdjustment != null) ? startDateAdjustment : sm_NoAdjustment, (endDateAdjustment != null) ? endDateAdjustment : sm_NoAdjustment, businessDaysToSettle)); }
/// <summary>Gets the tenor of the underlying Libor rate if the tenor is equal for each caplet. /// </summary> /// <param name="liborTenor">The (unique) tenor of the underlying Libor rate.</param> /// <returns> /// A value indicating whether <paramref name="liborTenor"/> contains valid data /// and a unique tenor is available. /// </returns> /// <remarks>This method returns the same value as <see cref="IIRCapletTenorConvention.HasUniqueLiborTenor"/>.</remarks> public bool TryGetUniqueUnderlyingLiborTenor(out TenorTimeSpan liborTenor) { liborTenor = m_LiborRateTenor.GetFrequencyTenor(); return(true); }
public TenorTimeSpan GetTimeSpanInBetween_TestCase(DateTime startDate, DateTime endDate, TenorTimeSpan.RoundingRule roundingRule) { return(TenorTimeSpan.GetTimeSpanInBetween(startDate, endDate, roundingRule)); }
public DateTime AddTenorTimeSpan_TestCase(DateTime startDate, TenorTimeSpan tenorTimeSpan, int tenorTimeSpanFactor) { return(TenorTimeSpanExtensions.AddTenorTimeSpan(startDate, tenorTimeSpan, tenorTimeSpanFactor)); }
/// <summary>Adds some <see cref="System.DateTime"/> objects into a specific date schedule. /// </summary> /// <param name="dateSchedule">The date schedule.</param> /// <exception cref="NotOperableException">Thrown, if the current instance it not operable.</exception> public void AddDatesToDateSchedule(DateSchedule dateSchedule) { if (IsOperable == false) { throw new NotOperableException("BackwardDateScheduleRule"); } DateTime firstDate, terminationDate; m_TimeSpanDescription.GetStartAndEndDate(m_ReferenceDate, dateSchedule.HolidayCalendar, out firstDate, out terminationDate, dateSchedule.Logging); if (terminationDate < firstDate) { throw new ArgumentException(String.Format(ExceptionMessages.ArgumentOutOfRangeGreaterEqual, "End date [" + terminationDate.ToShortDateString() + "]", "first date [" + firstDate.ToShortDateString() + "]")); } dateSchedule.Add(terminationDate); // add the end date // gets the date which is used as 'base date' for the date generation loop: DateTime seed = terminationDate; if ((m_LastRegularDate != null) && (m_LastRegularDate.HasValue)) // 'last regular date' is given { seed = m_LastRegularDate.Value; if (seed > terminationDate) { throw new ArgumentException(String.Format(ExceptionMessages.ArgumentOutOfRangeLessEqual, "Last regular date [" + seed.ToShortDateString() + "]", "end date [" + terminationDate.ToShortDateString() + "]")); } } if (m_SeedBusinessDayConvention != null) // perhaps adjust the 'base date' which is used for the date generation loop { seed = m_SeedBusinessDayConvention.GetAdjustedDate(seed, dateSchedule.HolidayCalendar); } else { seed = m_BusinessDayConvention.GetAdjustedDate(seed, dateSchedule.HolidayCalendar); } dateSchedule.Add(seed); // gets the exit condition for the loop: DateTime exitDate = firstDate; // perhaps not a business day if ((m_FirstRegularDate != null) && (m_FirstRegularDate.HasValue)) { exitDate = m_FirstRegularDate.Value; if (exitDate > seed) { throw new ArgumentException(String.Format(ExceptionMessages.ArgumentOutOfRangeLessEqual, "First regular date [" + exitDate.ToShortDateString() + "]", "last [regular] date [" + seed.ToShortDateString() + "]")); } } if (m_Frequency.IsOnceFrequency()) // end date and seed date are already added { if (exitDate != firstDate) // perhaps add the first regular date { dateSchedule.Add(exitDate); // one may apply the business day convention to the first regular date } } else // do the loop with respect to the frequency { TenorTimeSpan frequencyTenor = m_Frequency.GetFrequencyTenor(); DateTime runningDate = m_BusinessDayConvention.GetAdjustedDate(seed.AddTenorTimeSpan(frequencyTenor), dateSchedule.HolidayCalendar); int periodIndex = -1; while (runningDate >= exitDate) { dateSchedule.Add(runningDate); periodIndex--; runningDate = seed.AddTenorTimeSpan(frequencyTenor, periodIndex); runningDate = m_BusinessDayConvention.GetAdjustedDate(runningDate, dateSchedule.HolidayCalendar); } } dateSchedule.Add(firstDate); }
/// <summary>Gets the tenor of the underlying Libor rate if the tenor is equal for each caplet. /// </summary> /// <param name="liborTenor">The (unique) tenor of the underlying Libor rate.</param> /// <returns>A value indicating whether <paramref name="liborTenor"/> contains valid data /// and a unique tenor is available. /// </returns> public bool TryGetUniqueUnderlyingLiborTenor(out TenorTimeSpan liborTenor) { liborTenor = TenorTimeSpan.Null; return(false); }
public TenorTimeSpan AddTimeSpan_TestCase(TenorTimeSpan tenorTimeSpan, TenorTimeSpan tenorTimeSpanToAdd, int tenorTimeSpanFactor) { return(TenorTimeSpanExtensions.AddTimeSpan(tenorTimeSpan, tenorTimeSpanToAdd, tenorTimeSpanFactor)); }
/// <summary>Creates a new <see cref="ITimeframeDescription"/> object, where the start date of the period is a IMM date.</summary> /// <param name="month">The month of the period start date in its <see cref="IMM.Month"/> representation.</param> /// <param name="periodStartYearOffset">The number of years to add to the reference date in <c>GetStartAndEndDate(.)</c> to take into account for the calculation of the specific IMM date.</param> /// <param name="tenor">The tenor that represents the time span.</param> /// <param name="startDateAdjustment">A business day convention used to compute the start date of the period, i.e. the IMM date.</param> /// <param name="endDateAdjustment">A business day convention used to compute the end date of the period.</param> /// <returns>The specified <see cref="ITimeframeDescription"/> object.</returns> public static ITimeframeDescription Create(Month month, int periodStartYearOffset, TenorTimeSpan tenor, IBusinessDayConvention startDateAdjustment, IBusinessDayConvention endDateAdjustment) { return(new SpecificPeriod(month, periodStartYearOffset, tenor, startDateAdjustment, endDateAdjustment)); }
/// <summary>Creates a new <see cref="ITimeframeDescription"/> object, where the start date of the period is the next IMM date with respect to the reference date of the time period calculation.</summary> /// <param name="tenor">The tenor that represents the time span.</param> /// <param name="startDateAdjustment">A business day convention used to compute the start date of the period, i.e. the IMM date.</param> /// <param name="endDateAdjustment">A business day convention used to compute the end date of the period.</param> /// <returns>The specified <see cref="ITimeframeDescription"/> object.</returns> public static ITimeframeDescription Create(TenorTimeSpan tenor, IBusinessDayConvention startDateAdjustment, IBusinessDayConvention endDateAdjustment) { return(new NextPeriod(tenor, startDateAdjustment, endDateAdjustment)); }
public bool IsInsideTimeSpan_TestCase(DateTime startDate, TenorTimeSpan tenorTimeSpan, DateTime testDate, int deferredDays) { return(tenorTimeSpan.IsInsideTimeSpan(startDate, testDate, deferredDays)); }
/// <summary>Gets the start and end date of the timeframe. /// </summary> /// <param name="referenceDate">A reference date (can be a business day or a holiday).</param> /// <param name="holidayCalendar">The (settlement) holiday calendar.</param> /// <param name="fixingLag">The fixing lag, i.e. a method used to calculate the fixing date with respect to the period. Will be applied to the IMM Date (even if the IMM date is not a business day).</param> /// <param name="startDate">The start date of the time span with respect to <paramref name="referenceDate"/> (output).</param> /// <param name="endDate">The end date of the time span with respect to <paramref name="referenceDate"/> (output).</param> /// <param name="tenor">The tenor that represents the time span; if the end date of the current object is not specified by its <see cref="TenorTimeSpan"/> representation, <paramref name="tenorRoundingRule"/> /// will be applied to <paramref name="startDate"/> and <paramref name="endDate"/> for the calculation of a <see cref="TenorTimeSpan"/> representation.</param> /// <param name="tenorRoundingRule"> A rounding rule which will be take into account if and only if the end date of the current object is not specified by its <see cref="TenorTimeSpan"/> representation.</param> /// <param name="logger">An optional logger.</param> public DateTime GetStartAndEndDate(DateTime referenceDate, IHolidayCalendar holidayCalendar, IFixingLag fixingLag, out DateTime startDate, out DateTime endDate, out TenorTimeSpan tenor, TenorTimeSpan.RoundingRule tenorRoundingRule = TenorTimeSpan.RoundingRule.NearestMonth, ILogger logger = null) { tenor = Tenor; return(GetStartAndEndDate(referenceDate, holidayCalendar, fixingLag, out startDate, out endDate, logger)); }
/// <summary>Gets the start and end date of the timeframe. /// </summary> /// <param name="referenceDate">A reference date (can be a business day or a holiday).</param> /// <param name="holidayCalendar">The (settlement) holiday calendar.</param> /// <param name="startDate">The start date of the time span with respect to <paramref name="referenceDate"/> (output).</param> /// <param name="endDate">The end date of the time span with respect to <paramref name="referenceDate"/> (output).</param> /// <param name="tenor">The tenor that represents the time span; if the end date of the current object is not specified by its <see cref="TenorTimeSpan"/> representation, <paramref name="tenorRoundingRule"/> /// will be applied to <paramref name="startDate"/> and <paramref name="endDate"/> for the calculation of a <see cref="TenorTimeSpan"/> representation.</param> /// <param name="tenorRoundingRule"> A rounding rule which will be take into account if and only if the end date of the current object is not specified by its <see cref="TenorTimeSpan"/> representation.</param> /// <param name="logger">An optional logger.</param> public void GetStartAndEndDate(DateTime referenceDate, IHolidayCalendar holidayCalendar, out DateTime startDate, out DateTime endDate, out TenorTimeSpan tenor, TenorTimeSpan.RoundingRule tenorRoundingRule = TenorTimeSpan.RoundingRule.NearestMonth, ILogger logger = null) { tenor = Tenor; GetStartAndEndDate(referenceDate, holidayCalendar, out startDate, out endDate, logger); }
/// <summary>Determines whether a specified date schedule frequency is the frequency 'once'. /// </summary> /// <param name="dateScheduleFrequency">The date schedule frequency.</param> /// <returns> /// <c>true</c> if the specified date schedule frequency is the frequency 'once'; otherwise, <c>false</c>. /// </returns> public static bool IsOnceFrequency(this IDateScheduleFrequency dateScheduleFrequency) { return((dateScheduleFrequency != null) ? TenorTimeSpan.IsNull(dateScheduleFrequency.GetFrequencyTenor()) : false); }
public void Parse_TestCase(string tenorTimeSpanSpreadString, bool isTenorTimeSpan, TenorTimeSpan firstTenor, string firstTenorDescription, TenorTimeSpan secondTenor, string secondTenorDescription) { TenorTimeSpanSpread tenorTimeSpanSpread = TenorTimeSpanSpread.Parse(tenorTimeSpanSpreadString); Assert.That(tenorTimeSpanSpread.IsTenorTimeSpan, Is.EqualTo(isTenorTimeSpan), "IsTenorTimeSpan"); Assert.That(tenorTimeSpanSpread.FirstTenor, Is.EqualTo(firstTenor), "FirstTenor"); Assert.That(tenorTimeSpanSpread.FirstTenorDescription, Is.EqualTo(firstTenorDescription), "FirstTenorDescription"); Assert.That(tenorTimeSpanSpread.SecondTenor, Is.EqualTo(secondTenor), "SecondTenor"); Assert.That(tenorTimeSpanSpread.SecondTenorDescription, Is.EqualTo(secondTenorDescription), "SecondTenorDescription"); }