/// <summary> /// Initializes a new instance of the <see cref="PriceableBondCouponRateStream"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace.</param> /// <param name="bondId">The bond Id.</param> /// <param name="paymentConvention">The payment roll conventions</param> /// <param name="forecastRateInterpolation">ForwardEndDate = forecastRateInterpolation ? AccrualEndDate /// : AdjustedDateHelper.ToAdjustedDate(forecastRateIndex.indexTenor.Add(AccrualStartDate), AccrualBusinessDayAdjustments);</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="paymentCalendar">The paymentCalendar.</param> /// <param name="tradeDate">The trade date is used to set the base date for future coupon generation.</param> /// <param name="notionalAmount">The notional amount</param> /// <param name="couponType">The coupon type: fixed or floating.</param> /// <param name="bond">THe bond details.</param> public PriceableBondCouponRateStream ( ILogger logger , ICoreCache cache , string nameSpace , string bondId , DateTime tradeDate , decimal notionalAmount , CouponStreamType couponType , Bond bond , BusinessDayAdjustments paymentConvention , bool forecastRateInterpolation , IBusinessCalendar fixingCalendar , IBusinessCalendar paymentCalendar) { BondId = bondId; Multiplier = 1.0m; PaymentCurrencies = new List <string>(); AnalyticsModel = new BondStreamAnalytic(); BondCouponStreamType = couponType; Id = BuildId(bondId, BondCouponStreamType); Currency = bond.currency.Value; ForecastRateInterpolation = forecastRateInterpolation; //Get the currency. if (!PaymentCurrencies.Contains(bond.currency.Value)) { PaymentCurrencies.Add(bond.currency.Value); } //The calendars if (paymentCalendar == null) { paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, paymentConvention.businessCenters, nameSpace); } //Set the default discount curve name. BondCurveName = CurveNameHelpers.GetBondCurveName(Currency, bondId); //Set the forecast curve name.//TODO extend this to the other types. //if (BondCouponStreamType != CouponStreamType.GenericFixedRate) //{ // if (fixingCalendar == null) // { // fixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, ResetDates.resetDatesAdjustments.businessCenters, nameSpace); // } // ForecastCurveName = null; // //if (Calculation.Items != null) // //{ // // var floatingRateCalculation = Calculation.Items; // // var floatingRateIndex = (FloatingRateCalculation) floatingRateCalculation[0]; // // ForecastCurveName = CurveNameHelpers.GetForecastCurveName(floatingRateIndex); // //} //} //Build the coupons and principal exchanges. Coupons = PriceableInstrumentsFactory.CreatePriceableBondCoupons(tradeDate, bond, notionalAmount, BondCouponStreamType, paymentConvention, ForecastRateInterpolation, fixingCalendar, paymentCalendar);//TODO add the stub calculation. UpdateCouponDiscountCurveNames(); UpdateCouponIds(); //RiskMaturityDate = ; logger.LogInfo("Bond Coupon Stream built"); }
/// <summary> /// Initializes a new instance of the <see cref="PriceableSimpleBond"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="bond">The bond</param> /// <param name="settlementDate">The settlement date.</param> /// <param name="exDivDate">The ex dividend date.</param> /// <param name="businessDayAdjustments">The business day adjustments.</param> /// <param name="paymentCalendar">The payment Calendar.</param> /// <param name="marketQuote">The market quote.</param> /// <param name="quoteType">The quote type</param> public PriceableSimpleBond(DateTime baseDate, Bond bond, DateTime settlementDate, DateTime exDivDate, BusinessDayAdjustments businessDayAdjustments, IBusinessCalendar paymentCalendar, BasicQuotation marketQuote, BondPriceEnum quoteType) : base(baseDate, bond.faceAmount, bond.currency, null, null, businessDayAdjustments, marketQuote, quoteType) { Id = bond.id; var tempId = Id.Split('-'); var bondId = tempId[0]; if (tempId.Length > 2) { bondId = tempId[2]; } Issuer = (string)bond.Item;//Does not handle PartyReference type -> only string! Description = "Not Defined"; if (bond.description != null) { Description = bond.description; } MaturityDate = bond.maturity; CouponDayCount = new DayCountFraction { Value = bond.dayCountFraction.Value }; if (bond.parValueSpecified) { ParValue = bond.parValue; } if (bond.couponRateSpecified) { CouponRate = bond.couponRate; } CouponFrequency = new Period { period = bond.paymentFrequency.period, periodMultiplier = bond.paymentFrequency.periodMultiplier }; CouponType = CouponTypeEnum.Fixed; if (bond.clearanceSystem != null) { ClearanceSystem = bond.clearanceSystem.Value; } if (bond.exchangeId != null) { Exchange = bond.exchangeId.Value; } if (bond.seniority != null) { Seniority = EnumHelper.Parse <CreditSeniorityEnum>(bond.seniority.Value); } if (bond.instrumentId != null) { InstrumentIds = new List <InstrumentId>(); foreach (var identifier in bond.instrumentId.Select(id => InstrumentIdHelper.Parse(id.Value))) { InstrumentIds.Add(identifier); } } //This handles the case of a bond forward used in curve building. if (MaturityDate > BaseDate) { var rollConvention = RollConventionEnumHelper.Parse(MaturityDate.Day.ToString(CultureInfo.InvariantCulture)); Frequency = FrequencyHelper.ToFrequency(bond.paymentFrequency); SettlementDate = settlementDate; UnAdjustedPeriodDates = DateScheduler.GetUnadjustedCouponDatesFromMaturityDate(SettlementDate, MaturityDate, CouponFrequency, rollConvention, out _, out var nextCouponDate); LastCouponDate = UnAdjustedPeriodDates[0]; NextCouponDate = nextCouponDate; AdjustedPeriodDates = AdjustedDateScheduler.GetAdjustedDateSchedule(UnAdjustedPeriodDates, PaymentBusinessDayAdjustments.businessDayConvention, paymentCalendar).ToArray(); AdjustedPeriodDates[0] = SettlementDate; NextExDivDate = exDivDate; IsXD = IsExDiv(); } BondCurveName = CurveNameHelpers.GetBondCurveName(Currency.Value, bondId); SwapDiscountCurveName = CurveNameHelpers.GetDiscountCurveName(Currency.Value, true); }
/// <summary> /// /// </summary> /// <param name="logger"></param> /// <param name="cache"></param> /// <param name="nameSpace"></param> /// <param name="tradeDate"></param> /// <param name="settlementDate">The payment settlement date.</param> /// <param name="settlementCalendar"></param> /// <param name="paymentCalendar"></param> /// <param name="bondFpML"></param> /// <param name="basePartyReference"></param> /// <param name="bondType"></param> /// <param name="forecastRateInterpolation"></param> public BondTransactionPricer(ILogger logger, ICoreCache cache, string nameSpace, DateTime tradeDate, DateTime settlementDate, IBusinessCalendar settlementCalendar, IBusinessCalendar paymentCalendar, BondTransaction bondFpML, string basePartyReference, string bondType, bool forecastRateInterpolation) { Multiplier = 1.0m; TradeDate = tradeDate; BondType = EnumHelper.Parse <BondTypesEnum>(bondType); logger.LogInfo("BondType set. Commence to build a bond transaction."); if (bondFpML == null) { return; } BuyerReference = bondFpML.buyerPartyReference.href; PaymentCurrencies = new List <string> { bondFpML.notionalAmount.currency.Value }; SellerReference = bondFpML.sellerPartyReference.href; BasePartyBuyer = basePartyReference == bondFpML.buyerPartyReference.href; if (!BasePartyBuyer) { Multiplier = -1.0m; } ForecastRateInterpolation = forecastRateInterpolation; SettlementCalendar = settlementCalendar; PaymentCalendar = paymentCalendar; //Set the bond price information BondPrice = new BondPrice(); if (bondFpML.price.accrualsSpecified) { BondPrice.accrualsSpecified = true; BondPrice.accruals = bondFpML.price.accruals; } if (bondFpML.price.dirtyPriceSpecified) { BondPrice.dirtyPriceSpecified = true; BondPrice.dirtyPrice = bondFpML.price.dirtyPrice; } BondPrice.cleanOfAccruedInterest = bondFpML.price.cleanOfAccruedInterest; BondPrice.cleanPrice = bondFpML.price.cleanPrice; //Set the currencies CouponCurrency = bondFpML.notionalAmount.currency; PaymentCurrency = bondFpML.notionalAmount.currency;//This could be another currency! //Set the notional information NotionalAmount = MoneyHelper.GetAmount(bondFpML.notionalAmount.amount, bondFpML.notionalAmount.currency.Value); //Determines the quotation and units QuoteType = BondPriceEnum.YieldToMaturity; //We need to get the ytm in until there is a bond market price/spread. if (BondPrice.dirtyPriceSpecified) { QuoteType = BondPriceEnum.DirtyPrice; Quote = BasicQuotationHelper.Create(BondPrice.dirtyPrice, RateQuotationType); } //Get the instrument configuration information. var assetIdentifier = bondFpML.bond.currency.Value + "-Bond-" + BondType; BondNodeStruct bondTypeInfo = null; //TODO Set the swap curves for asset swap valuation. // //Gets the template bond type var instrument = InstrumentDataHelper.GetInstrumentConfigurationData(cache, nameSpace, assetIdentifier); if (instrument != null) { bondTypeInfo = instrument.InstrumentNodeItem as BondNodeStruct; } if (bondFpML.bond != null && bondTypeInfo != null) { if (SettlementCalendar == null) { SettlementCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, bondTypeInfo.SettlementDate.businessCenters, nameSpace); } if (PaymentCalendar == null) { PaymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, bondTypeInfo.BusinessDayAdjustments.businessCenters, nameSpace); } //Pre-processes the data for the priceable asset. var bond = XmlSerializerHelper.Clone(bondFpML.bond); Bond = bond; bondTypeInfo.Bond = Bond; //Set the curves to use for valuations. BondCurveName = CurveNameHelpers.GetBondCurveName(Bond.currency.Value, Bond.id); //THe discount curve is only for credit calculations. DiscountCurveName = CurveNameHelpers.GetDiscountCurveName(Bond.currency.Value, true); if (bond.maturitySpecified) { MaturityDate = bond.maturity; } SettlementDateConvention = bondTypeInfo.SettlementDate; BusinessDayAdjustments = bondTypeInfo.BusinessDayAdjustments; ExDivDateConvention = bondTypeInfo.ExDivDate; //This is done because the config data is not stored in the correct way. Need to add a price quote units. if (bond.couponRateSpecified) { var coupon = bond.couponRate; Bond.couponRate = coupon; } bondTypeInfo.Bond.faceAmount = NotionalAmount.amount; bondTypeInfo.Bond.faceAmountSpecified = true; Bond.faceAmount = NotionalAmount.amount; if (Bond.maturitySpecified) { RiskMaturityDate = Bond.maturity; } SettlementDate = settlementDate; if (!PaymentCurrencies.Contains(bondFpML.bond.currency.Value)) { PaymentCurrencies.Add(bondFpML.bond.currency.Value); } logger.LogInfo("Bond transaction has been successfully created."); } else { logger.LogInfo("Bond type data not available."); } //Set the underlying bond UnderlyingBond = new PriceableSimpleBond(tradeDate, bondTypeInfo, SettlementCalendar, PaymentCalendar, Quote, QuoteType); BondIssuer = UnderlyingBond.Issuer; if (BondPrice.dirtyPriceSpecified) { UnderlyingBond.PurchasePrice = BondPrice.dirtyPrice / 100; //PriceQuoteUnits } //Set the coupons var bondId = Bond.id;//Could use one of the instrumentIds //bondStream is an interest Rate Stream but needs to be converted to a bond stream. //It automatically contains the coupon currency. Coupons = new PriceableBondCouponRateStream(logger, cache, nameSpace, bondId, tradeDate, bondFpML.notionalAmount.amount, CouponStreamType.GenericFixedRate, Bond, BusinessDayAdjustments, ForecastRateInterpolation, null, PaymentCalendar); //Add payments like the settlement price if (!BondPrice.dirtyPriceSpecified) { return; } var amount = BondPrice.dirtyPrice * NotionalAmount.amount / 100; var settlementPayment = PaymentHelper.Create(BuyerReference, SellerReference, PaymentCurrency.Value, amount, SettlementDate); AdditionalPayments = PriceableInstrumentsFactory.CreatePriceablePayments(basePartyReference, new[] { settlementPayment }, SettlementCalendar); // var finalPayment = PaymentHelper.Create(BondIssuer, BuyerReference, CouponCurrency.Value, NotionalAmount.amount, RiskMaturityDate); FinalRedemption = PriceableInstrumentsFactory.CreatePriceablePayment(basePartyReference, finalPayment, PaymentCalendar); AdditionalPayments.Add(FinalRedemption); if (!PaymentCurrencies.Contains(settlementPayment.paymentAmount.currency.Value)) { PaymentCurrencies.Add(settlementPayment.paymentAmount.currency.Value); } }
/// <summary> /// Initializes a new instance of the <see cref="PriceableSimpleBond"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="nodeStruct">The bond nodeStruct</param> /// <param name="settlementCalendar">The settlement Calendar.</param> /// <param name="paymentCalendar">The payment Calendar.</param> /// <param name="marketQuote">The market quote.</param> /// <param name="quoteType">THe quote Type</param> public PriceableSimpleBond(DateTime baseDate, BondNodeStruct nodeStruct, IBusinessCalendar settlementCalendar, IBusinessCalendar paymentCalendar, BasicQuotation marketQuote, BondPriceEnum quoteType) : base(baseDate, nodeStruct.Bond.faceAmount, nodeStruct.Bond.currency, nodeStruct.SettlementDate, nodeStruct.ExDivDate, nodeStruct.BusinessDayAdjustments, marketQuote, quoteType) { Id = nodeStruct.Bond.id; var tempId = Id.Split('-'); var bondId = tempId[0]; if (tempId.Length > 2) { bondId = tempId[2]; } SettlementDateCalendar = settlementCalendar; Issuer = (string)nodeStruct.Bond.Item;//Does not handle PartyReference type -> only string! Description = "Not Defined"; //IsYTMQuote = true; if (nodeStruct.Bond.description != null) { Description = nodeStruct.Bond.description; } MaturityDate = nodeStruct.Bond.maturity; CouponDayCount = new DayCountFraction { Value = nodeStruct.Bond.dayCountFraction.Value }; CouponFrequency = new Period { period = nodeStruct.Bond.paymentFrequency.period, periodMultiplier = nodeStruct.Bond.paymentFrequency.periodMultiplier }; if (nodeStruct.Bond.couponRateSpecified) { CouponRate = nodeStruct.Bond.couponRate; } if (nodeStruct.Bond.parValueSpecified) { ParValue = nodeStruct.Bond.parValue; } if (nodeStruct.Bond.clearanceSystem != null) { ClearanceSystem = nodeStruct.Bond.clearanceSystem.Value; } if (nodeStruct.Bond.exchangeId != null) { Exchange = nodeStruct.Bond.exchangeId.Value; } CouponType = CouponTypeEnum.Fixed; if (nodeStruct.Bond.seniority != null) { Seniority = EnumHelper.Parse <CreditSeniorityEnum>(nodeStruct.Bond.seniority.Value, true); } if (nodeStruct.Bond.instrumentId != null) { InstrumentIds = new List <InstrumentId>(); foreach (var identifier in nodeStruct.Bond.instrumentId.Select(id => InstrumentIdHelper.Parse(id.Value))) { InstrumentIds.Add(identifier); } } //This handles the case of a bondforward used in curve building. if (MaturityDate > BaseDate) { DateTime lastCouponDate; DateTime nextCouponDate; var rollConvention = RollConventionEnumHelper.Parse(MaturityDate.Day.ToString(CultureInfo.InvariantCulture)); Frequency = FrequencyHelper.ToFrequency(nodeStruct.Bond.paymentFrequency); //Get the settlement date SettlementDate = GetSettlementDate(baseDate, settlementCalendar, nodeStruct.SettlementDate); //Generate the necessary dates. //TODO Should the settlement date and the underlying bond be calculated on the fly when calculation occurs? UnAdjustedPeriodDates = DateScheduler.GetUnadjustedCouponDatesFromMaturityDate(SettlementDate, MaturityDate, CouponFrequency, rollConvention, out lastCouponDate, out nextCouponDate); LastCouponDate = UnAdjustedPeriodDates[0]; NextCouponDate = nextCouponDate; AdjustedPeriodDates = AdjustedDateScheduler.GetAdjustedDateSchedule(UnAdjustedPeriodDates, nodeStruct.BusinessDayAdjustments .businessDayConvention, paymentCalendar) .ToArray(); AdjustedPeriodDates[0] = SettlementDate; //TODO check this! NextExDivDate = GetNextExDivDate(); IsXD = IsExDiv(); } BondCurveName = CurveNameHelpers.GetBondCurveName(Currency.Value, bondId); SwapDiscountCurveName = CurveNameHelpers.GetDiscountCurveName(Currency.Value, true); }