/// <summary> /// Add tf market data definition to an existing market. /// </summary> /// <param name="marketName">The Existing Market Name</param> /// <param name="tfId">The Bond futures Id</param> /// <param name="bondId">The Bond Id</param> /// <param name="quoteType">The Price quote type(Irr, Basis, NetBasis)</param> /// <param name="quote">The quote of bond futures</param> /// <param name="isOverride">if true, then add or override. if false, then ignore(default true)</param> /// <returns>if succeeded, return true. if failed, return error message : "Market {market object name} is not available!"</returns> public static object xl_MktAddTreasuryFutureData(string marketName, string tfId, string bondId, string quoteType, double quote, bool isOverride = true) { var mktObjName = tfId + "_" + bondId; var marketData = new TreasuryFutureMktData(mktObjName, quoteType, quote); return(XlManager.MergeMarketInfo(marketName, marketData, isOverride)); }
/// <summary> /// Return QDP bond futures qdp object. /// </summary> /// <param name="tradeId"></param> /// <param name="startDate"></param> /// <param name="settlementDate"></param> /// <param name="deliverableBondIds"></param> /// <param name="notional"></param> /// <param name="calendar"></param> /// <param name="dayCount"></param> /// <param name="nominalCoupon"></param> /// <param name="currency"></param> /// <returns></returns> public static object xl_CustomizedBondFutures(string tradeId, string startDate = null, string settlementDate = null, string[] deliverableBondIds = null, double notional = 1000000, string calendar = "chn", string dayCount = "Act365", double nominalCoupon = 0.03, string currency = "CNY") { var trade = XlManager.GetTrade(tradeId); if (!(trade is BondFuturesInfo)) { startDate = startDate ?? DateTime.Now.ToString("yyyy-MM-dd"); settlementDate = settlementDate ?? new Term("3M").Next(startDate.ToDate()).ToString(); trade = new BondFuturesInfo(tradeId) { StartDate = startDate, MaturityDate = settlementDate, Calendar = calendar, Currency = currency, DayCount = dayCount, DeliverableBondInfos = deliverableBondIds == null ? null : deliverableBondIds.Select(x => (FixedRateBondInfo)XlManager.GetTrade(x)).ToArray(), InstrumentType = "BondFutures", NominalCoupon = nominalCoupon, Notional = notional, ValuationParamters = new SimpleCfValuationParameters("FundingCurve", "", "FundingCurve") }; XlManager.AddTrades(new[] { trade }); } return(trade.ToTradeInfoInLabelData(null)); }
/// <summary> /// Get the zero rate for a given period on a given curve. /// </summary> /// <param name="mktName">The name of the market.</param> /// <param name="curveName">The name of the yield curve.</param> /// <param name="startDate">The start date of the calculation period, i.e. 2017-01-03.</param> /// <param name="endDate">The end date of the calculation period, i.e. 2017-01-13.</param> /// <returns></returns> public static double GetZeroRate(string mktName, string curveName, string startDate, string endDate) { //var qdpMarket = XlManager.GetXlMarket(mktName).QdpMarket; //var yieldcurve = qdpMarket.GetData<CurveData>(curveName).YieldCurve; var yieldcurve = XlManager.GetPrebuildQdpMarket(mktName).YieldCurves[curveName]; return(yieldcurve.ZeroRate(startDate.ToDate(), endDate.ToDate())); }
/// <summary> /// Add HistoricalIndexRates market data definition to an existing market. /// </summary> /// <param name="marketName">The Existing Market Name</param> /// <param name="indexType">The index type(enum IndexType)</param> /// <param name="indexDate">The index date</param> /// <param name="indexRate">The rate</param> /// <param name="isOverride">if true, then add or override. if false, then ignore(default true)</param> /// <returns>if succeeded, return true. if failed, return error message : "Market {market object name} is not available!"</returns> public static object xl_MktAddHistoricalIndexRates(string marketName, IndexType indexType, Date indexDate, double indexRate, bool isOverride = true) { var hisDic = new Dictionary <IndexType, Dictionary <Date, double> > { { indexType, new Dictionary <Date, double> { { indexDate, indexRate } } } }; return(XlManager.MergeMarketInfo(marketName, hisDic, isOverride)); }
/// <summary> /// Add instrument curve market data definition to an existing market. /// </summary> /// <param name="marketName">The Existing Market Name</param> /// <param name="curveName">The curve name</param> /// <param name="curveConvention">The curveConvention</param> /// <param name="rateDefinitions">The rateMktData array</param> /// <param name="trait">(enum YieldCurveTrait)</param> /// <param name="baseCurveDefinition">The base InstrumentCurveDefinition(default null)</param> /// <param name="regriddedTenors">The regriddedTenors array(default null)</param> /// <param name="isOverride">if true, then add or override. if false, then ignore(default true)</param> /// <returns>if succeeded, return true. if failed, return error message : "Market {market object name} is not available!"</returns> public static object xl_MktAddYieldCurve(string marketName, string curveName, CurveConvention curveConvention, RateMktData[] rateDefinitions, string trait, InstrumentCurveDefinition baseCurveDefinition = null, string[] regriddedTenors = null, bool isOverride = true) { var marketData = new InstrumentCurveDefinition(curveName, curveConvention, rateDefinitions, trait, baseCurveDefinition, regriddedTenors); return(XlManager.MergeMarketInfo(marketName, marketData, isOverride)); }
/// <summary> /// Add curve convention market data definition to an existing market. /// </summary> /// <param name="marketName">The Existing Market Name</param> /// <param name="curveConventionName">The curve convention name</param> /// <param name="currency">The currency (enum CurrencyCode)</param> /// <param name="businessDayConvention">(enum BusinessDayConvention)</param> /// <param name="calendar">(enum Calendar)</param> /// <param name="dayCount">(enum DayCount)</param> /// <param name="compound">(enum Compound)</param> /// <param name="interpolation">(enum Interpolation)</param> /// <param name="isOverride">if true, then add or override. if false, then ignore(default true)</param> /// <returns>if succeeded, return true. if failed, return error message : "Market {market object name} is not available!"</returns> public static object xl_MktAddCurveConvention(string marketName, string curveConventionName, string currency, string businessDayConvention, string calendar, string dayCount, string compound, string interpolation, bool isOverride = true) { var marketData = new CurveConvention(curveConventionName, currency, businessDayConvention, calendar, dayCount, compound, interpolation); return(XlManager.MergeMarketInfo(marketName, marketData, isOverride)); }
public static Dictionary <string, PnLResultBase> DoPnLExplain(string[] tradeIds, PrebuiltQdpMarket t0Mkt, PrebuiltQdpMarket t1Mkt, PrebuiltQdpMarket t0MktDateRolledFwd, PrebuiltQdpMarket t0MktRolldownForBond, PrebuiltQdpMarket t0MktPriceNow = null, PrebuiltQdpMarket t0MktPriceVolNow = null, PrebuiltQdpMarket t0MktVolNow = null) { //TODO: add the following for more exotic product where rate/price interplay is more pronounced //resultRateNow, resultPriceRateNow, resultVolRateNow, resultPriceVolRateNow var useRevalPnLFramework = (t0MktPriceNow != null && t0MktVolNow != null && t0MktPriceVolNow != null); //use reval for pnl attribution //PnL = PriceImpact + VolImpact + PriceVolCrossImpact + Unexplained var ret = new Dictionary <string, PnLResultBase>(); var tMarketName = t0Mkt.MarketName; var t1MarketName = t1Mkt.MarketName; var t0Vals = new Dictionary <string, IPricingResult>(); var t0ValsRolledForward = new Dictionary <string, IPricingResult>(); var t1Vals = new Dictionary <string, IPricingResult>(); var t0ValsPriceNow = new Dictionary <string, IPricingResult>(); var t0RolldownPriceForBond = new Dictionary <string, IPricingResult>(); var t0ValsVolNow = new Dictionary <string, IPricingResult>(); var t0ValsPriceVolNow = new Dictionary <string, IPricingResult>(); //use minimium price request to make it faster #region requests var pricingRequest = PricingRequest.Pv | PricingRequest.Cashflow | PricingRequest.DirtyPrice | PricingRequest.KeyRateDv01 | PricingRequest.DollarDuration | PricingRequest.DollarConvexity | PricingRequest.Delta | PricingRequest.Gamma | PricingRequest.Vega | PricingRequest.Theta | PricingRequest.Rho | PricingRequest.DVegaDvol | //one high order risk PricingRequest.ZeroSpread | PricingRequest.ZeroSpreadDelta | PricingRequest.AiEod | PricingRequest.Basis | PricingRequest.CheapestToDeliver | PricingRequest.Ytm | PricingRequest.UnderlyingPv | PricingRequest.Carry; #endregion requests foreach (var tradeId in tradeIds) { t0Vals[tradeId] = xl_ValueTrade(tradeId, t0Mkt, pricingRequest); var t1Request = PricingRequest.Pv | PricingRequest.DirtyPrice | PricingRequest.ZeroSpread | PricingRequest.AiEod | PricingRequest.Ytm | PricingRequest.Basis | PricingRequest.Cashflow; t1Vals[tradeId] = xl_ValueTrade(tradeId, t1Mkt, t1Request); t0ValsRolledForward[tradeId] = xl_ValueTrade(tradeId, t0MktDateRolledFwd, PricingRequest.Pv | PricingRequest.DirtyPrice | PricingRequest.UnderlyingPv); //reval framework for better pnl attribution if (useRevalPnLFramework) { t0ValsPriceNow[tradeId] = xl_ValueTrade(tradeId, t0MktPriceNow, PricingRequest.Pv); t0ValsVolNow[tradeId] = xl_ValueTrade(tradeId, t0MktVolNow, PricingRequest.Pv); t0ValsPriceVolNow[tradeId] = xl_ValueTrade(tradeId, t0MktPriceVolNow, PricingRequest.Pv); t0RolldownPriceForBond[tradeId] = xl_ValueTrade(tradeId, t0MktRolldownForBond, PricingRequest.Pv | PricingRequest.ZeroSpread); } } //For old interface: //var tCurves = GetXlMarket(tMarketName).MarketInfo.YieldCurveDefinitions.Select(x => x.Name) // .Select(x => t0Mkt.GetData<CurveData>(x).YieldCurve).ToDictionary(x => x.Name, x => x); //var t1Curves = GetXlMarket(t1MarketName).MarketInfo.YieldCurveDefinitions.Select(x => x.Name) // .Select(x => t1Mkt.GetData<CurveData>(x).YieldCurve).ToDictionary(x => x.Name, x => x); var tCurves = t0Mkt.YieldCurves; var t1Curves = t1Mkt.YieldCurves; var curveMoveScaling = 1e4; foreach (var tradeId in tradeIds) { var t1cf = (t1Vals[tradeId].Cashflows != null) ? t1Vals[tradeId].Cashflows.Where(x => x.PaymentDate <= t1Mkt.ReferenceDate && x.PaymentDate > t0Mkt.ReferenceDate).Sum(x => x.PaymentAmount) : 0.0; var tradeInfo = GetTrade(tradeId); if (tradeInfo is InterestRateSwapInfo || tradeInfo is BondInfoBase || tradeInfo is BondFuturesInfo) { //PnL using bond discounted cash flows //curve risk is between T0_{prime} and T1 var _tPv = t0Vals[tradeId].Pv; var _t1Pv = t1Vals[tradeId].Pv; var _tPvRecalib = t0ValsRolledForward[tradeId].Pv; var curvePnL = new Dictionary <string, CurveRisk[]>(); foreach (var curveRiskse in t0Vals[tradeId].KeyRateDv01) { var tCurve = tCurves[curveRiskse.Key]; var t1Curve = t1Curves[curveRiskse.Key]; curvePnL[curveRiskse.Key] = curveRiskse.Value.Select(x => new CurveRisk( x.Tenor, x.Risk * (t1Curve[x.Tenor] - tCurve[x.Tenor]) * curveMoveScaling )).ToArray(); } //include raw t1 curve risks in result foreach (var curveRisks in t0Vals[tradeId].KeyRateDv01) { curvePnL[curveRisks.Key + "KeyRateDv01"] = curveRisks.Value; } var pnLCurve = new CommonPnLResult(_tPv, _t1Pv, _tPvRecalib - _tPv, t1cf, curvePnL); ret[tradeId] = pnLCurve; } if (tradeInfo is InterestRateSwapInfo) { var swap = tradeInfo as InterestRateSwapInfo; //carry & roll down var rollDown = t0ValsRolledForward[tradeId].Pv - t0Vals[tradeId].Pv; var carry = t0Vals[tradeId].Carry; var pnlTime = rollDown + carry; var commonPnl = ret[tradeId]; var pnlPv01 = ret.ContainsKey(tradeId) && ret[tradeId].YieldCurvePnL.Count > 0 ? ret[tradeId].YieldCurvePnL.First().Value.Sum(x => x.Risk) : 0.0; var pnl = new SwapPnLResult(commonPnl.TPv, commonPnl.T1Pv, pnlTime: pnlTime, t1Cf: t1cf, pnlPv01: pnlPv01, pnlCarry: carry, pnlRolldown: rollDown); ret[tradeId + "durationConvexity"] = pnl; } if (tradeInfo is BondInfoBase) { var bond = tradeInfo as BondInfoBase; var tPv = t0Vals[tradeId].DirtyPrice; var t1Pv = t1Vals[tradeId].DirtyPrice; var tPvRecalib = t0ValsRolledForward[tradeId].DirtyPrice; //bond market PnL var pnlPv01 = ret.ContainsKey(tradeId) && ret[tradeId].YieldCurvePnL.Count > 0 ? ret[tradeId].YieldCurvePnL.First().Value.Sum(x => x.Risk) : 0.0; //bond specific pnl var tZSpread = t0Vals[tradeId].ZeroSpread; var t1ZSpread = t1Vals[tradeId].ZeroSpread; var tZSpreadDelta = t0Vals[tradeId].ZeroSpreadDelta; var zSpreadPnl = tZSpreadDelta * (t1ZSpread - tZSpread) * curveMoveScaling; var pnlCarry = t1Vals[tradeId].Ai - t0Vals[tradeId].Ai; //bond roll down effect: cashflow less, but benefit from still curve, note that zspread also changes due to rolling down the curve var pnlRolldown = t0RolldownPriceForBond[tradeId].Pv - t0Vals[tradeId].Pv + tZSpreadDelta * (t0RolldownPriceForBond[tradeId].ZeroSpread - tZSpread) * curveMoveScaling; var pnlTime = pnlCarry + pnlRolldown; //duration pnl is not used in book level pnl explain var pnlDuration = t0Vals[tradeId].ModifiedDuration * (t1Vals[tradeId].Ytm - t0Vals[tradeId].Ytm) * bond.Notional; var pnlConverixy = 0.5 * Math.Pow(t1Vals[tradeId].Ytm - t0Vals[tradeId].Ytm, 2.0) * t0Vals[tradeId].DollarConvexity / 100.0; var explainedPriceImpact = pnlPv01 + zSpreadPnl + pnlConverixy + pnlTime; var pnl = new BondPnLResult(tPv, t1Pv, pnlTime: pnlTime, t1Cf: t1cf, pnlPv01: pnlPv01, pnlZspread: zSpreadPnl, pnlCarry: pnlCarry, pnlRolldown: pnlRolldown, pnlDuration: pnlDuration, pnlConvexity: pnlConverixy); ret[tradeId + "durationConvexity"] = pnl; } if (tradeInfo is BondFuturesInfo) { var tPv = t0Vals[tradeId].DirtyPrice; var t1Pv = t1Vals[tradeId].DirtyPrice; //curve pnl var pnlPv01 = ret.ContainsKey(tradeId) && ret[tradeId].YieldCurvePnL.Count > 0 ? ret[tradeId].YieldCurvePnL.First().Value.Sum(x => x.Risk) : 0.0; //zspread pnl from CTD, converted to future equivalen t var zspreadT0 = t0Vals[tradeId].ZeroSpread; var zspreadT1 = t1Vals[tradeId].ZeroSpread; var zspreadPnl = (zspreadT1 - zspreadT0) * curveMoveScaling * t0Vals[tradeId].ZeroSpreadDelta; //basis pnl from CTD/cf - Future var basisT0 = t0Vals[tradeId].Basis; var basisT1 = t1Vals[tradeId].Basis; var bondFut = XlManager.GetTrade(tradeId) as BondFuturesInfo; var futPosScaling = 1.0 / 100.0 * bondFut.Notional; var basisPnL = (basisT1 - basisT0) * futPosScaling; //convexity pnl from CTD var ctdId = t0Vals[tradeId].CheapestToDeliver; var pnlConvexity = 0.0; var bondMktData = t0Mkt.BondPrices[ctdId]; if (bondMktData != null) { var ctdCleanPriceT0 = bondMktData.CleanPrice; var ctdInfo = bondFut.DeliverableBondInfos.Where(x => x.BondId == ctdId).First(); var ctdResultT0 = XlUdf.BondEngineCalc(ctdId, t0Mkt.ReferenceDate.ToString(), PriceQuoteType.Clean, ctdCleanPriceT0, PricingRequest.DirtyPrice, fixedBond: ctdInfo) as PricingResult; pnlConvexity = 0.5 * Math.Pow(t1Vals[tradeId].Ytm - t0Vals[tradeId].Ytm, 2.0) * t0Vals[tradeId].DollarConvexity / 100.0; } //time pnl from CTD var timePnL = t0ValsRolledForward[tradeId].UnderlyingPv - t0Vals[tradeId].UnderlyingPv; var pnl = new BondFuturesPnLResult(tPv, t1Pv, pnlPv01: pnlPv01, pnlZspread: zspreadPnl, pnlBasis: basisPnL, pnlTime: timePnL, pnlConvexity: pnlConvexity, curveRisks: null); ret[tradeId] = pnl; } if (tradeInfo is VanillaOptionInfo || tradeInfo is BinaryOptionInfo || GetTrade(tradeId) is BarrierOptionInfo || tradeInfo is AsianOptionInfo) { OptionValuationParameters valuationParameters = null; Date exerciseDate = null; double strike = 0.0; var trade = tradeInfo as OptionInfoBase; valuationParameters = trade.ValuationParamter; TradeUtil.GenerateOptionDates(trade, out Date[] exerciseDates, out Date[] obsDates, out DayGap settlementGap);
/// <summary> /// Add rate market data definition to an existing market. /// </summary> /// <param name="marketName">The Existing Market Name</param> /// <param name="curveName">The curve name</param> /// <param name="indexType">The index type(enum IndexType)</param> /// <param name="instrumentType">The InstrumentType(enum InstrumentType)</param> /// <param name="tenor">The curve rate tenor</param> /// <param name="rate">The rate value</param> /// <param name="isOverride">if true, then add or override. if false, then ignore(default true)</param> /// <returns>if succeeded, return true. if failed, return error message : "Market {market object name} is not available!"</returns> public static object xl_MktAddRateData(string marketName, string curveName, string indexType, string instrumentType, string tenor, double rate, bool isOverride = true) { var marketData = new RateMktData(tenor, rate, indexType, instrumentType, curveName); return(XlManager.MergeMarketInfo(marketName, marketData, isOverride)); }
/// <summary> /// Add bondfutures market data definition to an existing market. /// </summary> /// <param name="marketName">The Existing Market Name</param> /// <param name="tfId">The Bond futures Id</param> /// <param name="quote">The quote of bond futures price</param> /// <param name="isOverride">if true, then add or override. if false, then ignore(default true)</param> /// <returns>if succeeded, return true. if failed, return error message : "Market {market object name} is not available!"</returns> public static object xl_MktAddFuturesData(string marketName, string tfId, double quote, bool isOverride = true) { var marketData = new FuturesMktData(tfId, quote); return(XlManager.MergeMarketInfo(marketName, marketData, isOverride)); }
/// <summary> /// Add bond market data definition to an existing market. /// </summary> /// <param name="marketName">The Existing Market Name</param> /// <param name="bondId">The Bond Id</param> /// <param name="quoteType">The Price quote type(Clean, Dirty, Ytm, YtmExecution)</param> /// <param name="quote">The quote of bond</param> /// <param name="isOverride">if true, then add or override. if false, then ignore(default true)</param> /// <returns>if succeeded, return true. if failed, return error message : "Market {market object name} is not available!"</returns> public static object xl_MktAddBondData(string marketName, string bondId, string quoteType, double quote, bool isOverride = true) { var marketData = new BondMktData(bondId, quoteType, quote); return(XlManager.MergeMarketInfo(marketName, marketData, isOverride)); }
/// <summary> /// Convert tow column array {label, value} paris to TradeInfo. /// </summary> /// <param name="labelValue">Label value pairs.</param> /// <returns>Return a QDP trade info object given two column array of {label, value} pairs.</returns> public static TradeInfoBase ToTradeInfoBase(this object[,] labelValue) { var row = labelValue.GetLength(0); var col = labelValue.GetLength(1); var deliverableBondIds = new List <string>(); var instrumentType = InstrumentType.None; for (var i = 0; i < row; ++i) { if ((string)labelValue[i, 0] == "InstrumentType") { instrumentType = ((string)labelValue[i, 1]).ToInstrumentType(); } //if ((string) labelValue[i, 0] == "DeliverableBondInfos") //{ // deliverableBondIds.AddRange(labelValue[i, 1] != null ? ((string)labelValue[i, 1]).Split(',').ToList() : null); //} } if (instrumentType == InstrumentType.BondFutures) { var tf = labelValue.TransposeRowsAndColumns().ToArrayObj <BondFuturesInfo>().Single(); tf.DeliverableBondInfos = deliverableBondIds.Select(x => (FixedRateBondInfo)XlManager.GetTrade(x)).ToArray(); return(tf); } if (instrumentType == InstrumentType.InterestRateSwap) { return(labelValue.TransposeRowsAndColumns().ToArrayObj <InterestRateSwapInfo>().Single()); } if (instrumentType == InstrumentType.FixedRateBond) { return(labelValue.TransposeRowsAndColumns().ToArrayObj <FixedRateBondInfo>().Single()); } if (instrumentType == InstrumentType.FloatingRateBond) { return(labelValue.TransposeRowsAndColumns().ToArrayObj <FloatingRateBondInfo>().Single()); } if (instrumentType == InstrumentType.FixedDateCouonAdjustedBond) { return(labelValue.TransposeRowsAndColumns().ToArrayObj <FixedDateCouonAdjustedBondInfo>().Single()); } return(null); }
/// <summary> /// Return a interest rate swap. /// </summary> /// <param name="tradeId"></param> /// <param name="startDate"></param> /// <param name="maturityDate"></param> /// <param name="tenor"></param> /// <param name="notional"></param> /// <param name="currency"></param> /// <param name="swapDirection"></param> /// <param name="calendar"></param> /// <param name="fixedLegDayCount"></param> /// <param name="fixedLegFrequency"></param> /// <param name="fixedLegBusinessDayConvention"></param> /// <param name="fixedLegStub"></param> /// <param name="fixedLegCoupon"></param> /// <param name="floatingLegDayCount"></param> /// <param name="floatingLegFrequency"></param> /// <param name="floatingLegBusinessDayConvention"></param> /// <param name="floatingLegStub"></param> /// <param name="index"></param> /// <param name="resetTerm"></param> /// <param name="resetStub"></param> /// <param name="resetBusinessDayConvention"></param> /// <param name="resetToFixingGap"></param> /// <param name="resetCompound"></param> /// <returns></returns> public static object xl_InterestRateSwap(string tradeId , string startDate = null , string maturityDate = null , string tenor = "1Y" , double notional = 100.0 , string currency = "CNY" , string swapDirection = "Payer" , string calendar = "chn_ib" , string fixedLegDayCount = "Act365" , string fixedLegFrequency = "Quarterly" , string fixedLegBusinessDayConvention = "ModifiedFollowing" , string fixedLegStub = "ShortEnd" , double fixedLegCoupon = 0.03 , string floatingLegDayCount = "Act365" , string floatingLegFrequency = "Quarterly" , string floatingLegBusinessDayConvention = "ModifiedFollowing" , string floatingLegStub = "ShortEnd" , string index = "Fr007" , string resetTerm = "1W" , string resetStub = "ShortEnd" , string resetBusinessDayConvention = "None" , string resetToFixingGap = "+1BD" , string resetCompound = "Compounded" ) { var interestRateSwapInfo = XlManager.GetTrade(tradeId); if (!(interestRateSwapInfo is InterestRateSwapInfo)) { startDate = startDate ?? DateTime.Now.ToString("yyyy-MM-dd"); if (maturityDate == null && tenor != null) { maturityDate = new Term(tenor).Next(startDate.ToDate()).ToString(); } else { maturityDate = maturityDate ?? new Term("1Y").Next(startDate.ToDate()).ToString(); } string curveName = ""; switch (index) { case "Fr007": curveName = "Fr007SwapCurve"; break; case "Shibor3M": curveName = "Shibor3MSwapCurve"; break; case "Shibor1D": curveName = "ShiborONSwapCurve"; break; case "Depo1Y": curveName = "Depo1YSwapCurve"; break; } interestRateSwapInfo = new InterestRateSwapInfo(tradeId) { StartDate = startDate, MaturityDate = maturityDate, Tenor = tenor, Notional = notional, Currency = currency, SwapDirection = swapDirection, Calendar = calendar, FixedLegDC = fixedLegDayCount, FixedLegFreq = fixedLegFrequency, FixedLegBD = fixedLegBusinessDayConvention, FixedLegStub = fixedLegStub, FixedLegCoupon = fixedLegCoupon, FloatingLegDC = floatingLegDayCount, FloatingLegFreq = floatingLegFrequency, FloatingLegBD = floatingLegBusinessDayConvention, FloatingLegStub = floatingLegStub, Index = index, ResetTerm = resetTerm, ResetStub = resetStub, ResetBD = resetBusinessDayConvention, ResetToFixingGap = resetToFixingGap, ResetCompound = resetCompound, ValuationParamters = new SimpleCfValuationParameters(curveName, curveName, null) }; XlManager.AddTrades(new[] { interestRateSwapInfo }); } return(interestRateSwapInfo.ToTradeInfoInLabelData(null)); }
public static object BondEngineCalc(string bondId, string calcDate, PriceQuoteType priceQuote, double quote, PricingRequest request, FixedRateBondInfo fixedBond = null) { var bond = fixedBond ?? XlManager.GetTrade(bondId); if (bond == null) { return(string.Format("Cannot find bond {0}.", bondId)); } var vf = new BondVf((BondInfoBase)bond); var bondInstrument = vf.GenerateInstrument(); var valueDate = calcDate.ToDate(); var fixingCurve = new YieldCurve( "中债国债收收益率曲线", valueDate, new[] { new Tuple <Date, double>(valueDate, 0.0), new Tuple <Date, double>(new Term("10Y").Next(valueDate), 0.0) }, BusinessDayConvention.ModifiedFollowing, new Act365(), CalendarImpl.Get("Chn_ib"), CurrencyCode.CNY, Compound.Continuous, Interpolation.ForwardFlat, YieldCurveTrait.ForwardCurve ); var market = new MarketCondition( x => x.ValuationDate.Value = valueDate, x => x.FixingCurve.Value = fixingCurve, x => x.MktQuote.Value = new Dictionary <string, Tuple <PriceQuoteType, double> > { { bondId, Tuple.Create(priceQuote, quote) } }, x => x.HistoricalIndexRates.Value = HistoricalIndexRates ); if (bond is FloatingRateBondInfo) { var fixingTuple = bondInstrument.Coupon.GetPrimeCoupon(HistoricalIndexRates, fixingCurve, valueDate); var keyTenors = new string[fixingCurve.GetKeyTenors().Length]; fixingCurve.GetKeyTenors().CopyTo(keyTenors, 0); for (var i = 0; i < keyTenors.Length; ++i) { market = (MarketCondition)market.UpdateCondition(new UpdateMktConditionPack <IYieldCurve>(x => x.FixingCurve, market.FixingCurve.Value.BumpKeyRate(i, fixingTuple.Item2))); } if (request.Equals(PricingRequest.None)) { return(fixingTuple); } } var engine = vf.GenerateEngine(); var result = engine.Calculate(bondInstrument, market, request); if (!result.Succeeded) { return(string.Format("Failed to Calculate bond {0}:{1}", bondId, result.ErrorMessage)); } return(result); }
/// <summary> /// Return QDP bond qdp object. /// </summary> /// <param name="tradeId"></param> /// <param name="startDate"></param> /// <param name="maturityDate"></param> /// <param name="notional"></param> /// <param name="calendar"></param> /// <param name="currency"></param> /// <param name="accrualDayCount"></param> /// <param name="accrualBusinessDayConvention"></param> /// <param name="paymentDayCount"></param> /// <param name="paymentFrequency"></param> /// <param name="paymentStub"></param> /// <param name="paymentBusinessDayConvention"></param> /// <param name="settlement"></param> /// <param name="settlementCoupon"></param> /// <param name="issuePrice"></param> /// <param name="firstPaymentDate"></param> /// <param name="issueRate"></param> /// <param name="amoritzationInIndex"></param> /// <param name="renormalizeAfterAmoritzation"></param> /// <param name="compensationRate"></param> /// <param name="optionToCall"></param> /// <param name="optionToPut"></param> /// <param name="optionToAssPut"></param> /// <param name="fixedCoupon"></param> /// <param name="index"></param> /// <param name="resetDayCount"></param> /// <param name="resetCompound"></param> /// <param name="resetStub"></param> /// <param name="resetBusinessDayConvention"></param> /// <param name="resetToFixingGap"></param> /// <param name="resetTerm"></param> /// <param name="resetAverageDays"></param> /// <param name="resetRateDigits"></param> /// <param name="spread"></param> /// <param name="floatingRateMultiplier"></param> /// <param name="stickToEom"></param> /// <returns></returns> private static object xl_Bond( string tradeId, string startDate = null, string maturityDate = null, double notional = 100, string calendar = "chn_ib", string currency = "CNY", string accrualDayCount = "Act365", string accrualBusinessDayConvention = "ModifiedFollowing", string paymentDayCount = "Act365", string paymentFrequency = "SemiAnnual", string paymentStub = "ShortStart", string paymentBusinessDayConvention = "ModifiedFollowing", string settlement = "+0D", double settlementCoupon = double.NaN, double issuePrice = double.NaN, string firstPaymentDate = null, double issueRate = double.NaN, Dictionary <int, double> amoritzationInIndex = null, bool renormalizeAfterAmoritzation = false, Dictionary <int, double> compensationRate = null, Dictionary <string, double> optionToCall = null, Dictionary <string, double> optionToPut = null, Dictionary <string, double> optionToAssPut = null, double fixedCoupon = double.NaN, string index = null, string resetDayCount = null, string resetCompound = null, string resetStub = null, string resetBusinessDayConvention = null, string resetToFixingGap = null, string resetTerm = null, int resetAverageDays = 1, int resetRateDigits = 12, double spread = double.NaN, double floatingRateMultiplier = double.NaN, bool stickToEom = false) { var tradeInfo = XlManager.GetTrade(tradeId); if (!(tradeInfo is BondInfoBase)) { startDate = startDate ?? DateTime.Now.ToString("yyyy-MM-dd"); maturityDate = maturityDate ?? new Term("1Y").Next(startDate.ToDate()).ToString(); BondInfoBase bondInfo = null; if (string.IsNullOrWhiteSpace(index)) { bondInfo = new FixedRateBondInfo(tradeId) { FixedCoupon = double.IsNaN(fixedCoupon) ? 0.03 : fixedCoupon }; } else { bondInfo = new FloatingRateBondInfo(tradeId) { Index = index ?? "Shibor3M", ResetDC = resetDayCount ?? "Act365", ResetCompound = resetCompound ?? "Simple", ResetStub = resetStub ?? "ShortStart", ResetBD = resetBusinessDayConvention ?? "ModifiedFollowing", ResetToFixingGap = resetToFixingGap ?? "-1BD", ResetTerm = resetTerm ?? "3M", Spread = double.IsNaN(spread) ? 0.0 : spread, ResetAverageDays = resetAverageDays, ResetRateDigits = resetRateDigits, FloatingRateMultiplier = double.IsNaN(floatingRateMultiplier) ? 1.0 : floatingRateMultiplier, FloatingCalc = "ZzFrn", CapRate = 100, FloorRate = -100 }; } bondInfo.StartDate = startDate; bondInfo.MaturityDate = maturityDate; bondInfo.Calendar = calendar; bondInfo.PaymentFreq = paymentFrequency; bondInfo.StickToEom = stickToEom; bondInfo.PaymentStub = paymentStub; bondInfo.Notional = notional; bondInfo.Currency = currency; bondInfo.AccrualDC = accrualDayCount; bondInfo.DayCount = paymentDayCount; bondInfo.AccrualBD = accrualBusinessDayConvention; bondInfo.PaymentBD = paymentBusinessDayConvention; bondInfo.Settlement = settlement; bondInfo.SettlementCoupon = settlementCoupon; bondInfo.TradingMarket = calendar == "chn_ib" ? TradingMarket.ChinaInterBank.ToString() : TradingMarket.ChinaExShe.ToString(); bondInfo.IsZeroCouponBond = !double.IsNaN(issuePrice); bondInfo.IssuePrice = issuePrice; bondInfo.FirstPaymentDate = firstPaymentDate; bondInfo.AmortizationType = "None"; bondInfo.AmoritzationInIndex = amoritzationInIndex; bondInfo.RenormAmortization = renormalizeAfterAmoritzation; bondInfo.CompensationRate = compensationRate; bondInfo.IssueRate = issueRate; bondInfo.OptionToCall = optionToCall; bondInfo.OptionToPut = optionToPut; bondInfo.OptionToAssPut = optionToAssPut; bondInfo.ValuationParamters = new SimpleCfValuationParameters("中债国债收益率曲线", "", "中债国债收益率曲线"); XlManager.AddTrades(new[] { bondInfo }); tradeInfo = bondInfo; } return(tradeInfo.ToTradeInfoInLabelData(null)); }