/// <summary> /// Gets and sets the required pricing structures to value this leg. /// </summary> public List <String> GetRequiredPricingStructures() { var result = new List <String>(); if (calculationPeriodAmount.Item is Calculation amount) { var currency = XsdClassesFieldResolver.CalculationGetNotionalSchedule(amount); if (currency?.notionalStepSchedule != null) { var discountCurve = CurveNameHelpers.GetDiscountCurveName(currency.notionalStepSchedule.currency, true); result.Add(discountCurve); } if (amount.Items[0] is FloatingRateCalculation floatingRateCalculation) { result.Add(CurveNameHelpers.GetForecastCurveName(floatingRateCalculation.floatingRateIndex, floatingRateCalculation.indexTenor)); } } //TODO if (stubCalculationPeriodAmount != null) { if (stubCalculationPeriodAmount.initialStub?.Items != null) { result.AddRange(from value in stubCalculationPeriodAmount.initialStub.Items where value is Money select CurveNameHelpers.GetDiscountCurveName(((Money)value).currency, true)); } if (stubCalculationPeriodAmount.finalStub?.Items != null) { result.AddRange(from value in stubCalculationPeriodAmount.finalStub.Items where value is Money select CurveNameHelpers.GetDiscountCurveName(((Money)value).currency, true)); } } return(result); }
internal static void AddOtherPartyPayments(ValuationReport valuationReport, List <OtherPartyPaymentRangeItem> otherPartyPaymentList) { var otherPartyPayments = new List <Payment>(); // other party payments // if (null != otherPartyPaymentList) { foreach (OtherPartyPaymentRangeItem item in otherPartyPaymentList) { var otherPartyPayment = new Payment { payerPartyReference = PartyReferenceFactory.Create(item.Payer), receiverPartyReference = PartyReferenceFactory.Create(item.Receiver), paymentAmount = MoneyHelper.GetNonNegativeAmount(item.Amount), paymentDate = AdjustableOrAdjustedDateHelper.CreateAdjustedDate(item.PaymentDate), paymentType = PaymentTypeHelper.Create(item.PaymentType) }; otherPartyPayments.Add(otherPartyPayment); } } TradeValuationItem valuationItem = valuationReport.tradeValuationItem[0]; Trade[] tradeArray = XsdClassesFieldResolver.TradeValuationItemGetTradeArray(valuationItem); Trade trade = tradeArray[0]; trade.otherPartyPayment = otherPartyPayments.ToArray(); }
/// <summary> /// </summary> /// <param name="discountCurve"></param> /// <param name="tenor"></param> /// <param name="baseDate"></param> /// <param name="interpolatedCurve"></param> /// <param name="paymentCalendar"></param> /// <param name="dayCounter"></param> /// <returns></returns> /// <exception cref="System.Exception"></exception> public static TermCurve ToForwardCurve(TermCurve discountCurve, Period tenor, DateTime baseDate, InterpolatedCurve interpolatedCurve, IBusinessCalendar paymentCalendar, IDayCounter dayCounter) { TermCurve result = TermCurve.Create(new List <TermPoint>()); var length = discountCurve.point.Length; var offset = new Offset { dayType = DayTypeEnum.Calendar, dayTypeSpecified = true, period = tenor.period, periodMultiplier = tenor.periodMultiplier, periodSpecified = true }; if (paymentCalendar == null) { return(result); } for (int i = 0; i < length - 1; i++) //This will only go to the penultimate point. Extrapolation required for more. { var pointStart = discountCurve.point[i]; DateTime startDate = XsdClassesFieldResolver.TimeDimensionGetDate(pointStart.term); var endDate = paymentCalendar.Advance(startDate, offset, BusinessDayConventionEnum.FOLLOWING); var endPoint = new DateTimePoint1D(baseDate, endDate); var endDF = interpolatedCurve.Value(endPoint); double time = dayCounter.YearFraction(startDate, endDate); var forwardRateDouble = RateAnalytics.DiscountFactorsToForwardRate((double)pointStart.mid, endDF, time); TermPoint forwardPoint = TermPointFactory.Create(Convert.ToDecimal(forwardRateDouble), startDate); forwardPoint.id = tenor.id; result.Add(forwardPoint); } return(result); }
public static void SetFloorRateSchedule(InterestRateStream stream, Schedule floorRateSchedule, bool isReceiverBuyer) { Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(stream.calculationPeriodAmount); FloatingRateCalculation floatingRateCalculation = XsdClassesFieldResolver.CalculationGetFloatingRateCalculation(calculation); var schedule = new StrikeSchedule { initialValue = floorRateSchedule.initialValue, step = floorRateSchedule.step }; floatingRateCalculation.floorRateSchedule = new[] { schedule }; if (isReceiverBuyer) { floatingRateCalculation.floorRateSchedule[0].buyer = new IdentifiedPayerReceiver { Value = PayerReceiverEnum.Receiver }; floatingRateCalculation.floorRateSchedule[0].seller = new IdentifiedPayerReceiver { Value = PayerReceiverEnum.Payer }; } else { floatingRateCalculation.floorRateSchedule[0].buyer = new IdentifiedPayerReceiver { Value = PayerReceiverEnum.Payer }; floatingRateCalculation.floorRateSchedule[0].seller = new IdentifiedPayerReceiver { Value = PayerReceiverEnum.Receiver }; } }
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 definition... // 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(); }
/// <summary> /// Updates forecastRate, forecastPaymentAmount, discountFactor and presentValueAmount of each paymentCalculation period. /// </summary> /// <param name="interestRateStream">The interest rate stream.</param> /// <param name="forecastCurve">The forecast curve.</param> /// <param name="discountCurve">The discount curve.</param> /// <param name="valuationDate">The valuation date.</param> public static void UpdateCashflowsAmounts(InterestRateStream interestRateStream, IRateCurve forecastCurve, IRateCurve discountCurve, DateTime valuationDate) { //FixAfterManualUpdate(interestRateStream);//should it be removed, since it might produce subtle errors which will be effectively hidden. Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(interestRateStream.calculationPeriodAmount); UpdateNumberOfDaysAndYearFraction(new List <PaymentCalculationPeriod>(interestRateStream.cashflows.paymentCalculationPeriod), calculation); FloatingRateCalculation floatingRateCalculation = XsdClassesFieldResolver.CalculationHasFloatingRateCalculation(calculation) ? XsdClassesFieldResolver.CalculationGetFloatingRateCalculation(calculation) : null; // calculate forecast payment amount for each payment calculation period // foreach (PaymentCalculationPeriod period in interestRateStream.cashflows.paymentCalculationPeriod) { CalculateForecastPaymentAmount(calculation, floatingRateCalculation, period, forecastCurve, discountCurve, valuationDate); } // principle exchanges // if (interestRateStream.cashflows.principalExchange != null) { foreach (PrincipalExchange principalExchange in interestRateStream.cashflows.principalExchange) { CalculateForecastPaymentAmount(principalExchange, discountCurve, valuationDate); } } }
public static ValuationReport Generate(string valuationId, string baseParty, Fra fra, Market market, AssetValuation assetValuation) { var valuationReport = new ValuationReport { header = new NotificationMessageHeader { messageId = new MessageId { Value = valuationId } }, market = market }; // Associate id with the valuation // var tradeValuationItem = new TradeValuationItem(); valuationReport.tradeValuationItem = new[] { tradeValuationItem }; var trade = new Trade(); XsdClassesFieldResolver.TradeSetFra(trade, fra); tradeValuationItem.Items = new object[] { trade }; tradeValuationItem.valuationSet = new ValuationSet { baseParty = PartyReferenceFactory.Create(baseParty), assetValuation = new[] { assetValuation } }; return(valuationReport); }
// need a based date? // ///<summary> ///</summary> ///<param name="discountCurve"></param> ///<param name="baseDate"></param> ///<param name="frequency"></param> ///<param name="dayCounter"></param> ///<returns></returns> ///<exception cref="System.Exception"></exception> public static TermCurve ToZeroCurve(TermCurve discountCurve, DateTime baseDate, CompoundingFrequencyEnum frequency, IDayCounter dayCounter) { TermCurve result = TermCurve.Create(new List <TermPoint>()); foreach (TermPoint point in discountCurve.point) { DateTime pointDate = XsdClassesFieldResolver.TimeDimensionGetDate(point.term); double zeroRateDouble; if (baseDate != pointDate) { double time = dayCounter.YearFraction(baseDate, pointDate); zeroRateDouble = RateAnalytics.DiscountFactorToZeroRate((double)point.mid, time, frequency); } else { // set after the loop zeroRateDouble = 0; } TermPoint zeroPoint = TermPointFactory.Create(Convert.ToDecimal(zeroRateDouble), pointDate); zeroPoint.id = point.id; result.Add(zeroPoint); } if (result.point[0].mid == 0) { result.point[0].mid = result.point[1].mid; } return(result); }
//public static void SetNotionalSchedule(InterestRateStream stream, AmountSchedule amountSchedule) //{ // Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmount_GetCalculation(stream.calculationPeriodAmount); // var notional = new Notional { notionalStepSchedule = amountSchedule }; // XsdClassesFieldResolver.Calculation_SetNotionalSchedule(calculation, notional); //} public static void SetNotionalSchedule(InterestRateStream stream, NonNegativeAmountSchedule amountSchedule) { Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(stream.calculationPeriodAmount); var notional = new Notional { notionalStepSchedule = amountSchedule }; XsdClassesFieldResolver.CalculationSetNotionalSchedule(calculation, notional); }
private static void UpdateStubCalculationPeriodData(InterestRateStream interestRateStream, CalculationPeriod stubCalculationPeriod, StubValue stubValue, Notional notinalSchedule) { StubCalculationPeriodAmountHelper.UpdateStubCalculationPeriod(interestRateStream, stubCalculationPeriod, stubValue); decimal notional = NotionalHelper.GetNotionalValue(notinalSchedule, stubCalculationPeriod.adjustedStartDate); // Notional amount // XsdClassesFieldResolver.CalculationPeriodSetNotionalAmount(stubCalculationPeriod, notional); }
//private static void ProcessStubs(InterestRateStream stream, SwapLegParametersRange_Old swapTermParametersRange, IBusinessCalendar paymentCalendar) //{ // //bool isFullFirstCoupon = swapTermParametersRange.FirstCouponType == FirstCouponType.Full?true:false; // DateTime adjustedEffectiveDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, XsdClassesFieldResolver.CalculationPeriodDates_GetEffectiveDate(stream.calculationPeriodDates)); // DateTime adjustedTerminationDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, XsdClassesFieldResolver.CalculationPeriodDates_GetTerminationDate(stream.calculationPeriodDates)); // StubPeriodTypeEnum? initialStubType = null; // if (!string.IsNullOrEmpty(swapTermParametersRange.InitialStubType)) // { // initialStubType = EnumHelper.Parse<StubPeriodTypeEnum>(swapTermParametersRange.InitialStubType); // } // StubPeriodTypeEnum? finalStubType = null; // if (!string.IsNullOrEmpty(swapTermParametersRange.FinalStubType)) // { // finalStubType = EnumHelper.Parse<StubPeriodTypeEnum>(swapTermParametersRange.FinalStubType); // } // //Only calculate a stub if required i.e. // //If a FirsteRegularPeriod is specified -> Roll forward // //If a lastRegularePeriod is specified --> Roll Backwards // //If intialstub is not null // //if finalStubType is not null // //Otherwise, check if the maturity - effective date is modulo the frequency. // //If yes, there is no stub. // var periods = CalculationPeriodGenerator.GenerateAdjustedCalculationPeriods(adjustedEffectiveDate, // adjustedTerminationDate, // swapTermParametersRange.FirstRegularPeriodStartDate, // stream.calculationPeriodDates.calculationPeriodFrequency, // stream.calculationPeriodDates.calculationPeriodDatesAdjustments, // initialStubType, // finalStubType, // paymentCalendar); // //var periods = CalculationPeriodGenerator.GenerateAdjustedCalculationPeriods(adjustedEffectiveDate, // // adjustedTerminationDate, // // stream.calculationPeriodDates.firstRegularPeriodStartDate, // // stream.calculationPeriodDates.lastRegularPeriodEndDate, // // stream.calculationPeriodDates.calculationPeriodFrequency, // // stream.calculationPeriodDates.calculationPeriodDatesAdjustments, // // paymentCalendar); // if (!stream.calculationPeriodDates.firstRegularPeriodStartDateSpecified && periods.HasInitialStub) // { // stream.calculationPeriodDates.firstRegularPeriodStartDate = periods.FirstRegularPeriodUnadjustedStartDate; // stream.calculationPeriodDates.firstRegularPeriodStartDateSpecified = true; // } // if (!stream.calculationPeriodDates.lastRegularPeriodEndDateSpecified && periods.HasFinalStub) // { // stream.calculationPeriodDates.lastRegularPeriodEndDate = periods.LastRegularPeriodUnadjustedEndDate; // stream.calculationPeriodDates.lastRegularPeriodEndDateSpecified = true; // } //} private static void SetNotional(Calculation calculation, decimal amount, string currencyAsString) { Money notionalAsMoney = MoneyHelper.GetAmount(amount, currencyAsString); Notional notionalSchedule = NotionalFactory.Create(notionalAsMoney); XsdClassesFieldResolver.CalculationSetNotionalSchedule(calculation, notionalSchedule); }
public string CacheFraTrade(ILogger logger, ICoreCache cache, string fraId, FraInputRange fraInputRange) { var fra = ProductFactory.GetFpMLFra(fraInputRange); var trade = new Trade(); XsdClassesFieldResolver.TradeSetFra(trade, fra); cache.SaveObject(trade, fraId, null); return(fraId); }
private static void SetFirstRegularPeriodStartDate(InterestRateStream stream, DateTime firstRegularPeriodStartDate) { if (firstRegularPeriodStartDate != new DateTime()) { XsdClassesFieldResolver.CalculationPeriodDatesSetFirstRegularPeriodStartDate( stream.calculationPeriodDates, firstRegularPeriodStartDate); } }
private static void SetLastRegularPeriodEndDate(InterestRateStream stream, DateTime lastRegularPeriodEndDate) { if (lastRegularPeriodEndDate != new DateTime()) { XsdClassesFieldResolver.CalculationPeriodDatesSetLastRegularPeriodEndDate( stream.calculationPeriodDates, lastRegularPeriodEndDate); } }
public static ValuationReport Generate(string valuationId, string baseParty, string tradeId, DateTime tradeDate, Swap swap, Market market, AssetValuation assetValuation) { var valuationReport = new ValuationReport { header = new NotificationMessageHeader { messageId = new MessageId { Value = valuationId } }, market = market }; // Associate id with the valuation // var tradeValuationItem = new TradeValuationItem(); valuationReport.tradeValuationItem = new[] { tradeValuationItem }; //Party nabParty = PartyFactory.Create("Party1"); //Party counterParty = PartyFactory.Create(_counterpartyName); // // valuationReport.party = new Party[] { nabParty, counterParty }; // PartyOrAccountReference nabPartyReference = PartyOrAccountReferenceFactory.Create(nabParty.id); // PartyOrAccountReference counterPartyReference = PartyOrAccountReferenceFactory.Create(counterParty.id); // // NAB is the payer of pay paystream and receiver of receive stream // // // SwapHelper.GetPayerStream(swap).payerPartyReference = nabPartyReference; // SwapHelper.GetReceiverStream(swap).receiverPartyReference = nabPartyReference; // // // CounterParty is the receiver of paystream and payer of receivestream // // // SwapHelper.GetPayStream(swap).receiverPartyReference = counterPartyReference; // SwapHelper.GetReceiveStream(swap).payerPartyReference = counterPartyReference; var trade = new Trade(); // Generate trade header // TradeHeader tradeHeader = CreateTradeHeader(tradeDate, tradeId); trade.tradeHeader = tradeHeader; XsdClassesFieldResolver.TradeSetSwap(trade, swap); tradeValuationItem.Items = new object[] { trade }; tradeValuationItem.valuationSet = new ValuationSet { baseParty = PartyReferenceFactory.Create(baseParty), assetValuation = new[] { assetValuation } }; return(valuationReport); }
private static void SetFirstPeriodStartDate(InterestRateStream stream, AdjustableDate firstPeriodStartDate) { if (firstPeriodStartDate != null) { XsdClassesFieldResolver.CalculationPeriodDatesSetFirstPeriodStartDate( stream.calculationPeriodDates, firstPeriodStartDate); } }
/// <summary> /// Gets the unadjusted calculation date schedule. /// </summary> /// <param name="calculationPeriodDates">The calculation period dates.</param> /// <returns></returns> public List <CalculationPeriod> GetUnadjustedCalculationDateSchedule(CalculationPeriodDates calculationPeriodDates) { CalculationPeriodDates = calculationPeriodDates; PeriodInterval = CalculationPeriodHelper.CalculationPeriodFrequencyToInterval(calculationPeriodDates.calculationPeriodFrequency); _effectiveDate = XsdClassesFieldResolver.CalculationPeriodDatesGetEffectiveDate(calculationPeriodDates).unadjustedDate.Value; _termDate = XsdClassesFieldResolver.CalculationPeriodDatesGetTerminationDate(calculationPeriodDates).unadjustedDate.Value; RollConvention = calculationPeriodDates.calculationPeriodFrequency.rollConvention; _unadjustedDateScheduleList = CalculationPeriodHelper.GenerateUnadjustedCalculationDates(_effectiveDate, _termDate, calculationPeriodDates); return(_unadjustedDateScheduleList); }
public static void SetSpreadSchedule(InterestRateStream stream, Schedule spreadSchedule) { Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(stream.calculationPeriodAmount); FloatingRateCalculation floatingRateCalculation = XsdClassesFieldResolver.CalculationGetFloatingRateCalculation(calculation); var schedule = new SpreadSchedule { initialValue = spreadSchedule.initialValue, step = spreadSchedule.step }; floatingRateCalculation.spreadSchedule = new[] { schedule }; }
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); }
///<summary> /// Gets all the Forecast curve name. ///</summary> ///<returns></returns> public static string GetRateVolatilityMatrixName(Swap swap) { AdjustableDate adjustableEffectiveDate = XsdClassesFieldResolver.CalculationPeriodDatesGetEffectiveDate(swap.swapStream[0].calculationPeriodDates); AdjustableDate adjustableTerminationDate = XsdClassesFieldResolver.CalculationPeriodDatesGetTerminationDate(swap.swapStream[0].calculationPeriodDates); var years = adjustableTerminationDate.unadjustedDate.Value.Year - adjustableEffectiveDate.unadjustedDate.Value.Year; var calculation = (Calculation)swap.swapStream[0].calculationPeriodAmount.Item; var notional = XsdClassesFieldResolver.CalculationGetNotionalSchedule(calculation); var currency = notional.notionalStepSchedule.currency.Value; return(PricingStructureTypeEnum.RateVolatilityMatrix + "." + currency + "-IRSwap-" + years + "Y"); }
/// <summary> /// /// </summary> /// <returns></returns> public List <string> GetRequiredCurrencies() { var result = new List <string>(); var item = XsdClassesFieldResolver.CalculationGetNotionalSchedule((Calculation)calculationPeriodAmount.Item); if (item?.notionalStepSchedule?.currency != null) { result.Add(item.notionalStepSchedule.currency.Value); } return(result); }
/// <summary> /// Initializes a new instance of the <see cref="RateBasisCurve"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace</param> /// <param name="referenceCurveData">The market data. This must contain both the underlying base curve and the spread curve. /// Otherwise the RateBasisInterpolator can not instantiate.</param> /// <param name="spreadCurveData">The spread Curve Data</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="rollCalendar">The rollCalendar.</param> public RateBasisCurve(ILogger logger, ICoreCache cache, String nameSpace, Triplet <PricingStructure, PricingStructureValuation, NamedValueSet> referenceCurveData, Triplet <PricingStructure, PricingStructureValuation, NamedValueSet> spreadCurveData, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar) : base(spreadCurveData.Third, GenerateHolder(logger, cache, nameSpace, spreadCurveData.Third)) { PricingStructureData = new PricingStructureData(CurveType.Child, AssetClass.Rates, spreadCurveData.Third); //Set the identifier. var nvs = spreadCurveData.Third; var pricingStructureId = GetRateCurveId(); var refCurveId = PropertyHelper.ExtractReferenceCurveUniqueId(nvs); ReferenceCurveId = refCurveId != null ? new Identifier(refCurveId) : ReferenceCurveId = null; if (pricingStructureId.PricingStructureType != PricingStructureTypeEnum.RateBasisCurve) { return; } //Set the reference curve var baseCurveFpml = new Pair <PricingStructure, PricingStructureValuation>(referenceCurveData.First, referenceCurveData.Second); var baseCurveProps = referenceCurveData.Third; BaseCurve = (IRateCurve)PricingStructureFactory.Create(logger, cache, nameSpace, fixingCalendar, rollCalendar, baseCurveFpml, baseCurveProps); //Get the spread Data var spreadCurveFpml = new Pair <PricingStructure, PricingStructureValuation>(spreadCurveData.First, spreadCurveData.Second); //Override properties. //var optimize = PropertyHelper.ExtractOptimizeBuildFlag(properties); var bootstrap = PropertyHelper.ExtractBootStrapOverrideFlag(nvs); var tempFpml = (YieldCurveValuation)spreadCurveFpml.Second; var spreadAssets = tempFpml.inputs; //This is to catch it when there are no discount factor points. var discountsAbsent = tempFpml.discountFactorCurve?.point == null || tempFpml.discountFactorCurve.point.Length == 0; if (bootstrap || discountsAbsent) { //There must be a valid quoted asset set in order to bootstrap. if (!XsdClassesFieldResolver.QuotedAssetSetIsValid(spreadAssets)) { return; } PriceableRateSpreadAssets = PriceableAssetFactory.CreatePriceableRateSpreadAssets(logger, cache, nameSpace, pricingStructureId.BaseDate, spreadAssets, fixingCalendar, rollCalendar); Build(logger, cache, nameSpace, fixingCalendar, rollCalendar); } else { // the discount curve is already built, so don't rebuild PriceableRateSpreadAssets = PriceableAssetFactory.CreatePriceableRateSpreadAssets(logger, cache, nameSpace, pricingStructureId.BaseDate, spreadAssets, fixingCalendar, rollCalendar); //Order the assets. PriceableRateSpreadAssets = PriceableRateSpreadAssets.OrderBy(a => a.GetRiskMaturityDate()).ToList(); CreatePricingStructure(pricingStructureId, tempFpml.discountFactorCurve, PriceableAssetFactory.Parse(PriceableRateSpreadAssets)); SetInterpolator(BaseCurve, pricingStructureId.PricingStructureType); } }
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); }
private static Cashflows GetCashflows( InterestRateStream interestRateStream, CalculationPeriodsPrincipalExchangesAndStubs calculationPeriodsPrincipalExchangesAndStubs, IBusinessCalendar paymentCalendar) { // Assign notionals, rates, cap/floor rate, etc // StreamCashflowsGenerator.UpdateCalculationPeriodsData(interestRateStream, calculationPeriodsPrincipalExchangesAndStubs); List <PaymentCalculationPeriod> paymentCalculationPeriods = StreamCashflowsGenerator.GetPaymentCalculationPeriods(interestRateStream, calculationPeriodsPrincipalExchangesAndStubs, paymentCalendar); Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(interestRateStream.calculationPeriodAmount); UpdateNumberOfDaysAndYearFraction(paymentCalculationPeriods, calculation); return(CashflowsFactory.Create(paymentCalculationPeriods, calculationPeriodsPrincipalExchangesAndStubs.GetAllPrincipalExchanges(), true));//TODO THe cashflowsmatch paraqmeter at the end could be a problem! }
private static TradeHeader CreateTradeHeader(DateTime tradeDate, string tradeId) { var tradeHeader = new TradeHeader { tradeDate = IdentifiedDateHelper.Create(TradeProp.TradeDate, tradeDate), partyTradeIdentifier = new[] { new PartyTradeIdentifier() } }; var tradeIdAsObject = new TradeId { tradeIdScheme = "FpML", Value = tradeId }; XsdClassesFieldResolver.TradeIdentifierSetTradeId(tradeHeader.partyTradeIdentifier[0], tradeIdAsObject); return(tradeHeader); }
public string CacheFraTradeWithProperties(ILogger logger, ICoreCache cache, FraInputRange fraInputRange, NamedValueSet properties) { var fra = ProductFactory.GetFpMLFra(fraInputRange); var trade = new Trade(); XsdClassesFieldResolver.TradeSetFra(trade, fra); //Get the id. ProductIdentifier = new Identifiers.TradeIdentifier(properties); var fraId = ProductIdentifier.UniqueIdentifier; //Cache the trade. cache.SaveObject(trade, fraId, properties); return(fraId); }
private static void UpdateNumberOfDaysAndYearFraction(IEnumerable <PaymentCalculationPeriod> paymentCalculationPeriods, Calculation calculation) { foreach (PaymentCalculationPeriod pcp in paymentCalculationPeriods) { // set the calculationPeriodNumberOfDays and dayCountYearFraction fields // foreach (CalculationPeriod calculationPeriod in XsdClassesFieldResolver.GetPaymentCalculationPeriodCalculationPeriodArray(pcp)) { IDayCounter dayCounter = DayCounterHelper.Parse(calculation.dayCountFraction.Value); calculationPeriod.calculationPeriodNumberOfDays = dayCounter.DayCount(calculationPeriod.adjustedStartDate, calculationPeriod.adjustedEndDate).ToString(CultureInfo.InvariantCulture); calculationPeriod.dayCountYearFraction = (decimal)dayCounter.YearFraction(calculationPeriod.adjustedStartDate, calculationPeriod.adjustedEndDate); calculationPeriod.dayCountYearFractionSpecified = true; } } }
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 coupon type. Only Cap & Floor coupons are expected here."); }
public static Trade CreateFraTrade(string tradeId, RequiredIdentifierDate adjustedEffectiveDate, DateTime adjustedTerminationDate, AdjustableDate paymentDate, RelativeDateOffset fixingDayOffset, DayCountFraction dayCountFraction, decimal notionalAmount, string notionalCurrency, decimal fixedRate, string floatingRateIndex, string indexTenor, FraDiscountingEnum fraDiscounting) { var trade = new Trade(); var fra = new Fra { adjustedEffectiveDate = adjustedEffectiveDate, adjustedTerminationDate = adjustedTerminationDate, adjustedTerminationDateSpecified = true, paymentDate = paymentDate, Items = new object[] { new ProductType { Value = ProductTypeSimpleEnum.FRA.ToString() } }, ItemsElementName = new[] { ItemsChoiceType2.productType } }; if ("resetDate" != fixingDayOffset.dateRelativeTo.href) { throw new ArgumentException("The fixing date must be specified as 'resetDate'-relative!", nameof(fixingDayOffset)); } fra.fixingDateOffset = fixingDayOffset; fra.dayCountFraction = dayCountFraction; IDayCounter dayCounter = DayCounterHelper.Parse(fra.dayCountFraction.Value); fra.calculationPeriodNumberOfDays = dayCounter.DayCount(fra.adjustedEffectiveDate.Value, fra.adjustedTerminationDate).ToString(CultureInfo.InvariantCulture); fra.notional = MoneyHelper.GetAmount(notionalAmount, notionalCurrency); fra.fixedRate = fixedRate; fra.fixedRateSpecified = true; fra.floatingRateIndex = FloatingRateIndexHelper.Parse(floatingRateIndex); fra.indexTenor = new[] { PeriodHelper.Parse(indexTenor) }; fra.fraDiscounting = fraDiscounting; fra.fraDiscountingSpecified = true; PartyReference party1 = PartyReferenceFactory.Create("party1"); PartyReference party2 = PartyReferenceFactory.Create("party2"); fra.sellerPartyReference = party2; fra.buyerPartyReference = party1; XsdClassesFieldResolver.TradeSetFra(trade, fra); trade.id = tradeId; return(trade); }
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); }