public static FloatingRateDefinition CreateFloatingRateDefinition(FloatingRate floatingRate,
DayCountFraction dayCountFraction,
CalculationPeriod calculationPeriod,
IRateCurve forecastCurve)
{
//throw new NotImplementedException();
// assign floating rate def with adjusted fixing date
//
var floatingRateDefinition = new FloatingRateDefinition {
spread = 0.000m, spreadSpecified = true
};
// Spread = 0.0
//
var rateObservation = new RateObservation();
floatingRateDefinition.rateObservation = new[] { rateObservation };
rateObservation.forecastRate = GetForecastRate(calculationPeriod, forecastCurve, dayCountFraction);
rateObservation.forecastRateSpecified = true;
Decimal finalRate = rateObservation.forecastRate;
// If spread specified - add it to final rate.
//
if (floatingRateDefinition.spreadSpecified)
{
finalRate += floatingRateDefinition.spread;
}
floatingRateDefinition.calculatedRate = finalRate;
floatingRateDefinition.calculatedRateSpecified = true;
return(floatingRateDefinition);
}
private static void UpdateCashflowsWithDetailedCashflows(Cashflows cashflows, IEnumerable <DetailedCashflowRangeItem> listDetailedCashflows /*, bool fixedLeg*/)
{
var paymentCalculationPeriods = new List <PaymentCalculationPeriod>();
foreach (DetailedCashflowRangeItem detailedCashflowRangeItem in listDetailedCashflows)
{
var paymentCalculationPeriod = new PaymentCalculationPeriod();
var calculationPeriod = new CalculationPeriod();
paymentCalculationPeriod.Items = new object[] { calculationPeriod };
paymentCalculationPeriod.adjustedPaymentDate = detailedCashflowRangeItem.PaymentDate;
paymentCalculationPeriod.adjustedPaymentDateSpecified = true;
PaymentCalculationPeriodHelper.SetCalculationPeriodStartDate(paymentCalculationPeriod, detailedCashflowRangeItem.StartDate);
PaymentCalculationPeriodHelper.SetCalculationPeriodEndDate(paymentCalculationPeriod, detailedCashflowRangeItem.EndDate);
// Update notional amount
//
PaymentCalculationPeriodHelper.SetNotionalAmount(paymentCalculationPeriod, (decimal)detailedCashflowRangeItem.NotionalAmount);
if (detailedCashflowRangeItem.CouponType == "Fixed")
{
//CalculationPeriod calculationPeriod = PaymentCalculationPeriodHelper.GetCalculationPeriods(paymentCalculationPeriod)[0];
//if (XsdClassesFieldResolver.CalculationPeriod_HasFixedRate(calculationPeriod))
//{
// Fixed->Fixed
//
//PaymentCalculationPeriodHelper.SetRate(paymentCalculationPeriod, (decimal)detailedCashflowRangeItem.Rate);
XsdClassesFieldResolver.SetCalculationPeriodFixedRate(calculationPeriod, (decimal)detailedCashflowRangeItem.Rate);
//}
//else if (XsdClassesFieldResolver.CalculationPeriod_HasFloatingRateDefinition(calculationPeriod))
// {
// // Float->Fixed
// //
// PaymentCalculationPeriodHelper.ReplaceFloatingRateWithFixedRate(paymentCalculationPeriod, (decimal)detailedCashflowRangeItem.Rate);
// }
// else
// {
// throw new NotImplementedException();
// }
}
else if (detailedCashflowRangeItem.CouponType == "Float")
{
// Create floating rate definiton...
//
var floatingRateDefinition = new FloatingRateDefinition();
//XsdClassesFieldResolver.CalculationPeriod_SetFloatingRateDefinition(calculationPeriod, floatingRateDefinition);
calculationPeriod.Item1 = floatingRateDefinition;
// After the spread is reset - we need to update calculated rate.
//
PaymentCalculationPeriodHelper.SetSpread(paymentCalculationPeriod, (decimal)detailedCashflowRangeItem.Spread);
}
else
{
string message = $"Unsupported coupon type '{detailedCashflowRangeItem.CouponType}";
throw new System.Exception(message);
}
paymentCalculationPeriods.Add(paymentCalculationPeriod);
}
cashflows.cashflowsMatchParameters = false;
cashflows.paymentCalculationPeriod = paymentCalculationPeriods.ToArray();
}
public static FloatingRateDefinition CreateFloatingRateDefinition(CalculationPeriod calculationPeriod)
{
var floatingRateDefinition = new FloatingRateDefinition();
//floatingRateDefinition.spread = 0.0m;
//floatingRateDefinition.spreadSpecified = true;
return(floatingRateDefinition);
}
public static FloatingRateDefinition CreateSimple(FloatingRateIndex floatingRateIndex, Period tenor,
decimal derivedRate, decimal spread)
{
FloatingRateDefinition floatingRateDefinition = new FloatingRateDefinition();
floatingRateDefinition.calculatedRate = derivedRate + spread;
floatingRateDefinition.calculatedRateSpecified = true;
floatingRateDefinition.spread = spread;
floatingRateDefinition.spreadSpecified = true;
return(floatingRateDefinition);
}
public static FloatingRateDefinition CreateSimple(DateTime adjustedFixingDate, decimal observedRate, decimal spread)
{
FloatingRateDefinition floatingRateDefinition = new FloatingRateDefinition();
floatingRateDefinition.calculatedRate = observedRate + spread;
floatingRateDefinition.calculatedRateSpecified = true;
floatingRateDefinition.rateObservation = RateObservationFactory.Create(adjustedFixingDate, observedRate);
floatingRateDefinition.spread = spread;
floatingRateDefinition.spreadSpecified = true;
return(floatingRateDefinition);
}
public static FloatingRateDefinition CreateSimple(DateTime adjustedFixingDate, decimal observedRate, decimal spread)
{
var floatingRateDefinition = new FloatingRateDefinition
{
calculatedRate = observedRate + spread,
calculatedRateSpecified = true,
rateObservation = RateObservationFactory.Create(adjustedFixingDate, observedRate),
spread = spread,
spreadSpecified = true
};
return(floatingRateDefinition);
}
public static FloatingRateDefinition CreateSimple(FloatingRateIndex floatingRateIndex, Period tenor,
decimal derivedRate, decimal spread)
{
var floatingRateDefinition = new FloatingRateDefinition
{
calculatedRate = derivedRate + spread,
calculatedRateSpecified = true,
spread = spread,
spreadSpecified = true
};
return(floatingRateDefinition);
}
/// <summary>
/// Builds the calculation period.
/// </summary>
/// <returns></returns>
override protected CalculationPeriod BuildCalculationPeriod()
{
CalculationPeriod cp = base.BuildCalculationPeriod();
FloatingRateDefinition floatingRateDefinition = FloatingRateDefinitionHelper.CreateSimple(ForecastRateIndex.floatingRateIndex, ForecastRateIndex.indexTenor, AdjustedFixingDate, GetRate(), Margin);
cp.Item1 = floatingRateDefinition;
if (floatingRateDefinition.calculatedRateSpecified)
{
cp.forecastRate = floatingRateDefinition.calculatedRate;
cp.forecastRateSpecified = true;
}
cp.forecastAmount = MoneyHelper.GetAmount(CalculationResults.ExpectedValue, NotionalAmount.currency.Value);
return(cp);
}
public static void SetSpread(PaymentCalculationPeriod paymentCalculationPeriod, decimal value)
{
foreach (CalculationPeriod calculationPeriod in XsdClassesFieldResolver.GetPaymentCalculationPeriodCalculationPeriodArray(paymentCalculationPeriod))
{
if (XsdClassesFieldResolver.CalculationPeriodHasFloatingRateDefinition(calculationPeriod))
{
FloatingRateDefinition floatingRateDefinition = XsdClassesFieldResolver.CalculationPeriodGetFloatingRateDefinition(calculationPeriod);
floatingRateDefinition.spread = value;
floatingRateDefinition.spreadSpecified = true;
}
else
{
throw new NotImplementedException("PaymentCalculationPeriodHelper.SetSpread cannot be called on a fixed rate cashflow.");
}
}
}
public static FloatingRateDefinition CreateCapFloor(FloatingRateIndex floatingRateIndex, Period tenor, DateTime adjustedFixingDate,
decimal observedRate, decimal spread, decimal capfloorstrike, bool isCap)
{
FloatingRateDefinition floatingRateDefinition = CreateSimple(floatingRateIndex, tenor, adjustedFixingDate, observedRate, spread);
var strike = new Strike();
strike.strikeRate = capfloorstrike;
if (isCap)
{
floatingRateDefinition.capRate = new[] { strike };
}
else
{
floatingRateDefinition.floorRate = new[] { strike };
}
return(floatingRateDefinition);
}
private static string GetCouponType(PaymentCalculationPeriod pcalculationPeriod)
{
CalculationPeriod calculationPeriod = PaymentCalculationPeriodHelper.GetCalculationPeriods(pcalculationPeriod)[0];
FloatingRateDefinition floatingRateDefinition = XsdClassesFieldResolver.CalculationPeriodGetFloatingRateDefinition(calculationPeriod);
// If has a Cap rate, finalRate = MAX(0, FinalRate - CapRate)
//
if (null != floatingRateDefinition.capRate)
{
return("Cap");
}
// If has a Floor rate, finalRate = MAX(0, FloorRate - FinalRate)
//
if (null != floatingRateDefinition.floorRate)
{
return("Floor");
}
throw new System.Exception("Invalid coupond type. Only Cap & Floor coupons are expected here.");
}
public static decimal GetSpread(PaymentCalculationPeriod paymentCalculationPeriod)
{
decimal result = 0.0m;
decimal numberOfPeriods = 0.0m;
foreach (CalculationPeriod calculationPeriod in XsdClassesFieldResolver.GetPaymentCalculationPeriodCalculationPeriodArray(paymentCalculationPeriod))
{
if (XsdClassesFieldResolver.CalculationPeriodHasFloatingRateDefinition(calculationPeriod))
{
FloatingRateDefinition floatingRateDefinition = XsdClassesFieldResolver.CalculationPeriodGetFloatingRateDefinition(calculationPeriod);
result += floatingRateDefinition.spread;
}
else
{
throw new NotImplementedException("PaymentCalculationPeriodHelper.GetSpread cannot be called on fixed rate cashflow.");
}
numberOfPeriods += 1;
}
return(result / numberOfPeriods);
}
public static void UpdateFloatingRateDefinition(FloatingRateDefinition floatingRateDefinition,
FloatingRateCalculation floatingRateCalculation,
DayCountFraction dayCountFraction,
CalculationPeriod calculationPeriod,
IRateCurve forecastCurve)
{
var rateObservation = new RateObservation();
if (floatingRateDefinition.rateObservation != null)
{
if (floatingRateDefinition.rateObservation[0].adjustedFixingDateSpecified)
{
rateObservation.adjustedFixingDate = floatingRateDefinition.rateObservation[0].adjustedFixingDate;
rateObservation.adjustedFixingDateSpecified = true;
}
}
floatingRateDefinition.rateObservation = new[] { rateObservation };
rateObservation.forecastRate = GetForecastRate(calculationPeriod, forecastCurve, dayCountFraction);
rateObservation.forecastRateSpecified = true;
Decimal finalRate = rateObservation.forecastRate;
// If spread specified - add it to the final rate.
//
if (floatingRateDefinition.spreadSpecified)
{
finalRate += floatingRateDefinition.spread;
}
// Apply rounding (if it's been specified)
//
if (null != floatingRateCalculation.finalRateRounding)
{
Rounding finalRateRounding = floatingRateCalculation.finalRateRounding;
floatingRateDefinition.calculatedRate = RoundingHelper.Round(finalRate, finalRateRounding);
}
else
{
floatingRateDefinition.calculatedRate = finalRate;
}
floatingRateDefinition.calculatedRateSpecified = true;
}
/// <summary>
/// Builds the calculation period.
/// </summary>
/// <returns></returns>
protected override CalculationPeriod BuildCalculationPeriod()
{
CalculationPeriod cp = base.BuildCalculationPeriod();
//Set the floating rate definition
if (FloorStrike != null)
{
FloatingRateDefinition floatingRateDefinition = CapStrike != null?
FloatingRateDefinitionHelper.CreateCapFloor(ForecastRateIndex.floatingRateIndex, ForecastRateIndex.indexTenor, AdjustedFixingDate, GetRate(), Margin, (decimal)CapStrike, true)
: FloatingRateDefinitionHelper.CreateCapFloor(ForecastRateIndex.floatingRateIndex, ForecastRateIndex.indexTenor, AdjustedFixingDate, GetRate(), Margin, (decimal)FloorStrike, false);
cp.Item1 = floatingRateDefinition;
if (floatingRateDefinition.calculatedRateSpecified)
{
cp.forecastRate = floatingRateDefinition.calculatedRate;
cp.forecastRateSpecified = true;
}
}
if (CalculationPerformedIndicator)
{
cp.forecastAmount = ForecastAmount;
}
return(cp);
}
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);
}
private static Cashflows UpdateCashflowsWithDetailedCashflows(IEnumerable <InputCashflowRangeItem> listDetailedCashflows /*, bool fixedLeg*/)
{
var cashflows = new Cashflows();
var paymentCalculationPeriods = new List <PaymentCalculationPeriod>();
foreach (var detailedCashflowRangeItem in listDetailedCashflows)
{
var paymentCalculationPeriod = new PaymentCalculationPeriod();
var calculationPeriod = new CalculationPeriod();
paymentCalculationPeriod.Items = new object[] { calculationPeriod };
paymentCalculationPeriod.adjustedPaymentDate = detailedCashflowRangeItem.PaymentDate;
paymentCalculationPeriod.adjustedPaymentDateSpecified = true;
PaymentCalculationPeriodHelper.SetCalculationPeriodStartDate(paymentCalculationPeriod, detailedCashflowRangeItem.StartDate);
PaymentCalculationPeriodHelper.SetCalculationPeriodEndDate(paymentCalculationPeriod, detailedCashflowRangeItem.EndDate);
// Update notional amount
//
PaymentCalculationPeriodHelper.SetNotionalAmount(paymentCalculationPeriod, (decimal)detailedCashflowRangeItem.NotionalAmount);
switch (detailedCashflowRangeItem.CouponType.ToLower())
{
case "cap":
{
var floatingRateDefinition = new FloatingRateDefinition();
calculationPeriod.Item1 = floatingRateDefinition;
// After the spread is reset - we need to update calculated rate.
//
PaymentCalculationPeriodHelper.SetSpread(paymentCalculationPeriod, (decimal)detailedCashflowRangeItem.Spread);
floatingRateDefinition.capRate = new[] { new Strike() };
floatingRateDefinition.capRate[0].strikeRate = (decimal)detailedCashflowRangeItem.StrikeRate; //tODO There is no fixing date.
{
var rateObservation = new RateObservation
{
adjustedFixingDate =
detailedCashflowRangeItem.FixingDate,
adjustedFixingDateSpecified = true
};
floatingRateDefinition.rateObservation = new[] { rateObservation };
}
break;
}
case "floor":
{
var floatingRateDefinition = new FloatingRateDefinition();
//XsdClassesFieldResolver.CalculationPeriod_SetFloatingRateDefinition(calculationPeriod, floatingRateDefinition);
calculationPeriod.Item1 = floatingRateDefinition;
// After the spread is reset - we need to update calculated rate.
//
PaymentCalculationPeriodHelper.SetSpread(paymentCalculationPeriod, (decimal)detailedCashflowRangeItem.Spread);
floatingRateDefinition.capRate = new[] { new Strike() };
floatingRateDefinition.capRate[0].strikeRate = (decimal)detailedCashflowRangeItem.StrikeRate;
{
var rateObservation = new RateObservation
{
adjustedFixingDate =
detailedCashflowRangeItem.FixingDate,
adjustedFixingDateSpecified = true
};
floatingRateDefinition.rateObservation = new[] { rateObservation };
}
break;
}
default:
{
string message = String.Format("Specified coupon type : '{0}' is not supported. Please use one of these: 'cap, floor'", detailedCashflowRangeItem.CouponType.ToLower());
throw new NotSupportedException(message);
}
}
paymentCalculationPeriods.Add(paymentCalculationPeriod);
}
cashflows.cashflowsMatchParameters = true;
cashflows.paymentCalculationPeriod = paymentCalculationPeriods.ToArray();
return(cashflows);
}
public static void CalculationPeriodSetFloatingRateDefinition(CalculationPeriod calculationPeriod, FloatingRateDefinition value)
{
calculationPeriod.Item1 = value;
}
/// <summary>
///
/// </summary>
/// <param name="buyerIsBase"></param>
/// <param name="calculation"></param>
/// <param name="coupon"></param>
/// <param name="fOCalculationMethod"></param>
/// <param name="fixingCalendar"></param>
/// <param name="paymentCalendar"></param>
/// <returns></returns>
public static PriceableCapFloorCoupon CreatePriceableCapFloorCoupon(bool buyerIsBase,
Calculation calculation, PaymentCalculationPeriod coupon, bool fOCalculationMethod
, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar)
{
var notional = (Notional)calculation.Item;
var currency = notional.notionalStepSchedule.currency;
var dayCountFraction = calculation.dayCountFraction;
var paymentDate = coupon.adjustedPaymentDateSpecified
? coupon.adjustedPaymentDate
: coupon.unadjustedPaymentDate;
var calculationPeriods =
XsdClassesFieldResolver.GetPaymentCalculationPeriodCalculationPeriodArray(coupon);
if (calculationPeriods.Length == 1)
{
var calculationPeriod = calculationPeriods[0];
//Money expectedCashFlow = null;
decimal notionalamount = XsdClassesFieldResolver.CalculationPeriodGetNotionalAmount(calculationPeriod);
Money money = buyerIsBase ? MoneyHelper.GetAmount(-1 * notionalamount, currency) : MoneyHelper.GetAmount(notionalamount, currency);
var accrualStartDate = calculationPeriod.adjustedStartDateSpecified
? calculationPeriod.adjustedStartDate
: calculationPeriod.unadjustedStartDate;
var accrualEndDate = calculationPeriod.adjustedEndDateSpecified
? calculationPeriod.adjustedEndDate
: calculationPeriod.unadjustedEndDate;
// If has a fixed rate (fixed rate coupon)
var isThereDiscounting = XsdClassesFieldResolver.CalculationHasDiscounting(calculation);
if (XsdClassesFieldResolver.CalculationPeriodHasFloatingRateDefinition(calculationPeriod))
{
//The floating rate definition.
FloatingRateDefinition floatingRateDefinition = XsdClassesFieldResolver.CalculationPeriodGetFloatingRateDefinition(calculationPeriod);
//The floatingrateCalculation.
Debug.Assert(calculation.Items != null);
Debug.Assert(calculation.Items.Length > 0);
Debug.Assert(calculation.Items[0] is FloatingRateCalculation);
var floatingRateCalculation = (FloatingRateCalculation)calculation.Items[0];
//The forecast rate index.
var floatingRateIndex = floatingRateCalculation.floatingRateIndex;
var indexTenor = floatingRateCalculation.indexTenor.ToString();
var forecastRate = ForecastRateIndexHelper.Parse(floatingRateIndex.Value, indexTenor);
//The rate observation
// Apply spread from schedule if it hasn't been specified yet.
decimal margin = 0m;
if (floatingRateDefinition.spreadSpecified)
{
margin = floatingRateDefinition.spread;
}
//The observed rate.
Decimal?observedRate = null;
Decimal?capStrike = null;
Decimal?floorStrike = null;
if (floatingRateDefinition.capRate != null)
{
capStrike = floatingRateDefinition.capRate[0].strikeRate;
}
if (floatingRateDefinition.floorRate != null)
{
floorStrike = floatingRateDefinition.floorRate[0].strikeRate;
}
if (floatingRateDefinition.rateObservation != null)
{
var rateObservation = floatingRateDefinition.rateObservation[0];
if (rateObservation.observedRateSpecified)
{
observedRate = rateObservation.observedRate;
}
PriceableCapFloorCoupon rateCoupon;
if (isThereDiscounting)
{
var discounting = XsdClassesFieldResolver.CalculationGetDiscounting(calculation);
var floatingCouponWithDiscounting = new PriceableCapFloorCoupon(coupon.id, buyerIsBase,
capStrike, floorStrike, accrualStartDate, accrualEndDate,
rateObservation.adjustedFixingDate, dayCountFraction,
margin, observedRate, money, paymentDate,
forecastRate, discounting.discountingType,
observedRate, null, fixingCalendar, paymentCalendar);
if (fOCalculationMethod)
{
floatingCouponWithDiscounting.ForecastRateInterpolation = true;
}
rateCoupon = floatingCouponWithDiscounting;
return(rateCoupon);
}
var floatingCoupon = new PriceableCapFloorCoupon(coupon.id, buyerIsBase, capStrike, floorStrike,
accrualStartDate, accrualEndDate,
rateObservation.adjustedFixingDate, dayCountFraction,
margin, observedRate, money, paymentDate,
forecastRate, null, null, null,
fixingCalendar, paymentCalendar);
if (fOCalculationMethod)
{
floatingCoupon.ForecastRateInterpolation = true;
}
rateCoupon = floatingCoupon;
return(rateCoupon);
}
throw new NotImplementedException("Need to return a rate coupon, Alex!");
}
throw new System.Exception("CalculationPeriod has neither fixedRate nor floatingRateDefinition.");
}
throw new System.Exception("PaymentCalculationPeriod has zero, or multiple CalculationPeriods.");
}
/// <summary>
///
/// </summary>
/// <param name="payerIsBase"></param>
/// <param name="calculation"></param>
/// <param name="coupon"></param>
/// <param name="fOCalculationMethod"></param>
/// <param name="fixingCalendar"></param>
/// <param name="paymentCalendar"></param>
/// <returns></returns>
public static PriceableRateCoupon CreatePriceableCoupon(bool payerIsBase, Calculation calculation, PaymentCalculationPeriod coupon, bool fOCalculationMethod
, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar)
{
var notional = (Notional)calculation.Item;
var currency = notional.notionalStepSchedule.currency;
var dayCountFraction = calculation.dayCountFraction;
var paymentDate = coupon.adjustedPaymentDateSpecified
? coupon.adjustedPaymentDate
: coupon.unadjustedPaymentDate;
var calculationPeriods = XsdClassesFieldResolver.GetPaymentCalculationPeriodCalculationPeriodArray(coupon);
var discountFactorSpecified = coupon.discountFactorSpecified;
if (calculationPeriods.Length == 1)
{
var calculationPeriod = calculationPeriods[0];
var notionalAmount = XsdClassesFieldResolver.CalculationPeriodGetNotionalAmount(calculationPeriod);
var money = payerIsBase ? MoneyHelper.GetAmount(-1 * notionalAmount, currency) : MoneyHelper.GetAmount(notionalAmount, currency);
var accrualStartDate = calculationPeriod.adjustedStartDateSpecified
? calculationPeriod.adjustedStartDate
: calculationPeriod.unadjustedStartDate;
var accrualEndDate = calculationPeriod.adjustedEndDateSpecified
? calculationPeriod.adjustedEndDate
: calculationPeriod.unadjustedEndDate;
// If has a fixed rate (fixed rate coupon)
var isThereDiscounting = XsdClassesFieldResolver.CalculationHasDiscounting(calculation);
PriceableRateCoupon rateCoupon;
if (XsdClassesFieldResolver.CalculationPeriodHasFixedRate(calculationPeriod))
{
decimal finalRate = XsdClassesFieldResolver.CalculationPeriodGetFixedRate(calculationPeriod);
//The discount rate must be set. It would normally be the final rate. The assumption is that, it the discounting rate is zero then the final rate should be used.
if (isThereDiscounting)
{
var discounting = XsdClassesFieldResolver.CalculationGetDiscounting(calculation);
//This test works because if the rate is zero, then the coupon is not discounted and discounting Type should be null.
var discountRate = discounting.discountRate == 0.0m ? finalRate : discounting.discountRate;
rateCoupon = new PriceableFixedRateCoupon(coupon.id, payerIsBase, accrualStartDate, accrualEndDate,
dayCountFraction, finalRate, money, null, paymentDate, discounting.discountingType, discountRate,
null, paymentCalendar);
if (discountFactorSpecified)
{
rateCoupon.PaymentDiscountFactor = coupon.discountFactor;
}
return(rateCoupon);
}
rateCoupon = new PriceableFixedRateCoupon(coupon.id, payerIsBase, accrualStartDate, accrualEndDate,
dayCountFraction, finalRate, money, null, paymentDate, null, null,
null, paymentCalendar);
if (discountFactorSpecified)
{
rateCoupon.PaymentDiscountFactor = coupon.discountFactor;
}
return(rateCoupon);
}
if (XsdClassesFieldResolver.CalculationPeriodHasFloatingRateDefinition(calculationPeriod))
{
//The floating rate definition.
FloatingRateDefinition floatingRateDefinition = XsdClassesFieldResolver.CalculationPeriodGetFloatingRateDefinition(calculationPeriod);
//The floating rate Calculation.
Debug.Assert(calculation.Items != null);
Debug.Assert(calculation.Items.Length > 0);
Debug.Assert(calculation.Items[0] is FloatingRateCalculation);
var floatingRateCalculation = (FloatingRateCalculation)calculation.Items[0];
//The forecast rate index.
var floatingRateIndex = floatingRateCalculation.floatingRateIndex;
var indexTenor = floatingRateCalculation.indexTenor.ToString();
var forecastRate = ForecastRateIndexHelper.Parse(floatingRateIndex.Value, indexTenor);
//The rate observation
// Apply spread from schedule if it hasn't been specified yet.
var margin = 0m;
if (floatingRateDefinition.spreadSpecified)
{
margin = floatingRateDefinition.spread;
}
//The observed rate.
Decimal?observedRate = null;
Decimal?capStrike = null;
Decimal?floorStrike = null;
if (floatingRateDefinition.capRate != null)
{
capStrike = floatingRateDefinition.capRate[0].strikeRate;
}
if (floatingRateDefinition.floorRate != null)
{
floorStrike = floatingRateDefinition.floorRate[0].strikeRate;
}
if (floatingRateDefinition.rateObservation != null)//TODO This is a big problem. Need to handle the case of no fixing date!
{
var rateObservation = floatingRateDefinition.rateObservation[0];
if (rateObservation.observedRateSpecified)
{
observedRate = rateObservation.observedRate;
}
//Removed because Igor's old code populates these fields when the trade is created. This means the coupon is not recalculated!
//Now the coupon will ignore any previous calculations and only treat as a fixed coupon if the observed rate has been specified.
if (isThereDiscounting)
{
var discounting = XsdClassesFieldResolver.CalculationGetDiscounting(calculation);
if (capStrike != null || floorStrike != null)
{
rateCoupon = new PriceableCapFloorCoupon(coupon.id, !payerIsBase,
capStrike, floorStrike, accrualStartDate, accrualEndDate,
rateObservation.adjustedFixingDate, dayCountFraction,
margin, observedRate, money, paymentDate,
forecastRate, discounting.discountingType,
observedRate, null, fixingCalendar, paymentCalendar);
}
else
{
rateCoupon = new PriceableFloatingRateCoupon(coupon.id, !payerIsBase, accrualStartDate, accrualEndDate,
rateObservation.adjustedFixingDate, dayCountFraction,
margin, observedRate, money, paymentDate,
forecastRate, discounting.discountingType,
observedRate, null, fixingCalendar, paymentCalendar);
}
}
else
{
if (capStrike != null || floorStrike != null)
{
rateCoupon = new PriceableCapFloorCoupon(coupon.id, !payerIsBase, capStrike, floorStrike,
accrualStartDate, accrualEndDate,
rateObservation.adjustedFixingDate, dayCountFraction,
margin, observedRate, money, paymentDate,
forecastRate, null, null, null,
fixingCalendar, paymentCalendar);
}
else
{
rateCoupon = new PriceableFloatingRateCoupon(coupon.id, payerIsBase, accrualStartDate, accrualEndDate,
rateObservation.adjustedFixingDate, dayCountFraction,
margin, observedRate, money, paymentDate,
forecastRate, null, null, null,
fixingCalendar, paymentCalendar);
}
}
if (fOCalculationMethod)
{
((PriceableFloatingRateCoupon)rateCoupon).ForecastRateInterpolation = true;
}
if (discountFactorSpecified)
{
rateCoupon.PaymentDiscountFactor = coupon.discountFactor;
}
return(rateCoupon);
}
throw new NotImplementedException("Need to return a rate coupon, Alex!");
}
throw new System.Exception("CalculationPeriod has neither fixedRate nor floatingRateDefinition.");
}
throw new System.Exception("PaymentCalculationPeriod has zero, or multiple CalculationPeriods.");
}
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);
}
public List <DetailedCashflowRangeItem> GetDetailedCashflowsWithNotionalSchedule(
ILogger logger, ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
CapFloorLegParametersRange_Old legParametersRange,
List <DateTimeDoubleRangeItem> notionalValueItems,
ValuationRange valuationRange)
{
//Check if the calendars are null. If not build them!
var list1 = notionalValueItems.Select(item => new Pair <DateTime, decimal>(item.DateTime, Convert.ToDecimal(item.Value))).ToList();
NonNegativeSchedule notionalScheduleFpML = NonNegativeScheduleHelper.Create(list1);
Currency currency = CurrencyHelper.Parse(legParametersRange.Currency);
NonNegativeAmountSchedule amountSchedule = NonNegativeAmountScheduleHelper.Create(notionalScheduleFpML, currency);
InterestRateStream interestRateStream = GetCashflowsScheduleWithNotionalSchedule(fixingCalendar, paymentCalendar, legParametersRange, amountSchedule);
//Add the principal exchanges to the cashflows.
var principalExchangeList = list1.Select(cashflow => new PrincipalExchange
{
adjustedPrincipalExchangeDate = cashflow.First, adjustedPrincipalExchangeDateSpecified = true, principalExchangeAmount = cashflow.Second, principalExchangeAmountSpecified = true
}).ToArray();
interestRateStream.cashflows.principalExchange = principalExchangeList;
UpdateCashflowsWithAmounts(logger, cache, nameSpace, interestRateStream, legParametersRange, valuationRange);
var list = new List <DetailedCashflowRangeItem>();
foreach (PaymentCalculationPeriod paymentCalculationPeriod in interestRateStream.cashflows.paymentCalculationPeriod)
{
var detailedCashflowRangeItem = new DetailedCashflowRangeItem();
detailedCashflowRangeItem.PaymentDate = paymentCalculationPeriod.adjustedPaymentDate;
detailedCashflowRangeItem.StartDate = PaymentCalculationPeriodHelper.GetCalculationPeriodStartDate(paymentCalculationPeriod);
detailedCashflowRangeItem.EndDate = PaymentCalculationPeriodHelper.GetCalculationPeriodEndDate(paymentCalculationPeriod);
detailedCashflowRangeItem.NumberOfDays = PaymentCalculationPeriodHelper.GetNumberOfDays(paymentCalculationPeriod);
detailedCashflowRangeItem.FutureValue = MoneyHelper.ToDouble(paymentCalculationPeriod.forecastPaymentAmount);
detailedCashflowRangeItem.PresentValue = MoneyHelper.ToDouble(paymentCalculationPeriod.presentValueAmount);
detailedCashflowRangeItem.DiscountFactor = (double)paymentCalculationPeriod.discountFactor;
detailedCashflowRangeItem.NotionalAmount = (double)PaymentCalculationPeriodHelper.GetNotionalAmount(paymentCalculationPeriod);
detailedCashflowRangeItem.CouponType = GetCouponType(paymentCalculationPeriod);
detailedCashflowRangeItem.Rate = (double)PaymentCalculationPeriodHelper.GetRate(paymentCalculationPeriod);
CalculationPeriod calculationPeriod = PaymentCalculationPeriodHelper.GetCalculationPeriods(paymentCalculationPeriod)[0];
FloatingRateDefinition floatingRateDefinition = XsdClassesFieldResolver.CalculationPeriodGetFloatingRateDefinition(calculationPeriod);
switch (detailedCashflowRangeItem.CouponType.ToLower())
{
case "cap":
{
Strike strike = floatingRateDefinition.capRate[0];
detailedCashflowRangeItem.StrikeRate = (double)strike.strikeRate;
break;
}
case "floor":
{
Strike strike = floatingRateDefinition.floorRate[0];
detailedCashflowRangeItem.StrikeRate = (double)strike.strikeRate;
break;
}
default:
{
string message =
String.Format("Specified coupon type : '{0}' is not supported. Please use one of these: 'cap, floor'", detailedCashflowRangeItem.CouponType.ToLower());
throw new NotSupportedException(message);
}
}
// If floating rate - retrieve the spread.
//
detailedCashflowRangeItem.Spread = (double)PaymentCalculationPeriodHelper.GetSpread(paymentCalculationPeriod);
var fixingDate = new DateTime();
var tempDate = PaymentCalculationPeriodHelper.GetFirstFloatingFixingDate(paymentCalculationPeriod);
if (tempDate != null)
{
fixingDate = (DateTime)tempDate;
}
detailedCashflowRangeItem.FixingDate = fixingDate;
detailedCashflowRangeItem.Currency = "Not Specified";
if (currency != null)
{
detailedCashflowRangeItem.Currency = currency.Value;
}
list.Add(detailedCashflowRangeItem);
}
return(list);
}
