public static RelativeDateOffset Create(string period, DayTypeEnum dayType,
string businessDayConventionAsString,
string businessCentersAsString,
string dateRelativeTo)
{
var result = new RelativeDateOffset();
Period interval = PeriodHelper.Parse(period);
result.period = interval.period;
result.periodSpecified = true;
result.periodMultiplier = interval.periodMultiplier;
result.dayType = dayType;
result.dayTypeSpecified = true;
if (businessDayConventionAsString != null)
{
result.businessDayConvention = BusinessDayConventionHelper.Parse(businessDayConventionAsString);
result.businessDayConventionSpecified = true;
}
if (businessCentersAsString != null)
{
result.businessCenters = BusinessCentersHelper.Parse(businessCentersAsString);
}
if (dateRelativeTo != null)
{
var dateReference = new DateReference {
href = dateRelativeTo
};
result.dateRelativeTo = dateReference;
}
return(result);
}
/// <summary>
/// Converts to an adjustable date type.
/// </summary>
/// <param name="unadjustedDate"></param>
/// <param name="businessDayConvention"></param>
/// <param name="businessCentersAsString"></param>
/// <returns></returns>
public static AdjustableDate ToAdjustableDate(DateTime unadjustedDate, BusinessDayConventionEnum businessDayConvention, string businessCentersAsString)
{
AdjustableDate result = ToAdjustableDate(unadjustedDate, businessDayConvention);
result.dateAdjustments.businessCenters = BusinessCentersHelper.Parse(businessCentersAsString);
return(result);
}
/// <summary>
/// Adjusteds the dates from effective 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="rollConvention">The roll convention.</param>
/// <param name="businessCenters">The business centers.</param>
/// <param name="dateAdjustmentConvention">The date adjustment convention.</param>
/// <returns>A vertical arrray of dates.</returns>
public object[,] AdjustedDatesFromEffectiveDate(DateTime effectiveDate, DateTime terminationDate, string periodInterval, string rollConvention,
string businessCenters, string dateAdjustmentConvention)
{
BusinessCenters centers = BusinessCentersHelper.Parse(businessCenters);
IBusinessCalendar calendar = Engine.ToBusinessCalendar(centers);
var adjustments = EnumHelper.Parse <BusinessDayConventionEnum>(dateAdjustmentConvention);
var adjustedDateSchedule = AdjustedDateScheduler.AdjustedDatesFromEffectiveDate(effectiveDate, terminationDate, periodInterval, rollConvention, calendar, adjustments);
var result = RangeHelper.ConvertArrayToRange(adjustedDateSchedule);
return(result);
}
public static BusinessDayAdjustments Create(BusinessDayConventionEnum businessDayConvention, string businessCentersAsString)
{
var result = new BusinessDayAdjustments
{
businessDayConvention = businessDayConvention,
businessCenters =
BusinessCentersHelper.Parse(businessCentersAsString)
};
return(result);
}
/// <summary>
/// A helper to extract properties from a namedvalueset..
/// </summary>
/// <param name="propertyCollection">The collection of properties.</param>
public static BusinessCenters ExtractBusinessCenters(NamedValueSet propertyCollection)
{
BusinessCenters businessCentres = null;
var dictionaryKeys = propertyCollection.ToDictionary();
if (dictionaryKeys.ContainsKey("BusinessCenters"))
{
var centres = propertyCollection.Get("BusinessCenters").AsValue <string[]>();
businessCentres = BusinessCentersHelper.Parse(centres);
}
return(businessCentres);
}
/// <summary>
/// Gets a dates schedule.
/// </summary>
/// <param name="metaScheduleDefinitionRange">This must have 3 columns: interval, interval, rollconventionenum.</param>
/// <param name="startDate">The start date of the schedule to be generated.</param>
/// <param name="calendar">The relevant calendar.</param>
/// <param name="businessDayAdjustment">The business day adjustments.</param>
/// <returns>A vertical arrray of dates.</returns>
public object[,] GetMetaDatesSchedule(Excel.Range metaScheduleDefinitionRange,
DateTime startDate,
string calendar,
string businessDayAdjustment)
{
var values = metaScheduleDefinitionRange.Value[System.Reflection.Missing.Value] as object[, ];
List <ThreeStringsRangeItem> metaScheduleDefinition = ObjectToArrayOfPropertiesConverter.CreateListFromHorizontalArrayRange <ThreeStringsRangeItem>(values);
BusinessCenters centers = BusinessCentersHelper.Parse(calendar);
IBusinessCalendar businessCalendar = Engine.ToBusinessCalendar(centers);
var metaSchedule = AdjustedDatesMetaSchedule.GetMetaDatesSchedule(metaScheduleDefinition, startDate, businessCalendar, calendar, businessDayAdjustment);
var result = RangeHelper.ConvertArrayToRange(metaSchedule);
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="capFloorLeg"></param>
/// <param name="nameSpace"></param>
/// <param name="fixingCalendar"></param>
/// <param name="paymentCalendar"></param>
/// <param name="spreadSchedule"></param>
/// <param name="capOrFloorSchedule"></param>
/// <param name="notionalSchedule"></param>
/// <returns></returns>
public static CapFloor GenerateDefinitionCashflows(ILogger logger, ICoreCache cache,
string nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
CapFloorLegParametersRange capFloorLeg,
Schedule spreadSchedule,
Schedule capOrFloorSchedule,
NonNegativeAmountSchedule notionalSchedule)
{
if (paymentCalendar == null)
{
if (!string.IsNullOrEmpty(capFloorLeg.PaymentCalendar))
{
var payCalendar = BusinessCentersHelper.Parse(capFloorLeg.PaymentCalendar);
paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, payCalendar, nameSpace);
}
}
if (fixingCalendar == null)
{
if (!string.IsNullOrEmpty(capFloorLeg.FixingCalendar))
{
var fixCalendar = BusinessCentersHelper.Parse(capFloorLeg.FixingCalendar);
fixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, fixCalendar, nameSpace);
}
}
CapFloor capFloor = GenerateDefiniton(capFloorLeg, spreadSchedule, capOrFloorSchedule, notionalSchedule);
if (null != spreadSchedule)
{
InterestRateStreamParametricDefinitionGenerator.SetSpreadSchedule(capFloor.capFloorStream, spreadSchedule);
}
if (null != notionalSchedule)
{
InterestRateStreamParametricDefinitionGenerator.SetNotionalSchedule(capFloor.capFloorStream, notionalSchedule);
}
if (null != capOrFloorSchedule)
{
if (capFloorLeg.CapOrFloor == CapFloorType.Cap)
{
InterestRateStreamParametricDefinitionGenerator.SetCapRateSchedule(capFloor.capFloorStream, capOrFloorSchedule, true);
}
else
{
InterestRateStreamParametricDefinitionGenerator.SetFloorRateSchedule(capFloor.capFloorStream, capOrFloorSchedule, true);
}
}
capFloor.capFloorStream.cashflows = FixedAndFloatingRateStreamCashflowGenerator.GetCashflows(capFloor.capFloorStream, fixingCalendar, paymentCalendar);
return(capFloor);
}
/// <summary>
/// Gets the reset date.
/// </summary>
/// <param name="resetRelativeTo">The reset relative to.</param>
/// <returns></returns>
/// <param name="fixingDateRelativeOffset"></param>
private DateTime GetResetDate(ResetRelativeToEnum resetRelativeTo, RelativeDateOffset fixingDateRelativeOffset)
{
var resetDate = AccrualStartDate;
switch (resetRelativeTo)
{
case ResetRelativeToEnum.CalculationPeriodEndDate:
resetDate = AccrualEndDate;
break;
}
var interval = (Period)fixingDateRelativeOffset;
if (fixingDateRelativeOffset != null)
{
var adjustment = BusinessDayAdjustmentsHelper.Create(fixingDateRelativeOffset.businessDayConvention, BusinessCentersHelper.BusinessCentersString(fixingDateRelativeOffset.businessCenters.businessCenter));
resetDate = AdjustedDateHelper.ToAdjustedDate(FixingCalendar, resetDate, adjustment, OffsetHelper.FromInterval(interval, fixingDateRelativeOffset.dayType));
}
return(resetDate);
}
/// <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>
/// <returns></returns>
public static Swap GenerateDefinitionCashflows(ILogger logger,
ICoreCache cache, string nameSpace,
SwapLegParametersRange leg1Parameters,
Pair <IBusinessCalendar, IBusinessCalendar> leg1Calendars,
SwapLegParametersRange leg2Parameters,
Pair <IBusinessCalendar, IBusinessCalendar> leg2Calendars,
Schedule fixedRateSchedule,
Schedule spreadSchedule,
NonNegativeAmountSchedule notionalSchedule)
{
IBusinessCalendar leg1PaymentCalendar = null;
IBusinessCalendar leg2PaymentCalendar = null;
IBusinessCalendar leg1FixingCalendar = null;
IBusinessCalendar leg2FixingCalendar = null;
if (leg1Calendars != null)
{
leg1FixingCalendar = leg1Calendars.First;
leg1PaymentCalendar = leg1Calendars.Second;
}
else
{
if (!string.IsNullOrEmpty(leg1Parameters.PaymentCalendar))
{
var payCalendar = BusinessCentersHelper.Parse(leg1Parameters.PaymentCalendar);
leg1PaymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, payCalendar, nameSpace);
leg1FixingCalendar = leg1PaymentCalendar;
}
if (!string.IsNullOrEmpty(leg1Parameters.FixingCalendar))
{
var fixingCalendar = BusinessCentersHelper.Parse(leg1Parameters.FixingCalendar);
leg1FixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, fixingCalendar, nameSpace);
}
}
if (leg2Calendars != null)
{
leg2FixingCalendar = leg2Calendars.First;
leg2PaymentCalendar = leg2Calendars.Second;
}
else
{
if (!string.IsNullOrEmpty(leg2Parameters.PaymentCalendar))
{
var payCalendar = BusinessCentersHelper.Parse(leg2Parameters.PaymentCalendar);
leg2PaymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, payCalendar, nameSpace);
leg2FixingCalendar = leg2PaymentCalendar;
}
if (!string.IsNullOrEmpty(leg2Parameters.FixingCalendar))
{
var fixingCalendar = BusinessCentersHelper.Parse(leg2Parameters.FixingCalendar);
leg2FixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, fixingCalendar, nameSpace);
}
}
var swap = GenerateDefiniton(leg1Parameters, leg2Parameters);
InterestRateStream stream1 = swap.swapStream[0];
InterestRateStream stream2 = swap.swapStream[1];
if (null != fixedRateSchedule)
{
// Set FixedRateSchedule (if this is a fixed leg)
//
if (leg1Parameters.IsFixedLegType())
{
InterestRateStreamParametricDefinitionGenerator.SetFixedRateSchedule(stream1, fixedRateSchedule);
}
// Set FixedRateSchedule (if this is a fixed leg)
//
if (leg2Parameters.IsFixedLegType())
{
InterestRateStreamParametricDefinitionGenerator.SetFixedRateSchedule(stream2, fixedRateSchedule);
}
}
if (null != spreadSchedule) //for float legs only
{
if (leg1Parameters.IsFloatingLegType())
{
InterestRateStreamParametricDefinitionGenerator.SetSpreadSchedule(stream1, spreadSchedule);
}
if (leg2Parameters.IsFloatingLegType())
{
InterestRateStreamParametricDefinitionGenerator.SetSpreadSchedule(stream2, spreadSchedule);
}
}
if (null != notionalSchedule)
{
// Set notional schedule
//
InterestRateStreamParametricDefinitionGenerator.SetNotionalSchedule(stream1, notionalSchedule);
InterestRateStreamParametricDefinitionGenerator.SetNotionalSchedule(stream2, notionalSchedule);
}
stream1.cashflows = FixedAndFloatingRateStreamCashflowGenerator.GetCashflows(stream1, leg1FixingCalendar, leg1PaymentCalendar);
stream2.cashflows = FixedAndFloatingRateStreamCashflowGenerator.GetCashflows(stream2, leg2FixingCalendar, leg2PaymentCalendar);
return(swap);
}
