/// <summary> /// Gets and sets the required pricing structures to value this leg. /// </summary> public List <String> GetRequiredPricingStructures() { var result = new List <String>(); if (calculationPeriodAmount.Item is Calculation amount) { var currency = XsdClassesFieldResolver.CalculationGetNotionalSchedule(amount); if (currency?.notionalStepSchedule != null) { var discountCurve = CurveNameHelpers.GetDiscountCurveName(currency.notionalStepSchedule.currency, true); result.Add(discountCurve); } if (amount.Items[0] is FloatingRateCalculation floatingRateCalculation) { result.Add(CurveNameHelpers.GetForecastCurveName(floatingRateCalculation.floatingRateIndex, floatingRateCalculation.indexTenor)); } } //TODO if (stubCalculationPeriodAmount != null) { if (stubCalculationPeriodAmount.initialStub?.Items != null) { result.AddRange(from value in stubCalculationPeriodAmount.initialStub.Items where value is Money select CurveNameHelpers.GetDiscountCurveName(((Money)value).currency, true)); } if (stubCalculationPeriodAmount.finalStub?.Items != null) { result.AddRange(from value in stubCalculationPeriodAmount.finalStub.Items where value is Money select CurveNameHelpers.GetDiscountCurveName(((Money)value).currency, true)); } } return(result); }
/// <summary> /// /// </summary> /// <returns></returns> public List <string> GetRequiredCurrencies() { var result = new List <string>(); var item = XsdClassesFieldResolver.CalculationGetNotionalSchedule((Calculation)calculationPeriodAmount.Item); if (item?.notionalStepSchedule?.currency != null) { result.Add(item.notionalStepSchedule.currency.Value); } return(result); }
///<summary> /// Gets all the Forecast curve name. ///</summary> ///<returns></returns> public static string GetRateVolatilityMatrixName(Swap swap) { AdjustableDate adjustableEffectiveDate = XsdClassesFieldResolver.CalculationPeriodDatesGetEffectiveDate(swap.swapStream[0].calculationPeriodDates); AdjustableDate adjustableTerminationDate = XsdClassesFieldResolver.CalculationPeriodDatesGetTerminationDate(swap.swapStream[0].calculationPeriodDates); var years = adjustableTerminationDate.unadjustedDate.Value.Year - adjustableEffectiveDate.unadjustedDate.Value.Year; var calculation = (Calculation)swap.swapStream[0].calculationPeriodAmount.Item; var notional = XsdClassesFieldResolver.CalculationGetNotionalSchedule(calculation); var currency = notional.notionalStepSchedule.currency.Value; return(PricingStructureTypeEnum.RateVolatilityMatrix + "." + currency + "-IRSwap-" + years + "Y"); }
/// <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"); }
private static void CalculateForecastPaymentAmount(Calculation calculation, FloatingRateCalculation floatingRateCalculation, PaymentCalculationPeriod paymentCalculationPeriod, IRateCurve forecastCurve, IRateCurve discountCurve, DateTime valuationDate) { var amountAccruedPerPaymentPeriod = new List <Money>(); decimal interestFromPreviousPeriods = 0; Notional notionalSchedule = XsdClassesFieldResolver.CalculationGetNotionalSchedule(calculation); Currency notionalCurrency = notionalSchedule.notionalStepSchedule.currency; // Cashflows // foreach (CalculationPeriod calculationPeriod in XsdClassesFieldResolver.GetPaymentCalculationPeriodCalculationPeriodArray(paymentCalculationPeriod)) { decimal notional = XsdClassesFieldResolver.CalculationPeriodGetNotionalAmount(calculationPeriod); decimal finalRate = 0.0m; // If has a fixed rate (fixed rate coupon) // if (XsdClassesFieldResolver.CalculationPeriodHasFixedRate(calculationPeriod)) { finalRate = XsdClassesFieldResolver.CalculationPeriodGetFixedRate(calculationPeriod); } else if (XsdClassesFieldResolver.CalculationPeriodHasFloatingRateDefinition(calculationPeriod)) { if (null != forecastCurve) { FloatingRateDefinition floatingRateDefinition = XsdClassesFieldResolver.CalculationPeriodGetFloatingRateDefinition(calculationPeriod); // Apply spread from schedule if it hasn't been specified yet. // if (!floatingRateDefinition.spreadSpecified) { floatingRateDefinition.spread = floatingRateCalculation.spreadSchedule[0].initialValue; floatingRateDefinition.spreadSpecified = true; } ForecastRateHelper.UpdateFloatingRateDefinition(floatingRateDefinition, floatingRateCalculation, calculation.dayCountFraction, calculationPeriod, forecastCurve); calculationPeriod.Item1 = floatingRateDefinition; decimal calculatedRate = floatingRateDefinition.calculatedRate; // final rate after application of Cap/Floor rates // finalRate = calculatedRate; // If has a Cap rate, finalRate = MAX(0, FinalRate - CapRate) // if (null != floatingRateDefinition.capRate) { Strike strike = floatingRateDefinition.capRate[0]; finalRate = System.Math.Max(0, finalRate - strike.strikeRate); } // If has a Floor rate, finalRate = MAX(0, FloorRate - FinalRate) // if (null != floatingRateDefinition.floorRate) { Strike strike = floatingRateDefinition.floorRate[0]; finalRate = System.Math.Max(0, strike.strikeRate - finalRate); } } } else { throw new System.Exception("CalculationPeriod has neither fixedRate nor floatngRateDefinition."); } // Compound interest accrued during previos calculation periods in this payment period. // decimal notionalAdjustedForInterestFromPreviousPeriods = notional + interestFromPreviousPeriods; if (calculation.discounting == null) { interestFromPreviousPeriods = notionalAdjustedForInterestFromPreviousPeriods * finalRate * calculationPeriod.dayCountYearFraction; } else if (calculation.discounting.discountingType == DiscountingTypeEnum.FRA || calculation.discounting.discountingType == DiscountingTypeEnum.Standard) { interestFromPreviousPeriods = notionalAdjustedForInterestFromPreviousPeriods * (1.0m - 1.0m / (1.0m + finalRate * calculationPeriod.dayCountYearFraction)); } else { throw new NotSupportedException("The specified discountingType is not supported."); } Money amountAccruedPerCalculationPeriod = MoneyHelper.GetAmount(interestFromPreviousPeriods, notionalCurrency); amountAccruedPerPaymentPeriod.Add(amountAccruedPerCalculationPeriod); } paymentCalculationPeriod.forecastPaymentAmount = MoneyHelper.Sum(amountAccruedPerPaymentPeriod); paymentCalculationPeriod.discountFactor = (decimal)discountCurve.GetDiscountFactor(valuationDate, paymentCalculationPeriod.adjustedPaymentDate); paymentCalculationPeriod.discountFactorSpecified = true; paymentCalculationPeriod.presentValueAmount = MoneyHelper.Mul(paymentCalculationPeriod.forecastPaymentAmount, paymentCalculationPeriod.discountFactor); }
/// <summary> /// Update calculation periods with rates/notional. /// </summary> /// <param name="interestRateStream"></param> /// <param name="calculationPeriodsPrincipalExchangesAndStubs"></param> public static void UpdateCalculationPeriodsData(InterestRateStream interestRateStream, CalculationPeriodsPrincipalExchangesAndStubs calculationPeriodsPrincipalExchangesAndStubs) { Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(interestRateStream.calculationPeriodAmount); Notional notionalSchedule = XsdClassesFieldResolver.CalculationGetNotionalSchedule(calculation); #region Generate FUTURE amounts for principle exchanges // Initial PE // if (null != calculationPeriodsPrincipalExchangesAndStubs.InitialPrincipalExchange) { // initial OUTflow // decimal initialNotionalValue = ScheduleHelper.GetValue(notionalSchedule.notionalStepSchedule, calculationPeriodsPrincipalExchangesAndStubs.InitialPrincipalExchange.adjustedPrincipalExchangeDate); calculationPeriodsPrincipalExchangesAndStubs.InitialPrincipalExchange.principalExchangeAmount = -initialNotionalValue; calculationPeriodsPrincipalExchangesAndStubs.InitialPrincipalExchange.principalExchangeAmountSpecified = true; } // intermediatory PE // foreach (PrincipalExchange intermediatoryExchange in calculationPeriodsPrincipalExchangesAndStubs.IntermediatePrincipalExchanges) { DateTime principleExchangeDate = intermediatoryExchange.adjustedPrincipalExchangeDate; //value at the day before principle exchange day // decimal prevNotionalValue = ScheduleHelper.GetValue(notionalSchedule.notionalStepSchedule, principleExchangeDate.AddDays(-1)); //value at principle exchange day .. // decimal newNotionalValue = ScheduleHelper.GetValue(notionalSchedule.notionalStepSchedule, principleExchangeDate); decimal principalExchangeAmount = prevNotionalValue - newNotionalValue; intermediatoryExchange.principalExchangeAmount = principalExchangeAmount; intermediatoryExchange.principalExchangeAmountSpecified = true; } // Final PE // if (null != calculationPeriodsPrincipalExchangesAndStubs.FinalPrincipalExchange) { // pay the rest ot the notional back // decimal newNotionalValue = ScheduleHelper.GetValue(notionalSchedule.notionalStepSchedule, calculationPeriodsPrincipalExchangesAndStubs.FinalPrincipalExchange.adjustedPrincipalExchangeDate); calculationPeriodsPrincipalExchangesAndStubs.FinalPrincipalExchange.principalExchangeAmount = newNotionalValue; calculationPeriodsPrincipalExchangesAndStubs.FinalPrincipalExchange.principalExchangeAmountSpecified = true; } #endregion // Process standard calculation periods // foreach (CalculationPeriod calculationPeriod in calculationPeriodsPrincipalExchangesAndStubs.CalculationPeriods) { UpdateCalculationPeriodData(calculation, calculationPeriod, notionalSchedule); } // Process stub calculation periods // if (null != interestRateStream.stubCalculationPeriodAmount) { if ((null == interestRateStream.stubCalculationPeriodAmount.initialStub) && (null == interestRateStream.stubCalculationPeriodAmount.finalStub)) { throw new System.Exception( "interestRateStream.stubCalculationPeriodAmount.initialStub && interestRateStream.stubCalculationPeriodAmount.finalStub are null"); } StubValue initialStub = interestRateStream.stubCalculationPeriodAmount.initialStub; StubValue finalStub = interestRateStream.stubCalculationPeriodAmount.finalStub; if (null != calculationPeriodsPrincipalExchangesAndStubs.InitialStubCalculationPeriod && null != initialStub) { UpdateStubCalculationPeriodData(interestRateStream, calculationPeriodsPrincipalExchangesAndStubs.InitialStubCalculationPeriod, initialStub, notionalSchedule); } if (null != calculationPeriodsPrincipalExchangesAndStubs.FinalStubCalculationPeriod && null != finalStub) { UpdateStubCalculationPeriodData(interestRateStream, calculationPeriodsPrincipalExchangesAndStubs.FinalStubCalculationPeriod, finalStub, notionalSchedule); } } else { foreach (CalculationPeriod calculationPeriod in new[] { calculationPeriodsPrincipalExchangesAndStubs.InitialStubCalculationPeriod, calculationPeriodsPrincipalExchangesAndStubs.FinalStubCalculationPeriod }) { if (null != calculationPeriod) { UpdateCalculationPeriodData(calculation, calculationPeriod, notionalSchedule); } } } }
/// <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 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); }