private static List <IRateCurve> GetUniqueCurves(
ILogger logger,
ICoreCache cache,
String nameSpace,
SwapLegParametersRange_Old payLegParametersRange)
{
var uniqueCurves = new List <IRateCurve>();
var curveNames = new[]
{
payLegParametersRange.ForecastCurve,
payLegParametersRange.DiscountCurve
};
foreach (string curveName in curveNames)
{
if (!String.IsNullOrEmpty(curveName) && curveName.ToLower() != "none")
{
var curve = CurveLoader.LoadInterestRateCurve(logger, cache, nameSpace, curveName);
if (!uniqueCurves.Contains(curve))
{
uniqueCurves.Add(curve);
}
}
}
return(uniqueCurves);
}
public void CreateValuationFixedStream()
{
DateTime valuationDate = DateTime.Today;
var irFloaterPricer = new FloaterPricer();
string discountCurveID = BuildAndCacheRateCurve(valuationDate);
//string projectionCurveID = discountCurveID;
SwapLegParametersRange_Old receiveFixedLegParameters = CreateFixedAUD_6MSwapLegParametersRange(CounterParty, _NAB, valuationDate, 0.08m, "ACT/365.FIXED", "AUSY", "FOLLOWING", "AUSY", "NONE", discountCurveID);
ValuationRange valuationRange = CreateValuationRangeForNAB(valuationDate);
List <DetailedCashflowRangeItem> receiveCFRangeItemList = FloaterPricer.GetDetailedCashflowsTestOnly(Engine.Logger, Engine.Cache, Engine.NameSpace, null, null, receiveFixedLegParameters, valuationRange);
var tradeRange = new TradeRange {
Id = "TradeId_12345", TradeDate = valuationDate
};
var leg2PrincipleExchangeCashflowList = new List <PrincipalExchangeCashflowRangeItem>();
var leg2BulletPaymentList = new List <AdditionalPaymentRangeItem>();
List <PartyIdRangeItem> partyList = GetPartyList("NAB", "book", "MCHammer", "counterparty");
List <OtherPartyPaymentRangeItem> otherPartyPaymentRangeItems = GetOtherPartyPaymentList("counterparty", "cost center");
// Get price and swap representation using non-vanilla PRICE function.
//
string valuatonId = irFloaterPricer.CreateValuation(Engine.Logger, Engine.Cache, Engine.NameSpace, null, null,
CreateValuationSetList2(12345.67, -0.321), valuationRange, tradeRange,
receiveFixedLegParameters,
receiveCFRangeItemList,
leg2PrincipleExchangeCashflowList,
leg2BulletPaymentList,
partyList, otherPartyPaymentRangeItems);
var valuationReport = Engine.Cache.LoadObject <ValuationReport>(Engine.NameSpace + "." + valuatonId);
Debug.Print(XmlSerializerHelper.SerializeToString(valuationReport));
}
private static InterestRateStream GetCashflowsSchedule(
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
SwapLegParametersRange_Old legParametersRange)
{
InterestRateStream stream = InterestRateStreamParametricDefinitionGenerator.GenerateStreamDefinition(legParametersRange);
Cashflows cashflows = FixedAndFloatingRateStreamCashflowGenerator.GetCashflows(stream, fixingCalendar, paymentCalendar);
stream.cashflows = cashflows;
return(stream);
}
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));
}
public static void UpdateStreamCashflowsAmounts(SwapLegParametersRange_Old legParameters,
InterestRateStream stream,
ISwapLegEnvironment marketEnvironment,
DateTime valuationDate)
{
IRateCurve forecastCurve = null;
if (!String.IsNullOrEmpty(legParameters.ForecastCurve))
{
forecastCurve = marketEnvironment.GetForecastRateCurve();
}
IRateCurve discountingCurve = marketEnvironment.GetDiscountRateCurve();
FixedAndFloatingRateStreamCashflowGenerator.UpdateCashflowsAmounts(stream, forecastCurve, discountingCurve, valuationDate);
}
public List <DetailedCashflowRangeItem> GetDetailedCashflowsWithNotionalSchedule(
ILogger logger,
ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
SwapLegParametersRange_Old legParametersRange,
List <DateTimeDoubleRangeItem> notionalValueItems,
ValuationRange valuationRange)
{
var tempList = notionalValueItems.Select(item => new Pair <DateTime, decimal>(item.DateTime, Convert.ToDecimal(item.Value))).ToList();
NonNegativeSchedule notionalScheduleFpML = NonNegativeScheduleHelper.Create(tempList);
Currency currency = CurrencyHelper.Parse(legParametersRange.Currency);
NonNegativeAmountSchedule amountSchedule = NonNegativeAmountScheduleHelper.Create(notionalScheduleFpML, currency);
InterestRateStream interestRateStream = GetCashflowsScheduleWithNotionalSchedule(fixingCalendar, paymentCalendar, legParametersRange, amountSchedule);
UpdateCashflowsWithAmounts(logger, cache, nameSpace, interestRateStream, legParametersRange, valuationRange);
var list = new List <DetailedCashflowRangeItem>();
//int periodNumber = 1;
foreach (PaymentCalculationPeriod paymentCalculationPeriod in interestRateStream.cashflows.paymentCalculationPeriod)
{
var detailedCashflowRangeItem = new DetailedCashflowRangeItem();
list.Add(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);
// If floating rate - retrieve the spread.
//
if (legParametersRange.IsFloatingLegType())
{
detailedCashflowRangeItem.Spread = (double)PaymentCalculationPeriodHelper.GetSpread(paymentCalculationPeriod);
}
}
return(list);
}
public static void UpdatePaymentsAmounts(ILogger logger, ICoreCache cache,
String nameSpace, Swap swap,
SwapLegParametersRange_Old leg1Parameters,
SwapLegParametersRange_Old 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)
{
payment.discountFactor = (decimal)discountCurve.GetDiscountFactor(valuationDate, (DateTime)date);
payment.discountFactorSpecified = true;
payment.presentValueAmount = MoneyHelper.Mul(payment.paymentAmount, payment.discountFactor);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="nameSpace"></param>
/// <param name="leg1Parameters"></param>
/// <param name="leg1Calendars"></param>
/// <param name="leg2Parameters"></param>
/// <param name="leg2Calendars"></param>
/// <param name="fixedRateSchedule"></param>
/// <param name="spreadSchedule"></param>
/// <param name="notionalSchedule"></param>
/// <param name="marketEnvironment"></param>
/// <param name="valuationDate"></param>
/// <returns></returns>
public static Swap GenerateDefinitionCashflowsAmounts(ILogger logger, ICoreCache cache,
string nameSpace, SwapLegParametersRange_Old leg1Parameters,
Pair <IBusinessCalendar, IBusinessCalendar> leg1Calendars,
SwapLegParametersRange_Old leg2Parameters,
Pair <IBusinessCalendar, IBusinessCalendar> leg2Calendars,
Schedule fixedRateSchedule,
Schedule spreadSchedule,
NonNegativeAmountSchedule notionalSchedule,
ISwapLegEnvironment marketEnvironment,
DateTime valuationDate)
{
var swap = GenerateDefinitionCashflows(logger, cache, nameSpace, leg1Parameters, leg1Calendars, leg2Parameters, leg2Calendars, fixedRateSchedule, spreadSchedule, notionalSchedule);
InterestRateStream stream1 = swap.swapStream[0];
InterestRateStream stream2 = swap.swapStream[1];
UpdateStreamCashflowsAmounts(leg1Parameters, stream1, marketEnvironment, valuationDate);
UpdateStreamCashflowsAmounts(leg2Parameters, stream2, marketEnvironment, valuationDate);
return(swap);
}
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));
}
internal static ValuationResultRange GetPriceOld(
ILogger logger,
ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
SwapLegParametersRange_Old leg1ParametersRange,
SwapLegParametersRange_Old leg2ParametersRange,
ValuationRange valuationRange)
{
string baseParty = valuationRange.BaseParty;
InterestRateStream stream1 = GetCashflowsSchedule(fixingCalendar, paymentCalendar, leg1ParametersRange); //pay leg
InterestRateStream stream2 = GetCashflowsSchedule(fixingCalendar, paymentCalendar, leg2ParametersRange); //receive leg
var swap = SwapFactory.Create(stream1, stream2);
UpdateCashflowsWithAmounts(logger, cache, nameSpace, stream1, leg1ParametersRange, valuationRange);
UpdateCashflowsWithAmounts(logger, cache, nameSpace, stream2, leg2ParametersRange, valuationRange);
ValuationResultRange resultRange = CreateValuationRange(swap, baseParty);
return(resultRange);
}
public List <PrincipalExchangeCashflowRangeItem> GetPrincipalExchanges(
ILogger logger,
ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
SwapLegParametersRange_Old legParametersRange,
List <DateTimeDoubleRangeItem> notionalValueItems,
ValuationRange valuationRange)
{
InterestRateStream interestRateStream;
if (notionalValueItems.Count > 0)
{
var tempList = notionalValueItems.Select(item => new Pair <DateTime, decimal>(item.DateTime, Convert.ToDecimal(item.Value))).ToList();
NonNegativeSchedule notionalScheduleFpML = NonNegativeScheduleHelper.Create(tempList);
Currency currency = CurrencyHelper.Parse(legParametersRange.Currency);
NonNegativeAmountSchedule amountSchedule = NonNegativeAmountScheduleHelper.Create(notionalScheduleFpML, currency);
interestRateStream = GetCashflowsScheduleWithNotionalSchedule(fixingCalendar, paymentCalendar, legParametersRange, amountSchedule);
}
else
{
interestRateStream = GetCashflowsSchedule(fixingCalendar, paymentCalendar, legParametersRange);
}
UpdateCashflowsWithAmounts(logger, cache, nameSpace, interestRateStream, legParametersRange, valuationRange);
var list = new List <PrincipalExchangeCashflowRangeItem>();
//int periodNumber = 0;
foreach (PrincipalExchange principleExchange in interestRateStream.cashflows.principalExchange)
{
var principalExchangeCashflowRangeItem = new PrincipalExchangeCashflowRangeItem();
list.Add(principalExchangeCashflowRangeItem);
principalExchangeCashflowRangeItem.PaymentDate = principleExchange.adjustedPrincipalExchangeDate;
principalExchangeCashflowRangeItem.Amount = (double)principleExchange.principalExchangeAmount;
//principalExchangeCashflowRangeItem.PresentValueAmount = MoneyHelper.ToDouble(principleExchange.presentValuePrincipalExchangeAmount);
//principalExchangeCashflowRangeItem.DiscountFactor = (double)principleExchange.discountFactor;
}
return(list);
}
public static List <DetailedCashflowRangeItem> GetDetailedCashflowsTestOnly(
ILogger logger,
ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
SwapLegParametersRange_Old legParametersRange,
ValuationRange valuationRange)
{
InterestRateStream interestRateStream = GetCashflowsSchedule(fixingCalendar, paymentCalendar, legParametersRange);
UpdateCashflowsWithAmounts(logger, cache, nameSpace, interestRateStream, legParametersRange, valuationRange);
var list = new List <DetailedCashflowRangeItem>();
foreach (PaymentCalculationPeriod paymentCalculationPeriod in interestRateStream.cashflows.paymentCalculationPeriod)
{
var detailedCashflowRangeItem = new DetailedCashflowRangeItem();
list.Add(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);
// If floating rate - retrieve a spread.
//
if (legParametersRange.IsFloatingLegType())
{
detailedCashflowRangeItem.Spread = (double)PaymentCalculationPeriodHelper.GetSpread(paymentCalculationPeriod);
}
}
return(list);
}
public string CreateValuation(
ILogger logger,
ICoreCache cache,
String nameSpace,
IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar,
List <StringObjectRangeItem> valuationSet,
ValuationRange valuationRange,
TradeRange tradeRange,
SwapLegParametersRange_Old leg1ParametersRange,
List <DetailedCashflowRangeItem> leg1DetailedCashflowsListArray,
List <PrincipalExchangeCashflowRangeItem> leg1PrincipalExchangeCashflowListArray,
List <AdditionalPaymentRangeItem> leg1AdditionalPaymentListArray,
List <PartyIdRangeItem> partyIdList,//optional
List <OtherPartyPaymentRangeItem> otherPartyPaymentList
)
{
Swap floater = GetPriceAndGeneratedFpMLSwap(logger, cache, nameSpace, fixingCalendar, paymentCalendar, valuationRange, tradeRange, leg1ParametersRange, leg1DetailedCashflowsListArray, leg1PrincipalExchangeCashflowListArray, leg1AdditionalPaymentListArray).Second;
string baseParty = valuationRange.BaseParty;
string valuationReportAndProductId = tradeRange.Id ?? Guid.NewGuid().ToString();
floater.id = valuationReportAndProductId;
var uniqueCurves = GetUniqueCurves(logger, cache, nameSpace, leg1ParametersRange);
Market fpMLMarket = InterestRateProduct.CreateFpMLMarketFromCurves(uniqueCurves);
var valuation = new Valuations.Valuation();
// TODO: add Trade Id & Trade data into valuation. (Trade.Id & Trade.TradeHeader.TradeDate)
//
AssetValuation assetValuation = InterestRateProduct.CreateAssetValuationFromValuationSet(valuationSet);
valuation.CreateSwapValuationReport(cache, nameSpace, valuationReportAndProductId, baseParty, tradeRange.Id, tradeRange.TradeDate, floater, fpMLMarket, assetValuation);
ValuationReport valuationReport = valuation.Get(cache, nameSpace, valuationReportAndProductId);
InterestRateProduct.ReplacePartiesInValuationReport(valuationReport, partyIdList);
InterestRateProduct.AddOtherPartyPayments(valuationReport, otherPartyPaymentList);
return(valuationReportAndProductId);
}
private static void UpdateCashflowsWithAmounts(
ILogger logger,
ICoreCache cache,
String nameSpace,
InterestRateStream stream,
SwapLegParametersRange_Old legParametersRange,
ValuationRange valuationRange)
{
// Get a forecast curve
//
IRateCurve forecastCurve = null;
if (!String.IsNullOrEmpty(legParametersRange.ForecastCurve) && legParametersRange.ForecastCurve.ToLower() != "none")
{
forecastCurve = CurveLoader.LoadInterestRateCurve(logger, cache, nameSpace, legParametersRange.ForecastCurve);
}
// Get a discount curve
//
var discountCurve = CurveLoader.LoadInterestRateCurve(logger, cache, nameSpace, legParametersRange.DiscountCurve);
// Update cashflows & principal exchanges
//
FixedAndFloatingRateStreamCashflowGenerator.UpdateCashflowsAmounts(stream, forecastCurve, discountCurve, valuationRange.ValuationDate);
}
public void CreateSwaptionValuation()
{
DateTime valuationDate = DateTime.Today;
SwaptionPricer irSwaptionPricer = new InterestRateSwaptionPricer();
string discountCurveID = BuildAndCacheRateCurve(valuationDate); //RateCurveExcelInterfaceTests.ExcelInterface_CreateAUDCurveFromDepostSwapsFuturesFras_WithDates(valuationDate, valuationDate);
string projectionCurveID = discountCurveID;
SwapLegParametersRange_Old payFixed = CreateFixedAUD_6MSwapLegParametersRange(_NAB, CounterParty, valuationDate, 0.065m, "ACT/365.FIXED", "AUSY", "FOLLOWING", "AUSY", "NONE", discountCurveID);
SwapLegParametersRange_Old receiveFloat = CreateFloatingAUD_6MSwapLegParametersRange(CounterParty, _NAB, valuationDate, 0, "ACT/365.FIXED", "AUSY", "FOLLOWING", "AUSY", "NONE", discountCurveID, projectionCurveID);
ValuationRange valuationRange = CreateValuationRangeForNAB(valuationDate);
var payCFRangeItemList = InterestRateSwapPricer.GetDetailedCashflowsTestOnly(Engine.Logger, Engine.Cache, Engine.NameSpace, payFixed, valuationRange);
payCFRangeItemList[0].CouponType = "fixed"; // that should test case insensitive nature of coupons
payCFRangeItemList[1].CouponType = "Fixed"; //
var receiveCFRangeItemList = InterestRateSwapPricer.GetDetailedCashflowsTestOnly(Engine.Logger, Engine.Cache, Engine.NameSpace, receiveFloat, valuationRange);
receiveCFRangeItemList[0].CouponType = "float"; // that should test case insensitive nature of coupons
receiveCFRangeItemList[1].CouponType = "Float"; //
var tradeRange = new TradeRange {
Id = "TradeId_12345", TradeDate = valuationDate
};
var leg1PrincipalExchangeCashflowList = new List <InputPrincipalExchangeCashflowRangeItem>();
var leg2PrincipalExchangeCashflowList = new List <InputPrincipalExchangeCashflowRangeItem>();
var leg1BulletPaymentList = new List <AdditionalPaymentRangeItem>();
var leg2BulletPaymentList = new List <AdditionalPaymentRangeItem>();
var swaptionParametersRange = new SwaptionParametersRange
{
Premium = 456789.12m,
PremiumCurrency = "AUD",
PremiumPayer = CounterParty,
PremiumReceiver = _NAB,
ExpirationDate = valuationDate.AddDays(10),
ExpirationDateCalendar = "AUSY-GBLO",
ExpirationDateBusinessDayAdjustments = "FOLLOWING",
PaymentDate = valuationDate.AddDays(20),
PaymentDateCalendar = "USNY-GBLO",
PaymentDateBusinessDayAdjustments = "MODFOLLOWING",
EarliestExerciseTime = new TimeSpan(10, 0, 0).TotalDays,
ExpirationTime = new TimeSpan(11, 0, 0).TotalDays,
AutomaticExcercise = false
};
List <PartyIdRangeItem> partyList = GetPartyList("NAB", "book", "MCHammer", "counterparty");
List <OtherPartyPaymentRangeItem> otherPartyPaymentRangeItems = GetOtherPartyPaymentList("counterparty", "cost center");
List <FeePaymentRangeItem> feePaymentRangeItems = GetFeeList("counterparty", "book");
// Get price and swap representation using non-vanilla PRICE function.
//
string valuatonId = irSwaptionPricer.CreateValuation(Engine.Logger, Engine.Cache, Engine.NameSpace, null, null,
swaptionParametersRange,
CreateValuationSetList2(12345.67, -0.321), valuationRange, tradeRange,
payFixed, receiveFloat,
payCFRangeItemList, receiveCFRangeItemList,
leg1PrincipalExchangeCashflowList, leg2PrincipalExchangeCashflowList,
leg1BulletPaymentList, leg2BulletPaymentList,
partyList, otherPartyPaymentRangeItems,
feePaymentRangeItems);
var valuationReport = Engine.Cache.LoadObject <ValuationReport>(Engine.NameSpace + "." + valuatonId);
Debug.Print(XmlSerializerHelper.SerializeToString(valuationReport));
}
public Swaption GenerateSwaptionParametricWithCashflows()
{
var payLeg = new SwapLegParametersRange_Old
{
AdjustedType = AdjustedType.Unadjusted,
EffectiveDate = new DateTime(1994, 12, 14),
MaturityDate = new DateTime(1999, 12, 14),
FirstRegularPeriodStartDate = new DateTime(1995, 6, 14),
RollConvention = "14",
InitialStubType = StubPeriodTypeEnum.ShortInitial.ToString(),
FinalStubType = StubPeriodTypeEnum.ShortFinal.ToString(),
NotionalAmount = 1000000,
LegType = LegType.Fixed,
Currency = "AUD",
CouponOrLastResetRate = 0.08m,
PaymentFrequency = "6M",
DayCount = "Actual360",
PaymentCalendar = "AUSY",
PaymentBusinessDayAdjustments = "FOLLOWING",
FixingCalendar = "AUSY-GBLO",
FixingBusinessDayAdjustments = "MODFOLLOWING",
DiscountCurve = "AUD-LIBOR",
DiscountingType = "Standard"
};
var receiveLeg = new SwapLegParametersRange_Old
{
AdjustedType = AdjustedType.Unadjusted,
EffectiveDate = new DateTime(1994, 12, 14),
MaturityDate = new DateTime(1999, 12, 14),
FirstRegularPeriodStartDate = new DateTime(1995, 6, 14),
RollConvention = "14",
InitialStubType = StubPeriodTypeEnum.ShortInitial.ToString(),
FinalStubType = StubPeriodTypeEnum.ShortFinal.ToString(),
NotionalAmount = 1000000,
LegType = LegType.Floating,
Currency = "AUD",
FloatingRateSpread = 0,
PaymentFrequency = "6M",
DayCount = "Actual360",
PaymentCalendar = "AUSY",
PaymentBusinessDayAdjustments = "FOLLOWING",
FixingCalendar = "AUSY-GBLO",
FixingBusinessDayAdjustments = "MODFOLLOWING",
DiscountCurve = "AUD-LIBOR",
ForecastCurve = "AUD-LIBOR",
DiscountingType = "Standard"
};
var marketEnvironment = CreateInterestRateStreamTestEnvironment(new DateTime(1994, 12, 14));
var valuationDT = new DateTime(1994, 12, 20);
Swap swap = SwapGenerator.GenerateDefinitionCashflowsAmounts(Engine.Logger, Engine.Cache, Engine.NameSpace, payLeg, null, receiveLeg, null, null, null, null, marketEnvironment, valuationDT);
Assert.AreEqual(swap.swapStream.Length, 2);
Assert.IsNotNull(swap.swapStream[0].cashflows);
Assert.IsNotNull(swap.swapStream[1].cashflows);
var swaption = new Swaption {
swap = swap
};
return(swaption);
}
