public static RateObservation[] Create(DateTime resetDate,
DateTime adjustedFixingDate,
decimal observedRate,
decimal treatedRate,
string observationWeight,
string rateReference,
decimal forecastRate,
decimal treatedForecastRate,
string id)
{
RateObservation rateObservation = new RateObservation();
RateObservation[] rateObservations = new RateObservation[1];
rateObservation.resetDate = resetDate;
rateObservation.resetDateSpecified = true;
rateObservation.adjustedFixingDate = adjustedFixingDate;
rateObservation.adjustedFixingDateSpecified = true;
rateObservation.observedRate = observedRate;
rateObservation.observedRateSpecified = true;
rateObservation.treatedRate = treatedRate;
rateObservation.treatedRateSpecified = true;
rateObservation.observationWeight = observationWeight;
rateObservation.rateReference = RateReferenceHelper.Parse(rateReference);
rateObservation.forecastRate = forecastRate;
rateObservation.forecastRateSpecified = true;
rateObservation.treatedForecastRate = treatedForecastRate;
rateObservation.treatedForecastRateSpecified = true;
rateObservation.id = id;
rateObservations[0] = rateObservation;
return(rateObservations);
}
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);
}
/// <summary>
/// Sets the rate observation.
/// </summary>
/// <param name="rateObservation">The rate observation.</param>
/// <param name="resetDate">The reset date.</param>
private void SetRateObservation(RateObservation rateObservation, DateTime resetDate)
{
if (rateObservation != null)
{
if (rateObservation.observedRateSpecified)
{
Rate = rateObservation.observedRate;
UseObservedRate = true;
}
if (!rateObservation.adjustedFixingDateSpecified)
{
rateObservation.adjustedFixingDate = resetDate;
rateObservation.adjustedFixingDateSpecified = true;
}
}
}
public static RateObservation[] Create(DateTime adjustedFixingDate,
decimal observedRate)
{
RateObservation rateObservation = new RateObservation();
RateObservation[] rateObservations = new RateObservation[1];
rateObservation.resetDateSpecified = false;
rateObservation.adjustedFixingDate = adjustedFixingDate;
rateObservation.adjustedFixingDateSpecified = true;
rateObservation.observedRate = observedRate;
rateObservation.observedRateSpecified = true;
rateObservation.observationWeight = "1";
rateObservation.forecastRate = observedRate;
rateObservation.forecastRateSpecified = true;
rateObservations[0] = rateObservation;
return(rateObservations);
}
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;
}
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 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);
}
