/// <summary> /// Generate CTD dates and set CTD coupon rate and conversion factor. /// </summary> protected void GenerateCTD(double baseDate, double issueDate, double maturityDate, double couponInterval, double firstCouponDate, double penultimateCouponDate, DayCount dayCount, IHolidayCalendar calendar, double couponRate, double conversionFactor) { if (conversionFactor <= 0.0) { return; // No CTD details or details invalid } BondFutureOption deal = (BondFutureOption)fDeal; // Validation of settlement date not done for CTD details on price factor if (deal.Settlement_Date >= maturityDate) { throw new AnalyticsException("Settlement date must be before cheapest-to-deliver maturity date."); } DateGenerationResults dateGenerationResults = deal.GetDateGenerationResults(issueDate, maturityDate, couponInterval, firstCouponDate, penultimateCouponDate, dayCount, calendar); fPayDates = dateGenerationResults.PayDates; fAccruals = dateGenerationResults.AccrualYearFractions; fIssueDate = issueDate; fMaturityDate = maturityDate; fCouponInterval = couponInterval; fCouponRate = couponRate; fConversionFactor = conversionFactor; fAccrual = PricingFunctions.AccruedInterest(deal.Settlement_Date, fIssueDate, fPayDates, fAccruals, fCouponRate, 1.0, null); double strike = PriceTransform(deal.Strike); double tSettle = CalcUtils.DaysToYears(deal.Settlement_Date - baseDate); double tMaturity = CalcUtils.DaysToYears(fMaturityDate - baseDate); fStrikeYield = PricingFunctions.BondYieldFromPrice(tSettle, tMaturity, couponRate, couponInterval, strike); }
/// <summary> /// Calculate valuation profiles. /// </summary> public override void Value(ValuationResults valuationResults, PriceFactorList factors, BaseTimeGrid baseTimes) { PreValue(factors); TimeGridIterator tgi = new TimeGridIterator(fT); PVProfiles result = valuationResults.Profile; CashAccumulators cashAccumulators = valuationResults.Cash; BaseCliquetOption deal = (BaseCliquetOption)Deal; double scale = (deal.Buy_Sell == BuySell.Buy ? +1 : -1) * deal.GetUnits(); VectorEngine.For(tgi, () => { using (var cache = Vector.Cache(factors.NumScenarios)) { Vector pv = cache.Get(); Vector cash = cache.Get(); PricingFunctions.CliquetOption(pv, cash, deal.Option_Type, tgi.T, fTimes, deal.Moneyness, fKnownPrices, fAssetPrice, fFxRate, fPayoffFxRate, fDiscountRate, fAssetPriceVol, fQuantoCompo, fPayoffType, factors.PathDependent); cashAccumulators.Accumulate(fPayoffFxRate, tgi.Date, scale * cash); result.AppendVector(tgi.Date, scale * pv * fPayoffFxRate.Get(tgi.T)); } } ); result.Complete(fT); }
/// <summary> /// Adds the cap or floor option value. /// </summary> private static void AddOptionValue(Vector amount, OptionType optionType, Vector rate, double strike, Vector stdDev, double tau, double multiplier) { if (multiplier != 0.0 && tau > 0.0) { double optionStrike = 1.0 + tau * strike; amount.AddProduct(multiplier / tau, PricingFunctions.BlackFunction(optionType, rate, optionStrike, stdDev)); } }
/// <summary> /// Returns bond option's dirty strike. /// </summary> public double DirtyStrike(double strikePrice, DateList payDates, double[] accruals) { var strike = Percentage.PercentagePoint * strikePrice; if (Strike_Is_Clean == YesNo.Yes) { strike += PricingFunctions.AccruedInterest(Expiry_Date, Issue_Date, payDates, accruals, Percentage.PercentagePoint * Coupon_Rate, 1, null); } return(strike); }
/// <summary> /// Bond price at valuation date. /// </summary> protected override void SecurityPrice(Vector price, double baseDate, double valueDate) { var deal = (BondLendingBase)fDeal; if (deal.Notional == 0.0) { price.Clear(); return; } double accrual; double cash; PricingFunctions.BondPrice(price, out accrual, out cash, baseDate, valueDate, valueDate, deal.Issue_Date, deal.Bond_Maturity_Date, deal.Notional, Percentage.PercentagePoint * deal.Coupon_Rate, fPayDates, fAccruals, fDiscountRate, deal.Amortisation, fPrincipals, fFinalPrincipal, fSurvivalProb, 1.0); price.MultiplyBy(1.0 / deal.Notional); }
/// <inheritdoc /> protected override void ForwardPrice(double baseDate, double valueDate, Vector forwardPrice) { BondFuture deal = (BondFuture)fDeal; double t = CalcUtils.DaysToYears(valueDate - baseDate); double tSettle = CalcUtils.DaysToYears(deal.Settlement_Date - baseDate); double accrual, cash; PricingFunctions.BondPrice(forwardPrice, out accrual, out cash, baseDate, valueDate, deal.Settlement_Date, fIssueDate, fMaturityDate, 1.0, fCouponRate, fPayDates, fAccruals, fDiscountRate, null, null, 0.0, fSurvivalProb, 1.0); AdjustForDefault(baseDate, valueDate, forwardPrice, deal.Expiry_Date, Respect_Default == YesNo.Yes && !string.IsNullOrEmpty(deal.Issuer), fUnderlyingIsAlive, fHistoricalRecovery, fDefaultTime, fDiscountRate, fRecoveryRate); // If deal.Repo_Rate is null or empty then fRepoRate will default to the DiscountRate forwardPrice.Assign(Percentage.OverPercentagePoint * ((forwardPrice / fRepoRate.Get(t, tSettle) - accrual)) / fConversionFactor); }
/// <summary> /// Calculates the PV using analytic formula if at least one scenario needs it. /// </summary> private void CalculateAnalyticPV(Vector analyticPv, Vector isUnique, Vector[] stdDev, Vector yStar, Vector[] coefficient, Vector[] coupon, Vector dfTExpiry, Vector[] df) { if (isUnique.MaxElement() == 1.0) { OptionType optionType = fSwaptionDeal.Payer_Receiver == PayerReceiver.Payer ? OptionType.Call : OptionType.Put; // Value by summing the of the caplets or floorlets analyticPv.Clear(); using (var cache = Vector.CacheLike(yStar)) { // f_i(y*) plays the role of price and dfTPay[i] the strike. Vector optionletPrice = cache.Get(); VectorEngine.For(0, stdDev.Length, i => { // Performs optionletPrice = dfExpiry * fCoefficient[i] * Exp(-stdDev[i] * yStar) optionletPrice.Assign(CalcUtils.SafeExpMultiply(-stdDev[i] * yStar, coefficient[i] * dfTExpiry)); analyticPv.Add(coupon[i] * PricingFunctions.BlackFunction(optionType, optionletPrice, df[i], stdDev[i])); return(LoopAction.Continue); }); } } }
/// <summary> /// Calculate forward price, discount factor and volatility /// </summary> protected override void PriceAndVolatility(double baseDate, double valueDate, Vector forwardPrice, Vector discountFactor, Vector volatility) { BondFutureOption deal = (BondFutureOption)fDeal; double t = CalcUtils.DaysToYears(valueDate - baseDate); double tSettle = CalcUtils.DaysToYears(deal.Settlement_Date - baseDate); double tMaturity = CalcUtils.DaysToYears(fMaturityDate - baseDate); fDiscountRate.GetValue(discountFactor, t, tSettle); if (volatility != null) { double tExpiry = deal.GetTimeToExpiry(baseDate); if (tExpiry > t) { // Calculate price volatility using (var cache = Vector.CacheLike(forwardPrice)) { Vector macaulayDuration = cache.Get(); Vector yield = cache.Get(); Vector yieldStrike = cache.Get(fStrikeYield); // Calculate forwrad price, yield and adjusted duration using simple bond price functions PricingFunctions.BondForwardPriceAndAdjustedMacaulayDuration(forwardPrice, macaulayDuration, t, tSettle, tMaturity, fCouponRate, fCouponInterval, discountFactor, fDiscountRate, fSurvivalProb); PricingFunctions.BondYieldFromPrice(yield, tSettle, tMaturity, fCouponRate, fCouponInterval, forwardPrice); // Calculate Modified Duration from Macaulay Duration. Vector modifiedDuration = cache.Get(); PricingFunctions.GetModifiedDuration(modifiedDuration, macaulayDuration, yield, fCouponInterval); // Get yield volatility fInterestYieldVol.GetValue(volatility, t, yield, yieldStrike, tExpiry, tMaturity - tSettle); // Convert (normal) yield vol to lognormal price vol volatility.MultiplyBy(modifiedDuration); if (fInterestYieldVol.GetDistributionType() == ProbabilityDistribution.Lognormal) { // Convert lognormal yield vol to lognormal price vol. volatility.MultiplyBy(yield); } } } else { volatility.Clear(); } } // Recalculate forward price using fAccruals double accrual, cash; PricingFunctions.BondPrice(forwardPrice, out accrual, out cash, baseDate, valueDate, deal.Settlement_Date, fIssueDate, fMaturityDate, 1.0, fCouponRate, fPayDates, fAccruals, fDiscountRate, null, null, 0.0, fSurvivalProb, 1.0); BondFutureValuation.AdjustForDefault(baseDate, valueDate, forwardPrice, deal.Expiry_Date, Respect_Default == YesNo.Yes && !string.IsNullOrEmpty(deal.Issuer), fUnderlyingIsAlive, fHistoricalRecovery, fDefaultTime, fDiscountRate, fRecoveryRate); forwardPrice.AssignQuotient(forwardPrice, discountFactor); if (!fRepoIsDiscount) { fRepoRate.GetValue(discountFactor, t, tSettle); } }
/// <summary> /// Generic Deal Valuation - derived objects override the ValueFn() method. /// </summary> public override void Value(ValuationResults valuationResults, PriceFactorList factors, BaseTimeGrid baseTimes) { PreValue(factors); var deal = (CalendarSpreadOption)Deal; var tgi = new TimeGridIterator(fT); PVProfiles result = valuationResults.Profile; CashAccumulators accumulator = valuationResults.Cash; fTimeToSettlement = CalcUtils.DaysToYears(deal.Settlement_Date - factors.BaseDate); fPeriodEnd1 = CalcUtils.DaysToYears(deal.Period_End_1 - factors.BaseDate); fPeriodEnd2 = CalcUtils.DaysToYears(deal.Period_End_2 - factors.BaseDate); // The time to expiry is the time to the end of the first expiring contract. fTimeToExpiry = CalcUtils.DaysToYears(deal.Period_End_1 - factors.BaseDate); using (var cache = Vector.Cache(factors.NumScenarios)) { EnergySpreadOptionPricer pricer1 = GetEnergyOptionPricer(fForwardSample, fReferencePrice1, fReferenceVol1, factors.BaseDate, fPeriodEnd1, deal.Period_Start_1, deal.Period_End_1, deal.Realized_Average_1, deal.Realized_Average_Date_1, cache); EnergySpreadOptionPricer pricer2 = GetEnergyOptionPricer(fForwardSample, fReferencePrice2, fReferenceVol2, factors.BaseDate, fPeriodEnd2, deal.Period_Start_2, deal.Period_End_2, deal.Realized_Average_2, deal.Realized_Average_Date_2, cache); Vector pv = cache.Get(); Vector realizedPrice1 = cache.Get(); Vector realizedPrice2 = cache.Get(); Vector unrealizedPrice1 = cache.Get(); Vector unrealizedPrice2 = cache.Get(); Vector vol1 = cache.Get(); Vector vol2 = cache.Get(); Vector correlation = cache.Get(); Vector discountFactor = cache.Get(); // Calculate correlation between forward prices for two different (dereferenced) maturities (e.g. Apr2012 and Jan2013). TDate forwardDate1 = fReferencePrice1.GetPriceDate(deal.Period_End_1, 0); TDate forwardDate2 = fReferencePrice2.GetPriceDate(deal.Period_End_2, 0); fCorrelations.GetValue(correlation, tgi.T, forwardDate1, forwardDate2); while (tgi.Next()) { pv.Clear(); if (tgi.T <= fTimeToExpiry) { // Get unrealised reference forward prices (which also age the pricer to time t and update the realized average at time t) pricer1.GetUnrealizedPrice(tgi.T, unrealizedPrice1); pricer2.GetUnrealizedPrice(tgi.T, unrealizedPrice2); // Get the realized averages for both reference prices. pricer1.GetRealizedPrice(realizedPrice1); pricer2.GetRealizedPrice(realizedPrice2); int numSamples1 = pricer1.GetNumSamples(); int numRealizedSamples1 = pricer1.GetNumRealizedSamples(); int numUnrealizedSamples1 = pricer1.GetNumUnrealizedSamples(); int numSamples2 = pricer2.GetNumSamples(); int numRealizedSamples2 = pricer2.GetNumRealizedSamples(); int numUnrealizedSamples2 = pricer2.GetNumUnrealizedSamples(); // Modify the strike Vector kStar = cache.Get(deal.Strike_Price - realizedPrice1 * numRealizedSamples1 / numSamples1 + realizedPrice2 * numRealizedSamples2 / numSamples2); Vector refPriceStar1 = cache.Get(unrealizedPrice1 * numUnrealizedSamples1 / numSamples1); Vector refPriceStar2 = cache.Get(unrealizedPrice2 * numUnrealizedSamples2 / numSamples2); // Get ATM volatilities of the forward price at different maturities (given as time in years with respect to base date). pricer1.GetVol(tgi.T, unrealizedPrice2, vol1); pricer2.GetVol(tgi.T, unrealizedPrice1, vol2); // value is intrinsic - pricing with volatility 0 and realized price if there are no future sample. if (numUnrealizedSamples1 == 0) { vol1.Clear(); } // value is intrinsic - pricing with volatility 0 and realized price if there are no future sample. if (numUnrealizedSamples2 == 0) { vol2.Clear(); } // CSO pricing: exp(-rT) * E{max(F1(T) - F2(T) - K, 0)} // For the European CSO, we set multiplier1 = sign, multiplier2 = -sign, constant = -sign * strike, // where sign = +1 for a call and -1 for a put in the SpreadOptionBS function. double rootTime = Math.Sqrt(fTimeToExpiry - tgi.T); Vector volStar1 = cache.Get(vol1 * rootTime); Vector volStar2 = cache.Get(vol2 * rootTime); PricingFunctions.SpreadOptionBS(pv, fCallPutSign, -fCallPutSign, cache.Get(-fCallPutSign * kStar), fCallPutSign, refPriceStar1, refPriceStar2, kStar, volStar1, volStar2, correlation); // The option itself cannot be worth less than zero (for long positions). // However, due to that the Bjerksund & Stensland is a type of non-optimal exercise, it is possible to end up with negative PV via // its pricing formula. pv.AssignMax(pv, 0.0); // Discount payment made at settlement date pv.MultiplyBy(fScale * fDiscountRate.Get(tgi.T, fTimeToSettlement)); } // Cash settlement at settlement date if (tgi.T == fTimeToSettlement && accumulator != null && !accumulator.Ignore) { accumulator.Accumulate(fFxPayoffRate, tgi.Date, pv); } result.AppendVector(tgi.Date, pv * fFxPayoffRate.Get(tgi.T)); } result.Complete(fT); } }
/// <summary> /// Calculate valuation profiles. /// </summary> public override void Value(ValuationResults valuationResults, PriceFactorList factors, BaseTimeGrid baseTimes) { PreValue(factors); TimeGridIterator tgi = new TimeGridIterator(fT); PVProfiles result = valuationResults.Profile; CashAccumulators cashAccumulators = valuationResults.Cash; BondOptionDeal deal = (BondOptionDeal)Deal; double baseDate = factors.BaseDate; double notional = deal.Notional; double interval = deal.Coupon_Interval; double buySign = (deal.Buy_Sell == BuySell.Buy) ? +1 : -1; double paySign = (deal.Option_Type == OptionType.Call) ? +1 : -1; double coupon = Percentage.PercentagePoint * deal.Coupon_Rate; double tExpiry = CalcUtils.DaysToYears(deal.Expiry_Date - baseDate); double tMaturity = CalcUtils.DaysToYears(deal.Bond_Maturity_Date - baseDate); IInterestYieldVol interestYieldVol = InterestVolBase.GetYieldVol(factors, deal.Yield_Volatility, fCurrency); if ((deal.Amortisation) != null && (deal.Amortisation.Count > 0)) { notional = deal.Amortisation.GetPrincipal(notional, deal.Expiry_Date); } bool respectDefault = Respect_Default == YesNo.Yes && fCreditRating != null; using (IntraValuationDiagnosticsHelper.StartDeal(fIntraValuationDiagnosticsWriter, Deal)) { using (var pricerCache = Vector.Cache(factors.NumScenarios)) { Vector defaultTime = null; Vector bondIsAlive = null; Vector historicalRecovery = null; if (respectDefault) { defaultTime = pricerCache.Get(); bondIsAlive = pricerCache.Get(1.0); historicalRecovery = pricerCache.GetClear(); fCreditRating.DefaultTime(defaultTime); } var defaultedBeforeBaseDate = respectDefault && CreditRating.DefaultedBeforeBaseDate(fCreditRating, baseDate); VectorEngine.For(tgi, () => { using (IntraValuationDiagnosticsHelper.StartValuation(fIntraValuationDiagnosticsWriter, tgi.Date)) { using (var cache = Vector.Cache(factors.NumScenarios)) { Vector optionValue = cache.GetClear(); Vector stdDev = cache.Get(); // Std.Dev of Price Vector stdDevYield = cache.Get(); //Std.Dev of Yield Vector price = cache.Get(); Vector yield = cache.Get(); Vector macaulayDuration = cache.Get(); Vector bondValue = cache.Get(); Vector df = cache.Get(); Vector dfr = fRepoIsDiscount ? null : cache.Get(); if (defaultedBeforeBaseDate) { result.AppendVector(tgi.Date, optionValue); return(LoopAction.Break); } // This BondPrice function returns the value of the bond cashflows after ExpiryDate, including accrual, discounted back to T.date double accrual, cash; PricingFunctions.BondPrice(bondValue, out accrual, out cash, baseDate, tgi.Date, deal.Expiry_Date, deal.Issue_Date, deal.Bond_Maturity_Date, notional, coupon, fPayDates, fAccruals, fDiscountRate, deal.Amortisation, fPrincipals, fFinalPrincipal, fSurvivalProb, +1.0); // Now check scenario by scenario for defaults, overwriting bondValue as necessary if (respectDefault) { AdjustBondValueForDefault(notional, tExpiry, bondValue, bondIsAlive, historicalRecovery, defaultTime, tgi.T, fDiscountRate, fRecoveryRate); } // convert price and duration to forward (tExpiry) basis if (tgi.Date == deal.Expiry_Date) { optionValue.Assign(buySign * VectorMath.Max(0.0, paySign * (bondValue - notional * fStrike))); cashAccumulators.Accumulate(fFxRate, tgi.Date, optionValue); } else { fDiscountRate.GetValue(df, tgi.T, tExpiry); if (fRepoIsDiscount) { dfr = df; } else { fRepoRate.GetValue(dfr, tgi.T, tExpiry); } // Need yield and duration to convert yield vol to price vol. PricingFunctions.BondForwardPriceAndAdjustedMacaulayDuration(price, macaulayDuration, tgi.T, tExpiry, tMaturity, coupon, interval, df, fDiscountRate, fSurvivalProb); PricingFunctions.BondYieldFromPrice(yield, tExpiry, tMaturity, coupon, interval, price); // Calculate Modified Duration from Macaulay Duration. Vector modifiedDuration = cache.GetClear(); PricingFunctions.GetModifiedDuration(modifiedDuration, macaulayDuration, yield, interval); // Calculate Std.Dev of Yield and Price interestYieldVol.GetStdDev(stdDevYield, tgi.T, yield, fStrikeYield, tExpiry, tMaturity - tExpiry); stdDev.Assign(modifiedDuration * stdDevYield); if (interestYieldVol.GetDistributionType() == ProbabilityDistribution.Lognormal) { stdDev.MultiplyBy(yield); } price.AssignQuotient(bondValue, df); PricingFunctions.BlackFunction(optionValue, deal.Option_Type, price, notional * fStrike, stdDev); optionValue.MultiplyBy(buySign * dfr); if (fIntraValuationDiagnosticsWriter.Level > IntraValuationDiagnosticsLevel.None) { // Add Intra-valuation Diagnostics using (var volatilitiesAtDateStore = IntraValuationDiagnosticsHelper.CreateVolatilitiesAtDateStore(fIntraValuationDiagnosticsWriter, factors.NumScenarios)) using (var volatilitiesYieldAtDateStore = IntraValuationDiagnosticsHelper.CreateVolatilitiesAtDateStore(fIntraValuationDiagnosticsWriter, factors.NumScenarios)) { volatilitiesAtDateStore.Add(tgi.Date, tgi.TimeGrid.fEndDate, stdDev); volatilitiesYieldAtDateStore.Add(tgi.Date, tgi.TimeGrid.fEndDate, stdDevYield); IntraValuationDiagnosticsHelper.AddBondOptionProperties(fIntraValuationDiagnosticsWriter, price, dfr, bondValue, accrual, volatilitiesAtDateStore, volatilitiesYieldAtDateStore); IntraValuationDiagnosticsHelper.AddCashflowsPV(fIntraValuationDiagnosticsWriter, optionValue); } } } result.AppendVector(tgi.Date, fFxRate.Get(tgi.T) * optionValue); return(LoopAction.Continue); } } }); } result.Complete(fT); } }
/// <summary> /// Returns the yield implied by strike price. /// </summary> public double GetStrikeYield(ref double strike, double tExpiry, double tMaturity, DateList payDates, double[] accruals) { strike = DirtyStrike(strike, payDates, accruals); return(PricingFunctions.BondYieldFromPrice(tExpiry, tMaturity, Percentage.PercentagePoint * Coupon_Rate, Coupon_Interval, strike)); }