/// <summary>
/// Converts to an adjustable date type.
/// </summary>
/// <param name="unadjustedDate"></param>
/// <param name="businessDayConventions"></param>
/// <param name="businessCentersAsString"></param>
/// <param name="businessCalendar"></param>
/// <returns></returns>
public static DateTime ToAdjustedDate(IBusinessCalendar businessCalendar, DateTime unadjustedDate, string businessDayConventions, string businessCentersAsString)
{
AdjustableDate adjustableDate = DateTypesHelper.ToAdjustableDate(unadjustedDate, businessDayConventions, businessCentersAsString);
DateTime adjustedDate = ToAdjustedDate(businessCalendar, adjustableDate);
return(adjustedDate);
}
/// <summary>
/// Converts to an adjustable date type.
/// </summary>
/// <param name="cache"></param>
/// <param name="unadjustedDate"></param>
/// <param name="businessDayConventions"></param>
/// <param name="businessCentersAsString"></param>
/// <param name="nameSpace"></param>
/// <returns></returns>
public static DateTime ToAdjustedDate(ICoreCache cache, DateTime unadjustedDate, string businessDayConventions, string businessCentersAsString, string nameSpace)
{
AdjustableDate adjustableDate = DateTypesHelper.ToAdjustableDate(unadjustedDate, businessDayConventions, businessCentersAsString);
DateTime adjustedDate = ToAdjustedDate(cache, adjustableDate, nameSpace);
return(adjustedDate);
}
public static Trade CreateFraTrade(FraInputRange2 fraInputRange)
{
var trade = new Trade();
var fra = new Fra
{
adjustedEffectiveDate =
DateTypesHelper.ToRequiredIdentifierDate(fraInputRange.AdjustedEffectiveDate),
adjustedTerminationDate = fraInputRange.AdjustedTerminationDate,
adjustedTerminationDateSpecified = true,
paymentDate =
DateTypesHelper.ToAdjustableDate(fraInputRange.UnadjustedPaymentDate,
fraInputRange.PaymentDateBusinessDayConvention,
fraInputRange.PaymentDateBusinessCenters),
Items = new object[] { new ProductType {
Value = ProductTypeSimpleEnum.FRA.ToString()
} },
ItemsElementName = new[] { ItemsChoiceType2.productType }
};
if ("resetDate" != fraInputRange.FixingDayOffsetDateRelativeTo)
{
throw new ArgumentException("The fixing date must be specified as 'resetDate'-relative!", nameof(fraInputRange));
}
var fixingDayType = EnumHelper.Parse <DayTypeEnum>(fraInputRange.FixingDayOffsetDayType);
fra.fixingDateOffset = RelativeDateOffsetHelper.Create(fraInputRange.FixingDayOffsetPeriod, fixingDayType,
fraInputRange.FixingDayOffsetBusinessDayConvention,
fraInputRange.FixingDayOffsetBusinessCenters,
fraInputRange.FixingDayOffsetDateRelativeTo);
fra.dayCountFraction = DayCountFractionHelper.Parse(fraInputRange.DayCountFraction);
IDayCounter dayCounter = DayCounterHelper.Parse(fra.dayCountFraction.Value);
fra.calculationPeriodNumberOfDays = dayCounter.DayCount(fra.adjustedEffectiveDate.Value, fra.adjustedTerminationDate).ToString(CultureInfo.InvariantCulture);
fra.notional = MoneyHelper.GetAmount(fraInputRange.NotionalAmount, fraInputRange.NotionalCurrency);
fra.fixedRate = (decimal)fraInputRange.FixedRate;
fra.fixedRateSpecified = true;
fra.floatingRateIndex = FloatingRateIndexHelper.Parse(fraInputRange.FloatingRateIndex);
fra.indexTenor = new[] { PeriodHelper.Parse(fraInputRange.IndexTenor) };
fra.fraDiscounting = fraInputRange.FraDiscounting;
fra.fraDiscountingSpecified = true;
PartyReference party1 = PartyReferenceFactory.Create("party1");
PartyReference party2 = PartyReferenceFactory.Create("party2");
fra.sellerPartyReference = party1;
fra.buyerPartyReference = party2;
if (bool.Parse(fraInputRange.IsParty1Buyer))
{
fra.sellerPartyReference = party2;
fra.buyerPartyReference = party1;
}
XsdClassesFieldResolver.TradeSetFra(trade, fra);
trade.id = fraInputRange.TradeId;
return(trade);
}
public static CapFloor GeneratedFpMLCapFloor(
ILogger logger, ICoreCache cache,
CapFloorLegParametersRange capFloorParametersRange,
List <InputCashflowRangeItem> capFloorDetailedCashflowsList,
List <InputPrincipalExchangeCashflowRangeItem> capFloorPrincipalExchangeCashflowListArray,
List <AdditionalPaymentRangeItem> capFloorAdditionalPaymentList,
List <FeePaymentRangeItem> feePaymentList
)
{
//Check if the calendars are null. If not build them!
InterestRateStream stream1 = GetCashflowsSchedule(null, null, capFloorParametersRange);//parametric definiton + cashflows schedule
// Update FpML cashflows
//
stream1.cashflows = UpdateCashflowsWithDetailedCashflows(capFloorDetailedCashflowsList);
if (null != capFloorPrincipalExchangeCashflowListArray)
{
// create principal exchanges
//
InterestRateSwapPricer.CreatePrincipalExchangesFromListOfRanges(stream1.cashflows, capFloorPrincipalExchangeCashflowListArray);
}
// Add bullet payments...
//
var bulletPaymentList = new List <Payment>();
if (null != capFloorAdditionalPaymentList)
{
bulletPaymentList.AddRange(capFloorAdditionalPaymentList.Select(bulletPaymentRangeItem =>
new Payment {
payerPartyReference = PartyReferenceFactory.Create(capFloorParametersRange.Payer), receiverPartyReference =
PartyReferenceFactory.Create(capFloorParametersRange.Receiver),
paymentAmount = MoneyHelper.GetNonNegativeAmount(bulletPaymentRangeItem.Amount, bulletPaymentRangeItem.Currency),
paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(bulletPaymentRangeItem.PaymentDate)
}));
}
CapFloor capFloor = CapFloorFactory.Create(stream1);
capFloor.additionalPayment = bulletPaymentList.ToArray();
var feeList = new List <Payment>();
if (null != feePaymentList)
{
feeList.AddRange(feePaymentList.Select(feePaymentRangeItem =>
new Payment
{
paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(feePaymentRangeItem.PaymentDate),
paymentAmount = MoneyHelper.GetNonNegativeAmount(feePaymentRangeItem.Amount, feePaymentRangeItem.Currency), //TODO The currency needs to be added!
payerPartyReference = PartyReferenceFactory.Create(feePaymentRangeItem.Payer),
receiverPartyReference = PartyReferenceFactory.Create(feePaymentRangeItem.Receiver)
}));
}
capFloor.premium = feeList.ToArray();
return(capFloor);
}
private static void SetEffectiveAndTerminationDates(InterestRateStream stream,
DateTime rawEffectiveDate,
DateTime rawTerminationDate,
string terminationDateBusinessDayAdjustments,
string terminationDateBusinessDayCalendar)
{
AdjustableDate effectiveDate = DateTypesHelper.ToAdjustableDate(rawEffectiveDate);
XsdClassesFieldResolver.CalculationPeriodDatesSetEffectiveDate(stream.calculationPeriodDates, effectiveDate);
AdjustableDate terminationDate = DateTypesHelper.ToAdjustableDate(rawTerminationDate, terminationDateBusinessDayAdjustments, terminationDateBusinessDayCalendar);
XsdClassesFieldResolver.CalculationPeriodDatesSetTerminationDate(stream.calculationPeriodDates, terminationDate);
}
internal static Pair <ValuationResultRange, Swap> GetPriceAndGeneratedFpMLSwap(
ILogger logger,
ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
ValuationRange valuationRange,
TradeRange tradeRange,
SwapLegParametersRange_Old leg1ParametersRange,
List <DetailedCashflowRangeItem> leg1DetailedCashflowsList,
List <PrincipalExchangeCashflowRangeItem> leg1PrincipalExchangeCashflowList,
List <AdditionalPaymentRangeItem> leg1AdditionalPaymentList)
{
InterestRateStream stream1 = GetCashflowsSchedule(fixingCalendar, paymentCalendar, leg1ParametersRange);//parametric definiton + cashflows schedule
var swap = SwapFactory.Create(stream1);
// Update FpML cashflows
//
UpdateCashflowsWithDetailedCashflows(stream1.cashflows, leg1DetailedCashflowsList);
// Update PE
//
if (null != leg1PrincipalExchangeCashflowList)
{
CreatePrincipalExchangesFromListOfRanges(stream1.cashflows, leg1PrincipalExchangeCashflowList);
}
// Add bullet payments...
//
if (null != leg1AdditionalPaymentList)
{
swap.additionalPayment = leg1AdditionalPaymentList.Select(bulletPaymentRangeItem => new Payment
{
payerPartyReference = PartyReferenceFactory.Create(leg1ParametersRange.Payer),
receiverPartyReference = PartyReferenceFactory.Create(leg1ParametersRange.Receiver),
paymentAmount = MoneyHelper.GetNonNegativeAmount(bulletPaymentRangeItem.Amount),
paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(bulletPaymentRangeItem.PaymentDate)
}).ToArray();
}
// Update FpML cashflows with DF,FV,PV, etc (LegParametersRange needed to access curve functionality)
//
UpdateCashflowsWithAmounts(logger, cache, nameSpace, stream1, leg1ParametersRange, valuationRange);
// Update additional payments
//
var leg1DiscountCurve = CurveLoader.LoadInterestRateCurve(logger, cache, nameSpace, leg1ParametersRange.DiscountCurve);
SwapGenerator.UpdatePaymentsAmounts(logger, cache, nameSpace, swap, leg1ParametersRange, leg1DiscountCurve, valuationRange.ValuationDate, paymentCalendar);
//~ Update additional payments
string baseParty = valuationRange.BaseParty;
return(new Pair <ValuationResultRange, Swap>(CreateValuationRange(swap, baseParty), swap));
}
/// <summary>
///
/// </summary>
/// <param name="fraInputRange"></param>
/// <returns></returns>
public static Fra GetFpMLFra(FraInputRange fraInputRange)
{
var fra = new Fra
{
adjustedEffectiveDate =
DateTypesHelper.ToRequiredIdentifierDate(fraInputRange.AdjustedEffectiveDate),
adjustedTerminationDate = fraInputRange.AdjustedTerminationDate,
paymentDate =
DateTypesHelper.ToAdjustableDate(fraInputRange.UnadjustedPaymentDate,
fraInputRange.PaymentDateBusinessDayConvention,
fraInputRange.PaymentDateBusinessCenters)
};
if ("resetDate" != fraInputRange.FixingDayOffsetDateRelativeTo)
{
throw new ArgumentException("The fixing date must be specified as 'resetDate'-relative!", nameof(fraInputRange));
}
var fixingDayType = EnumHelper.Parse <DayTypeEnum>(fraInputRange.FixingDayOffsetDayType);
fra.fixingDateOffset = RelativeDateOffsetHelper.Create(fraInputRange.FixingDayOffsetPeriod, fixingDayType,
fraInputRange.FixingDayOffsetBusinessDayConvention,
fraInputRange.FixingDayOffsetBusinessCenters,
fraInputRange.FixingDayOffsetDateRelativeTo);
fra.dayCountFraction = DayCountFractionHelper.Parse(fraInputRange.DayCountFraction);
IDayCounter dayCounter = DayCounterHelper.Parse(fra.dayCountFraction.Value);
fra.calculationPeriodNumberOfDays = dayCounter.DayCount(fra.adjustedEffectiveDate.Value, fra.adjustedTerminationDate).ToString();
fra.notional = MoneyHelper.GetAmount(fraInputRange.NotionalAmount, fraInputRange.NotionalCurrency);
fra.fixedRate = (decimal)fraInputRange.FixedRate;
fra.floatingRateIndex = FloatingRateIndexHelper.Parse(fraInputRange.FloatingRateIndex);
fra.indexTenor = new[] { PeriodHelper.Parse(fraInputRange.IndexTenor) };
fra.fraDiscounting = fraInputRange.FraDiscounting;
PartyReference nabParty = PartyReferenceFactory.Create("NAB");
PartyReference counterParty = PartyReferenceFactory.Create("COUNTERPARTY");
if (bool.Parse(fraInputRange.Sell))
{
fra.sellerPartyReference = nabParty;
fra.buyerPartyReference = counterParty;
}
else
{
fra.sellerPartyReference = counterParty;
fra.buyerPartyReference = nabParty;
}
return(fra);
}
public static Swaption GenerateSwaptionDefiniton(SwapLegParametersRange_Old leg1Parameters,
IBusinessCalendar leg1PaymentCalendar,
SwapLegParametersRange_Old leg2Parameters,
IBusinessCalendar leg2PaymentCalendar,
SwaptionParametersRange swaptionParameters)
{
Swap swap = SwapGenerator.GenerateDefiniton(leg1Parameters, leg2Parameters);
NonNegativeMoney premium = MoneyHelper.GetNonNegativeAmount(swaptionParameters.Premium, swaptionParameters.PremiumCurrency);
AdjustableDate expirationDate = DateTypesHelper.ToAdjustableDate(swaptionParameters.ExpirationDate, swaptionParameters.ExpirationDateBusinessDayAdjustments, swaptionParameters.ExpirationDateCalendar);
AdjustableOrAdjustedDate paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(swaptionParameters.PaymentDate, swaptionParameters.PaymentDateBusinessDayAdjustments, swaptionParameters.PaymentDateCalendar);
TimeSpan earliestExerciseTimeAsTimeSpan = TimeSpan.FromDays(swaptionParameters.EarliestExerciseTime);
DateTime earliestExerciseTime = DateTime.MinValue.Add(earliestExerciseTimeAsTimeSpan);
TimeSpan expirationTimeAsTimeSpan = TimeSpan.FromDays(swaptionParameters.ExpirationTime);
DateTime expirationTime = DateTime.MinValue.Add(expirationTimeAsTimeSpan);
return(SwaptionFactory.Create(swap, premium,
swaptionParameters.PremiumPayer, swaptionParameters.PremiumReceiver,
paymentDate, expirationDate,
earliestExerciseTime, expirationTime, swaptionParameters.AutomaticExcercise));
}
/// <summary>
/// Builds a bullet payment.
/// </summary>
/// <param name="productType"></param>
/// <param name="payerIsBaseParty"></param>
/// <param name="paymentDate"></param>
/// <param name="businessDayCalendar"></param>
/// <param name="businessDayAdjustments"> </param>
/// <param name="currency"></param>
/// <param name="amount"></param>
/// <returns></returns>
public static BulletPayment Parse(string productType, Boolean payerIsBaseParty,
DateTime paymentDate, string businessDayCalendar,
string businessDayAdjustments, string currency, decimal amount)
{
var px = new BulletPayment
{
payment =
new Payment
{
paymentAmount =
MoneyHelper.GetNonNegativeAmount(amount, currency)
},
Items = new object[] { ProductTypeHelper.Create("BulletPayment") },
ItemsElementName = new[] { ItemsChoiceType2.productType }
};
var tempDate = DateTypesHelper.ToAdjustableDate(paymentDate, businessDayAdjustments,
businessDayCalendar);
px.payment.paymentDate = AdjustableOrAdjustedDateHelper.Create(tempDate.unadjustedDate.Value, null, tempDate.dateAdjustments);//TODO
//Setting the items array which contains product type and product is information.
//payment type information
px.payment.paymentType = PaymentTypeHelper.Create("Payment");
//Set the party information
px.payment.payerPartyReference = new PartyReference {
href = "Party2"
};
px.payment.receiverPartyReference = new PartyReference {
href = "Party1"
};
if (payerIsBaseParty)
{
px.payment.payerPartyReference = new PartyReference {
href = "Party1"
};
px.payment.receiverPartyReference = new PartyReference {
href = "Party2"
};
}
return(px);
}
public static Trade CreateSwaptionTrade(SwaptionParametersRange swaptionParametersRange, IBusinessCalendar paymentCalendar, Swap underlyingSwap)
{
var premium = MoneyHelper.GetNonNegativeAmount(swaptionParametersRange.Premium, swaptionParametersRange.PremiumCurrency);
AdjustableDate expirationDate = DateTypesHelper.ToAdjustableDate(swaptionParametersRange.ExpirationDate, swaptionParametersRange.ExpirationDateBusinessDayAdjustments, swaptionParametersRange.ExpirationDateCalendar);
AdjustableOrAdjustedDate paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(swaptionParametersRange.PaymentDate, swaptionParametersRange.PaymentDateBusinessDayAdjustments, swaptionParametersRange.PaymentDateCalendar);
TimeSpan earliestExerciseTimeAsTimeSpan = TimeSpan.FromDays(swaptionParametersRange.EarliestExerciseTime);
DateTime earliestExerciseTime = DateTime.MinValue.Add(earliestExerciseTimeAsTimeSpan);
TimeSpan expirationTimeAsTimeSpan = TimeSpan.FromDays(swaptionParametersRange.ExpirationTime);
DateTime expirationTime = DateTime.MinValue.Add(expirationTimeAsTimeSpan);
var swaption = SwaptionFactory.Create(underlyingSwap, premium, swaptionParametersRange.PremiumPayer, swaptionParametersRange.PremiumReceiver,
paymentDate, expirationDate,
earliestExerciseTime, expirationTime, swaptionParametersRange.AutomaticExcercise);
swaption.Items = new object[] { new ProductType {
Value = ProductTypeSimpleEnum.InterestRateSwaption.ToString()
} };
swaption.ItemsElementName = new[] { ItemsChoiceType2.productType };
var trade = new Trade();
XsdClassesFieldResolver.TradeSetSwaption(trade, swaption);
return(trade);
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceablePrincipalExchange"/> class.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="payerIsBaseParty">A flag determining if the sign on the mamount is relative to the base party.</param>
/// <param name="amount">The amount.</param>
/// <param name="currency">The currency.</param>
/// <param name="adjustedPaymentDate">The adjusted payment date.</param>
/// <param name="paymentCalendar">Type paymentCalendar.</param>
public PriceablePrincipalExchange
(
string id
, bool payerIsBaseParty
, Decimal amount
, string currency
, DateTime adjustedPaymentDate
, IBusinessCalendar paymentCalendar) :
base(id, "DiscountedCashflow", payerIsBaseParty, MoneyHelper.GetAmount(amount, currency), DateTypesHelper.ToAdjustableOrAdjustedDate(adjustedPaymentDate),
PaymentTypeHelper.Create("Certain"), CashflowTypeHelper.Create(CashflowTypeEnum.PrincipalExchange.ToString()), false, paymentCalendar)
{
}
public string CreateValuation(
ILogger logger,
ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
SwaptionParametersRange swaptionParametersRange,
List <StringObjectRangeItem> valuationSet,
ValuationRange valuationRange,
TradeRange tradeRange,
SwapLegParametersRange leg1ParametersRange,
SwapLegParametersRange leg2ParametersRange,
List <InputCashflowRangeItem> leg1DetailedCashflowsListArray,
List <InputCashflowRangeItem> leg2DetailedCashflowsListArray,
List <InputPrincipalExchangeCashflowRangeItem> leg1PrincipalExchangeCashflowListArray,
List <InputPrincipalExchangeCashflowRangeItem> leg2PrincipalExchangeCashflowListArray,
List <AdditionalPaymentRangeItem> leg1AdditionalPaymentListArray,
List <AdditionalPaymentRangeItem> leg2AdditionalPaymentListArray,
List <PartyIdRangeItem> partyIdList, //optional
List <OtherPartyPaymentRangeItem> otherPartyPaymentList, //opt
List <FeePaymentRangeItem> feePaymentList //opt
)
{
var swap = GetPriceAndGeneratedFpMLSwap(logger, cache, nameSpace,
fixingCalendar, paymentCalendar, valuationRange,
tradeRange, leg1ParametersRange, leg2ParametersRange,
leg1DetailedCashflowsListArray, leg2DetailedCashflowsListArray,
leg1PrincipalExchangeCashflowListArray, leg2PrincipalExchangeCashflowListArray,
leg1AdditionalPaymentListArray, leg2AdditionalPaymentListArray).Second;
string baseParty = valuationRange.BaseParty;
List <IRateCurve> uniqueCurves = GetUniqueCurves(logger, cache, nameSpace, leg1ParametersRange, leg2ParametersRange);
Market fpMLMarket = InterestRateProduct.CreateFpMLMarketFromCurves(uniqueCurves);
// TODO: add Trade Id & Trade data into valuation. (Trade.Id & Trade.TradeHeader.TradeDate)
//
// create ValuationReport and add it to in-memory collection.
// Add methods!
AssetValuation assetValuation = InterestRateProduct.CreateAssetValuationFromValuationSet(valuationSet);
NonNegativeMoney premium = MoneyHelper.GetNonNegativeAmount(swaptionParametersRange.Premium, swaptionParametersRange.PremiumCurrency);
AdjustableDate expirationDate = DateTypesHelper.ToAdjustableDate(swaptionParametersRange.ExpirationDate, swaptionParametersRange.ExpirationDateBusinessDayAdjustments, swaptionParametersRange.ExpirationDateCalendar);
AdjustableOrAdjustedDate paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(swaptionParametersRange.PaymentDate, swaptionParametersRange.PaymentDateBusinessDayAdjustments, swaptionParametersRange.PaymentDateCalendar);
TimeSpan earliestExerciseTimeAsTimeSpan = TimeSpan.FromDays(swaptionParametersRange.EarliestExerciseTime);
DateTime earliestExerciseTime = DateTime.MinValue.Add(earliestExerciseTimeAsTimeSpan);
TimeSpan expirationTimeAsTimeSpan = TimeSpan.FromDays(swaptionParametersRange.ExpirationTime);
DateTime expirationTime = DateTime.MinValue.Add(expirationTimeAsTimeSpan);
var swaption = SwaptionFactory.Create(swap, premium, swaptionParametersRange.PremiumPayer, swaptionParametersRange.PremiumReceiver,
paymentDate, expirationDate,
earliestExerciseTime, expirationTime, swaptionParametersRange.AutomaticExcercise);
// overrides the premium created by SwaptionFactort.Create
//
var feeList = new List <Payment>();
if (null != feePaymentList)
{
feeList.AddRange(feePaymentList.Select(feePaymentRangeItem => new Payment
{
paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(feePaymentRangeItem.PaymentDate),
paymentAmount = MoneyHelper.GetNonNegativeAmount(feePaymentRangeItem.Amount),
payerPartyReference = PartyReferenceFactory.Create(feePaymentRangeItem.Payer),
receiverPartyReference = PartyReferenceFactory.Create(feePaymentRangeItem.Receiver)
}));
}
swaption.premium = feeList.ToArray();
string valuationReportAndProductId = tradeRange.Id ?? Guid.NewGuid().ToString();
swaption.id = valuationReportAndProductId;
ValuationReport valuationReport = ValuationReportGenerator.Generate(valuationReportAndProductId, baseParty, valuationReportAndProductId, tradeRange.TradeDate, swaption, fpMLMarket, assetValuation);
cache.SaveObject(valuationReport, valuationReportAndProductId, null);
InterestRateProduct.ReplacePartiesInValuationReport(valuationReport, partyIdList);
InterestRateProduct.AddOtherPartyPayments(valuationReport, otherPartyPaymentList);
return(valuationReportAndProductId);
}
public static Pair <ValuationResultRange, CapFloor> GetPriceAndGeneratedFpML(
ILogger logger, ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
ValuationRange valuationRange, TradeRange tradeRange,
CapFloorLegParametersRange_Old leg1ParametersRange,
List <InputCashflowRangeItem> leg1DetailedCashflowsList,
List <InputPrincipalExchangeCashflowRangeItem> legPrincipalExchangeCashflowListArray,
List <AdditionalPaymentRangeItem> leg1AdditionalPaymentList,
List <FeePaymentRangeItem> feePaymentList
)
{
//Check if the calendars are null. If not build them!
InterestRateStream stream1 = GetCashflowsSchedule(fixingCalendar, paymentCalendar, leg1ParametersRange);//parametric definiton + cashflows schedule
// Update FpML cashflows
//
stream1.cashflows = UpdateCashflowsWithDetailedCashflows(leg1DetailedCashflowsList);
if (null != legPrincipalExchangeCashflowListArray)
{
// create principal exchanges
//
InterestRateSwapPricer.CreatePrincipalExchangesFromListOfRanges(stream1.cashflows, legPrincipalExchangeCashflowListArray);
}
// Add bullet payments...
//
var bulletPaymentList = new List <Payment>();
if (null != leg1AdditionalPaymentList)
{
bulletPaymentList.AddRange(leg1AdditionalPaymentList.Select(bulletPaymentRangeItem => new Payment
{
payerPartyReference = PartyReferenceFactory.Create(leg1ParametersRange.Payer),
receiverPartyReference = PartyReferenceFactory.Create(leg1ParametersRange.Receiver),
paymentAmount = MoneyHelper.GetNonNegativeAmount(bulletPaymentRangeItem.Amount, bulletPaymentRangeItem.Currency),
paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(bulletPaymentRangeItem.PaymentDate)
}));
}
CapFloor capFloor = CapFloorFactory.Create(stream1);
capFloor.additionalPayment = bulletPaymentList.ToArray();
var feeList = new List <Payment>();
if (null != feePaymentList)
{
feeList.AddRange(feePaymentList.Select(feePaymentRangeItem => new Payment
{
paymentDate = DateTypesHelper.ToAdjustableOrAdjustedDate(feePaymentRangeItem.PaymentDate),
paymentAmount = MoneyHelper.GetNonNegativeAmount(feePaymentRangeItem.Amount, feePaymentRangeItem.Currency),
payerPartyReference = PartyReferenceFactory.Create(feePaymentRangeItem.Payer),
receiverPartyReference = PartyReferenceFactory.Create(feePaymentRangeItem.Receiver)
}));
}
capFloor.premium = feeList.ToArray();
// Update FpML cashflows with DF,FV,PV, etc (LegParametersRange needed to access curve functionality)
//
UpdateCashflowsWithAmounts(logger, cache, nameSpace, stream1, leg1ParametersRange, valuationRange);
// Update additional payments
//
var leg1DiscountCurve = CurveLoader.LoadInterestRateCurve(logger, cache, nameSpace, leg1ParametersRange.DiscountCurve);
CapFloorGenerator.UpdatePaymentsAmounts(paymentCalendar, capFloor, leg1ParametersRange, leg1DiscountCurve, valuationRange.ValuationDate);
//~ Update additional payments
string baseParty = valuationRange.BaseParty;
return(new Pair <ValuationResultRange, CapFloor>(CreateValuationRange(capFloor, baseParty), capFloor));
}
