/// <summary>
///
/// </summary>
/// <param name="baseParty"></param>
/// <param name="payment"></param>
/// <param name="paymentCalendar"></param>
/// <returns></returns>
public static PriceablePayment CreatePriceablePayment(string baseParty, Payment payment, IBusinessCalendar paymentCalendar)
{
const int index = 0;
bool payerIsBase = false;
string id;
if (payment.id == null)
{
id = "Payment_" + index;
}
else
{
id = payment.id;
}
if (baseParty == payment.payerPartyReference.href)
{
payerIsBase = true;
}
var multiplier = payerIsBase ? -1.0m : 1.0m;
if (payment.paymentDate != null)
{
return(new PriceablePayment(id, payment.payerPartyReference.href,
payment.receiverPartyReference.href, payerIsBase, MoneyHelper.Mul(payment.paymentAmount, multiplier),
payment.paymentDate, paymentCalendar));
}
var amount = MoneyHelper.Mul(payment.paymentAmount, multiplier);
return(new PriceablePayment(id, payment.payerPartyReference.href,
payment.receiverPartyReference.href, payerIsBase, amount, payment.paymentDate, paymentCalendar));
}
/// <summary>
/// Creates a fixed coupon calculation period.
/// </summary>
/// <param name="accrualStartDate"></param>
/// <param name="accrualEndDate"></param>
/// <param name="notionalAmount"></param>
/// <param name="calculation"></param>
/// <returns></returns>
public static CalculationPeriod[] CreateSimpleCouponItem(DateTime accrualStartDate, DateTime accrualEndDate,
Money notionalAmount, Calculation calculation)
{
IDayCounter dayCounter = DayCounterHelper.Parse(calculation.dayCountFraction.Value);
var calculationPeriod = new CalculationPeriod();
int numDays = dayCounter.DayCount(accrualStartDate, accrualEndDate);
calculationPeriod.adjustedStartDate = accrualStartDate;
calculationPeriod.adjustedStartDateSpecified = true;
calculationPeriod.adjustedEndDate = accrualEndDate;
calculationPeriod.adjustedEndDateSpecified = true;
calculationPeriod.dayCountYearFraction = (decimal)dayCounter.YearFraction(accrualStartDate, accrualEndDate);
calculationPeriod.dayCountYearFractionSpecified = true;
calculationPeriod.calculationPeriodNumberOfDays = numDays.ToString(CultureInfo.InvariantCulture);
calculationPeriod.Item = notionalAmount.amount;
calculationPeriod.unadjustedEndDateSpecified = false;
calculationPeriod.unadjustedStartDateSpecified = false;
calculationPeriod.Item1 = calculation;
var rate = ((Schedule)calculation.Items[0]).initialValue;
calculationPeriod.forecastRate = rate;
calculationPeriod.forecastRateSpecified = true;
calculationPeriod.forecastAmount = MoneyHelper.Mul(notionalAmount,
calculationPeriod.dayCountYearFraction *
calculationPeriod.forecastRate);
var calculationPeriods = new List <CalculationPeriod> {
calculationPeriod
};
return(calculationPeriods.ToArray());
}
private static void CalculateForecastPaymentAmount(PrincipalExchange principleExchange,
IRateCurve discountCurve,
DateTime valuationDate)
{
principleExchange.discountFactor = (decimal)discountCurve.GetDiscountFactor(valuationDate, principleExchange.adjustedPrincipalExchangeDate);
principleExchange.discountFactorSpecified = true;
principleExchange.presentValuePrincipalExchangeAmount = MoneyHelper.Mul(MoneyHelper.GetAmount(principleExchange.principalExchangeAmount), principleExchange.discountFactor);
}
public static void UpdatePaymentsAmounts(IBusinessCalendar paymentCalendar,
CapFloor capFloor,
CapFloorLegParametersRange capFloorLeg,
IRateCurve discountCurve,
DateTime valuationDate)
{
foreach (Payment payment in capFloor.additionalPayment)
{
var date = AdjustedDateHelper.GetAdjustedDate(paymentCalendar, payment.paymentDate);
if (date != null)
{
payment.discountFactor = (decimal)discountCurve.GetDiscountFactor(valuationDate, (DateTime)date);
payment.discountFactorSpecified = true;
payment.presentValueAmount = MoneyHelper.Mul(payment.paymentAmount, payment.discountFactor);
}
}
}
/// <summary>
/// Builds this instance.
/// </summary>
/// <returns></returns>
public PrincipalExchange Build()
{
var money = MoneyHelper.Mul(PaymentAmount, PayerIsBaseParty);
var px = PrincipalExchangeHelper.Create(PaymentDate, money.amount);
px.id = Id;
//px.
px.adjustedPrincipalExchangeDate = PaymentDate;
px.adjustedPrincipalExchangeDateSpecified = true;
if (CalculationPerfomedIndicator)
{
px.discountFactor = PaymentDiscountFactor;
var npv = System.Math.Abs(ForecastAmount.amount) * PaymentDiscountFactor;
px.discountFactorSpecified = true;
px.presentValuePrincipalExchangeAmount = MoneyHelper.Mul(npv, PaymentAmount.currency.Value, PayerIsBaseParty);
}
return(px);
}
public static void UpdatePaymentsAmounts(ILogger logger, ICoreCache cache,
String nameSpace, Swap swap,
SwapLegParametersRange leg1Parameters,
SwapLegParametersRange leg2Parameters,
IRateCurve leg1DiscountCurve,
IRateCurve leg2DiscountCurve,
DateTime valuationDate, IBusinessCalendar paymentCalendar)
{
foreach (Payment payment in swap.additionalPayment)
{
// choose correct discount curve
//
IRateCurve discountCurve;
if (payment.payerPartyReference.href == leg1Parameters.Payer)
{
discountCurve = leg1DiscountCurve;
}
else if (payment.payerPartyReference.href == leg2Parameters.Payer)
{
discountCurve = leg2DiscountCurve;
}
else
{
throw new NotImplementedException();
}
if (paymentCalendar == null)
{
var containsPaymentDateAdjustments = AdjustableOrAdjustedDateHelper.Contains(payment.paymentDate, ItemsChoiceType.dateAdjustments, out var dateAdjustments);
if (containsPaymentDateAdjustments && dateAdjustments != null)
{
paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, ((BusinessDayAdjustments)dateAdjustments).
businessCenters, nameSpace);
}
}
var date = AdjustedDateHelper.GetAdjustedDate(paymentCalendar, payment.paymentDate);
if (date == null)
{
continue;
}
payment.discountFactor = (decimal)discountCurve.GetDiscountFactor(valuationDate, (DateTime)date);
payment.discountFactorSpecified = true;
payment.presentValueAmount = MoneyHelper.Mul(payment.paymentAmount, payment.discountFactor);
}
}
/// <summary>
///
/// </summary>
/// <param name="nameSpace"></param>
/// <param name="baseDateForRelativeOffset"></param>
/// <param name="baseParty"></param>
/// <param name="optionPremia"></param>
/// <param name="fixingCalendar"></param>
/// <param name="paymentCalendar"> </param>
/// <param name="cache"></param>
/// <returns></returns>
public static PriceableFxOptionPremium CreatePriceableFxOptionPremium(ICoreCache cache, String nameSpace,
DateTime?baseDateForRelativeOffset, string baseParty, FxOptionPremium optionPremia,
IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar)
{
bool payerIsBase = baseParty == optionPremia.payerPartyReference.href;
var multiplier = payerIsBase ? -1.0m : 1.0m;
var settlementDate = AdjustedDateHelper.GetAdjustedDate(cache, nameSpace, fixingCalendar, baseDateForRelativeOffset, optionPremia.paymentDate);
if (settlementDate == null)
{
return(null);
}
var date = new PriceableFxOptionPremium("FxOptionPremiumPayment", optionPremia.payerPartyReference.href,
optionPremia.receiverPartyReference.href, payerIsBase,
MoneyHelper.Mul(optionPremia.paymentAmount, multiplier),
(DateTime)settlementDate, optionPremia.quote,
optionPremia.settlementInformation, paymentCalendar);
return(date);
}
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);
}
