/// <summary> /// Initializes a new instance of the <see cref="PriceableCapFloorStream"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The nameSpace</param> /// <param name="capId">The cap Id.</param> /// <param name="payerPartyReference">The payer party reference.</param> /// <param name="receiverPartyReference">The receiver party reference.</param> /// <param name="payerIsBase">The flag for whether the payerreference is the base party.</param> /// <param name="calculationPeriodDates">The caluclation period date information.</param> /// <param name="paymentDates">The payment dates of the swap leg.</param> /// <param name="resetDates">The reset dates of the swap leg.</param> /// <param name="principalExchanges">The principal Exchange type.</param> /// <param name="calculationPeriodAmount">The calculation period amount data.</param> /// <param name="stubCalculationPeriodAmount">The stub calculation information.</param> /// <param name="cashflows">The FpML cashflows for that stream.</param> /// <param name="settlementProvision">The settlement provision data.</param> /// <param name="forecastRateInterpolation">ForwardEndDate = forecastRateInterpolation ? AccrualEndDate /// : AdjustedDateHelper.ToAdjustedDate(forecastRateIndex.indexTenor.Add(AccrualStartDate), AccrualBusinessDayAdjustments);</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="paymentCalendar">The paymentCalendar.</param> public PriceableCapFloorStream ( ILogger logger , ICoreCache cache , String nameSpace , string capId , string payerPartyReference , string receiverPartyReference , bool payerIsBase , CalculationPeriodDates calculationPeriodDates , PaymentDates paymentDates , ResetDates resetDates , PrincipalExchanges principalExchanges , CalculationPeriodAmount calculationPeriodAmount , StubCalculationPeriodAmount stubCalculationPeriodAmount , Cashflows cashflows , SettlementProvision settlementProvision , bool forecastRateInterpolation , IBusinessCalendar fixingCalendar , IBusinessCalendar paymentCalendar) : base(logger, cache, nameSpace, capId, payerPartyReference, receiverPartyReference, payerIsBase, calculationPeriodDates, paymentDates, resetDates, principalExchanges, calculationPeriodAmount, stubCalculationPeriodAmount, cashflows, settlementProvision, forecastRateInterpolation, fixingCalendar, paymentCalendar) { }
/// <summary> /// Gets the unadjusted calculation date schedule. /// </summary> /// <param name="calculationPeriodDates">The calculation period dates.</param> /// <returns></returns> public List <CalculationPeriod> GetUnadjustedCalculationDateSchedule(CalculationPeriodDates calculationPeriodDates) { CalculationPeriodDates = calculationPeriodDates; PeriodInterval = CalculationPeriodHelper.CalculationPeriodFrequencyToInterval(calculationPeriodDates.calculationPeriodFrequency); _effectiveDate = XsdClassesFieldResolver.CalculationPeriodDatesGetEffectiveDate(calculationPeriodDates).unadjustedDate.Value; _termDate = XsdClassesFieldResolver.CalculationPeriodDatesGetTerminationDate(calculationPeriodDates).unadjustedDate.Value; RollConvention = calculationPeriodDates.calculationPeriodFrequency.rollConvention; _unadjustedDateScheduleList = CalculationPeriodHelper.GenerateUnadjustedCalculationDates(_effectiveDate, _termDate, calculationPeriodDates); return(_unadjustedDateScheduleList); }
public static DateTime?CalculationPeriodDatesGetLastRegularPeriodEndDate(CalculationPeriodDates calculationPeriodDates) { DateTime?result = null; bool goodDate = calculationPeriodDates.lastRegularPeriodEndDate != new DateTime(); if (calculationPeriodDates.lastRegularPeriodEndDateSpecified || goodDate) { result = calculationPeriodDates.lastRegularPeriodEndDate; } return(result); }
public static DateTime?CalculationPeriodDatesGetFirstRegularPeriodStartDate(CalculationPeriodDates calculationPeriodDates) { DateTime?result = null; var goodDate = calculationPeriodDates.firstRegularPeriodStartDate != new DateTime(); if (calculationPeriodDates.firstRegularPeriodStartDateSpecified || goodDate) { result = calculationPeriodDates.firstRegularPeriodStartDate; } return(result); }
private static InterestRateStream CreateGenericStream(PayRelativeToEnum paymentDateRelativeTo) { InterestRateStream stream = new InterestRateStream(); CalculationPeriodDates calculationPeriodDates = new CalculationPeriodDates(); stream.calculationPeriodDates = calculationPeriodDates; PaymentDates paymentDates = new PaymentDates(); stream.paymentDates = paymentDates; paymentDates.payRelativeTo = paymentDateRelativeTo; CalculationPeriodAmount calculationPeriodAmount = new CalculationPeriodAmount(); stream.calculationPeriodAmount = calculationPeriodAmount; Calculation calculation = new Calculation(); stream.calculationPeriodAmount.Item = calculation; return(stream); }
public static AdjustableDate CalculationPeriodDatesGetFirstPeriodStartDate(CalculationPeriodDates calculationPeriodDates) { return(calculationPeriodDates.firstPeriodStartDate); }
/// <summary> /// Initializes a new instance of the <see cref="PriceableInterestRateStream"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namesspace.</param> /// <param name="swapId">The swap Id.</param> /// <param name="payerPartyReference">The payer party reference.</param> /// <param name="receiverPartyReference">The receiver party reference.</param> /// <param name="payerIsBase">The flag for whether the payerreference is the base party.</param> /// <param name="calculationPeriodDates">The caluclation period date information.</param> /// <param name="paymentDates">The payment dates of the swap leg.</param> /// <param name="resetDates">The reset dates of the swap leg.</param> /// <param name="principalExchanges">The principal Exchange type.</param> /// <param name="calculationPeriodAmount">The calculation period amount data.</param> /// <param name="stubCalculationPeriodAmount">The stub calculation information.</param> /// <param name="cashflows">The FpML cashflows for that stream.</param> /// <param name="settlementProvision">The settlement provision data.</param> /// <param name="forecastRateInterpolation">ForwardEndDate = forecastRateInterpolation ? AccrualEndDate /// : AdjustedDateHelper.ToAdjustedDate(forecastRateIndex.indexTenor.Add(AccrualStartDate), AccrualBusinessDayAdjustments);</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="paymentCalendar">The paymentCalendar.</param> public PriceableInterestRateStream ( ILogger logger , ICoreCache cache , String nameSpace , string swapId , string payerPartyReference , string receiverPartyReference , bool payerIsBase , CalculationPeriodDates calculationPeriodDates , PaymentDates paymentDates , ResetDates resetDates , PrincipalExchanges principalExchanges , CalculationPeriodAmount calculationPeriodAmount , StubCalculationPeriodAmount stubCalculationPeriodAmount , Cashflows cashflows , SettlementProvision settlementProvision , bool forecastRateInterpolation , IBusinessCalendar fixingCalendar , IBusinessCalendar paymentCalendar) { Multiplier = 1.0m; Payer = payerPartyReference; Receiver = receiverPartyReference; PayerIsBaseParty = payerIsBase; CalculationPeriodDates = calculationPeriodDates; PaymentDates = paymentDates; PaymentCurrencies = new List <string>(); ResetDates = resetDates; PrincipalExchanges = principalExchanges; CalculationPeriodAmount = calculationPeriodAmount; AnalyticsModel = new StructuredStreamAnalytic(); Calculation = (Calculation)CalculationPeriodAmount.Item; if (Calculation.Items?[0] is Schedule strikeSchedule) { Strike = strikeSchedule.initialValue;//Only picks up the first fixed rate for the swaption calculation. } StubCalculationPeriodAmount = stubCalculationPeriodAmount; Cashflows = cashflows; CouponStreamType = CouponTypeFromCalculation(Calculation); Id = BuildId(swapId, CouponStreamType); ForecastRateInterpolation = forecastRateInterpolation; var isThereDiscounting = XsdClassesFieldResolver.CalculationHasDiscounting(Calculation); if (isThereDiscounting) { IsDiscounted = true; //TODO need to include rate logic for the correct solved answers. What about reset cashflows?? } //Get the currency. var currency = XsdClassesFieldResolver.CalculationGetNotionalSchedule(Calculation); Currency = currency.notionalStepSchedule.currency; if (!PaymentCurrencies.Contains(Currency.Value)) { PaymentCurrencies.Add(Currency.Value); } //The calendars if (paymentCalendar == null) { paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, PaymentDates.paymentDatesAdjustments.businessCenters, nameSpace); } SettlementProvision = settlementProvision; //Set the default discount curve name. DiscountCurveName = CurveNameHelpers.GetDiscountCurveName(Currency.Value, true); //Set the forecast curve name.//TODO extend this to the other types. if (CouponStreamType != CouponStreamType.GenericFixedRate) { if (fixingCalendar == null) { fixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, ResetDates.resetDatesAdjustments.businessCenters, nameSpace); } ForecastCurveName = null; if (Calculation.Items != null) { var floatingRateCalculation = Calculation.Items; var floatingRateIndex = (FloatingRateCalculation)floatingRateCalculation[0]; ForecastCurveName = CurveNameHelpers.GetForecastCurveName(floatingRateIndex); } } //Build the coupons and principal exchanges. if (GetCashflowPaymentCalculationPeriods() != null) { Coupons = PriceableInstrumentsFactory.CreatePriceableCoupons(PayerIsBaseParty, GetCashflowPaymentCalculationPeriods(), Calculation, ForecastRateInterpolation, fixingCalendar, paymentCalendar);//TODO add the stubcalculation. UpdateCouponIds(); } if (GetCashflowPrincipalExchanges() != null) { var exchanges = GetCashflowPrincipalExchanges(); Exchanges = PriceableInstrumentsFactory.CreatePriceablePrincipalExchanges(PayerIsBaseParty, exchanges, Currency.Value, paymentCalendar); UpdateExchangeIds(); } RiskMaturityDate = LastDate(); logger.LogInfo("Stream built"); }
/// <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); }
public static void CalculationPeriodDatesSetLastRegularPeriodEndDate(CalculationPeriodDates calculationPeriodDates, DateTime value) { calculationPeriodDates.lastRegularPeriodEndDate = value; calculationPeriodDates.lastRegularPeriodEndDateSpecified = true; }
/// <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 static AdjustableDate CalculationPeriodDatesGetEffectiveDate(CalculationPeriodDates calculationPeriodDates) { return((AdjustableDate)calculationPeriodDates.Item); }
public static void CalculationPeriodDatesSetFirstRegularPeriodStartDate(CalculationPeriodDates calculationPeriodDates, DateTime value) { calculationPeriodDates.firstRegularPeriodStartDate = value; calculationPeriodDates.firstRegularPeriodStartDateSpecified = true; }
public static void CalculationPeriodDatesSetFirstPeriodStartDate(CalculationPeriodDates calculationPeriodDates, AdjustableDate value) { calculationPeriodDates.firstPeriodStartDate = value; }
public static CalculationPeriodsPrincipalExchangesAndStubs GenerateCalculationPeriodsPrincipalExchangesAndStubs( InterestRateStream interestRateStream, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar) { CalculationPeriodDates calculationPeriodDates = interestRateStream.calculationPeriodDates; AdjustableDate adjustableEffectiveDate = XsdClassesFieldResolver.CalculationPeriodDatesGetEffectiveDate(calculationPeriodDates); AdjustableDate adjustableTerminationDate = XsdClassesFieldResolver.CalculationPeriodDatesGetTerminationDate(calculationPeriodDates); AdjustableDate adjustableFirstPeriodDate = adjustableEffectiveDate; DateTime?firstRegularPeriodStartDate = XsdClassesFieldResolver.CalculationPeriodDatesGetFirstRegularPeriodStartDate(calculationPeriodDates); var tempDate = XsdClassesFieldResolver.CalculationPeriodDatesGetFirstPeriodStartDate(calculationPeriodDates); if (tempDate != null && firstRegularPeriodStartDate != null) { adjustableFirstPeriodDate = tempDate; Frequency frequency = calculationPeriodDates.calculationPeriodFrequency; var startDate = CalculationPeriodGenerator.AddPeriod((DateTime)firstRegularPeriodStartDate, IntervalHelper.FromFrequency(frequency), -1); adjustableFirstPeriodDate.unadjustedDate = IdentifiedDateHelper.Create(startDate); } DateTime?lastRegularPeriodEndDate = XsdClassesFieldResolver.CalculationPeriodDatesGetLastRegularPeriodEndDate(calculationPeriodDates); // This assumes automatic adjustment of calculationperiods. CalculationPeriodsPrincipalExchangesAndStubs result = CalculationPeriodGenerator.GenerateAdjustedCalculationPeriods( adjustableFirstPeriodDate.unadjustedDate.Value, adjustableTerminationDate.unadjustedDate.Value, firstRegularPeriodStartDate, lastRegularPeriodEndDate, calculationPeriodDates.calculationPeriodFrequency, calculationPeriodDates.calculationPeriodDatesAdjustments, paymentCalendar); //Determine whether the reset dates must be calcuated. Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(interestRateStream.calculationPeriodAmount); // Add principle exchanges if this need is defined in parametric representation of the interest rate steam. // if (null != interestRateStream.principalExchanges) { //if (paymentCalendar == null) //{ // paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, adjustableEffectiveDate.dateAdjustments.businessCenters); //} // Initial PE // if (interestRateStream.principalExchanges.initialExchange) { PrincipalExchange initialExchange = PrincipalExchangeHelper.Create(AdjustedDateHelper.ToAdjustedDate(paymentCalendar, adjustableEffectiveDate)); result.InitialPrincipalExchange = initialExchange; } // intermediatory PE // if (interestRateStream.principalExchanges.intermediateExchange) { // Generate a list of intermediatory PE exchanges // 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); } } } // Final PE // Assume the same calendar is used for the termination date as well! if (interestRateStream.principalExchanges.finalExchange) { PrincipalExchange finalExchange = PrincipalExchangeHelper.Create(AdjustedDateHelper.ToAdjustedDate(paymentCalendar, adjustableTerminationDate)); result.FinalPrincipalExchange = finalExchange; } } //Only does upfront resetRelativeTo start date. if (interestRateStream.resetDates != null && calculation.Items[0].GetType() == typeof(FloatingRateCalculation)) { //Get the fixing date convention. var fixingDateConvention = interestRateStream.resetDates.resetDatesAdjustments; //if (fixingCalendar == null) //{ // fixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, fixingDateConvention.businessCenters); //} foreach (var calculationPeriod in result.CalculationPeriods) { if (calculationPeriod.adjustedStartDateSpecified) { //Set the adjusted fixing date. var adjustedFixingDate = AdjustedDateHelper.ToAdjustedDate(fixingCalendar, calculationPeriod.adjustedStartDate, fixingDateConvention); var floatingRateDefinition = new FloatingRateDefinition(); var rateObservation = new RateObservation { observedRateSpecified = false, adjustedFixingDateSpecified = true, adjustedFixingDate = adjustedFixingDate }; floatingRateDefinition.rateObservation = new[] { rateObservation }; calculationPeriod.Item1 = floatingRateDefinition; } } //The initial stub period. if (result.InitialStubCalculationPeriod != null) { if (result.InitialStubCalculationPeriod.adjustedStartDateSpecified) { //Set the adjusted fixing date. var adjustedFixingDate = AdjustedDateHelper.ToAdjustedDate(fixingCalendar, result.InitialStubCalculationPeriod.adjustedStartDate, fixingDateConvention); var floatingRateDefinition = new FloatingRateDefinition(); var rateObservation = new RateObservation { observedRateSpecified = false, adjustedFixingDateSpecified = true, adjustedFixingDate = adjustedFixingDate }; floatingRateDefinition.rateObservation = new[] { rateObservation }; result.InitialStubCalculationPeriod.Item1 = floatingRateDefinition; } } //The final stub period if (result.FinalStubCalculationPeriod != null) { if (result.FinalStubCalculationPeriod.adjustedStartDateSpecified) { //Set the adjusted fixing date. var adjustedFixingDate = AdjustedDateHelper.ToAdjustedDate(fixingCalendar, result.FinalStubCalculationPeriod.adjustedStartDate, fixingDateConvention); var floatingRateDefinition = new FloatingRateDefinition(); var rateObservation = new RateObservation { observedRateSpecified = false, adjustedFixingDateSpecified = true, adjustedFixingDate = adjustedFixingDate }; floatingRateDefinition.rateObservation = new[] { rateObservation }; result.FinalStubCalculationPeriod.Item1 = floatingRateDefinition; } } } return(result); }
public static void CalculationPeriodDatesSetTerminationDate(CalculationPeriodDates calculationPeriodDates, AdjustableDate value) { calculationPeriodDates.Item1 = value; }
public static AdjustableDate CalculationPeriodDatesGetTerminationDate(CalculationPeriodDates calculationPeriodDates) { return((AdjustableDate)calculationPeriodDates.Item1); }
public static void CalculationPeriodDatesSetEffectiveDate(CalculationPeriodDates calculationPeriodDates, AdjustableDate value) { calculationPeriodDates.Item = value; }