/// <summary> /// Prepare for valuation anything that is not dependent upon the scenario. /// </summary> public override void PreCloneInitialize(PriceFactorList Factors, BaseTimeGrid BaseTimes, RequiredResults ResultsRequired) { base.PreCloneInitialize(Factors, BaseTimes, ResultsRequired); DealCreditLinkedNoteBase deal = (DealCreditLinkedNoteBase)fDeal; DateGenerationRequest dateGenerationRequest = new DateGenerationRequest { RequiresPayDates = true, RequiresResetDates = true, RequiresYearFractions = true, }; DateGenerationParams dateGenerationParams = new DateGenerationParams { EffectiveDate = deal.Effective_Date, MaturityDate = deal.Maturity_Date, CouponPeriod = deal.Coupon_Interval, AccrualCalendar = deal.GetHolidayCalendar(), AccrualDayCount = deal.Accrual_Day_Count, }; DateGenerationResults dateGenerationResults = CashflowGeneration.GenerateCashflowDateAndValueLists(dateGenerationRequest, dateGenerationParams); PayDates = dateGenerationResults.PayDates; Accruals = dateGenerationResults.AccrualYearFractions; ResetDates = dateGenerationResults.ResetDates; // Add to valuation time grid bool cashRequired = ResultsRequired.CashRequired(); fT.AddPayDate(deal.Effective_Date, cashRequired); fT.AddPayDates(PayDates, cashRequired); }
/// <summary> /// Vector valuation function. /// </summary> public override void Value(ValuationResults valuationResults, PriceFactorList factors, BaseTimeGrid baseTimes) { PreValue(factors); TimeGridIterator tgi = new TimeGridIterator(fT); PVProfiles result = valuationResults.Profile; CashAccumulators accumulator = valuationResults.Cash; DealCreditLinkedNoteBase deal = (DealCreditLinkedNoteBase)fDeal; ISurvivalProb SP = GetSurvivalProbability(factors); RecoveryRate RR = GetRecoveryRate(factors); CreditRating CR = GetCreditRating(factors); double tEffective = CalcUtils.DaysToYears(deal.Effective_Date - factors.BaseDate); double scale = (deal.Buy_Sell == BuySell.Buy) ? +deal.Notional_Amount : -deal.Notional_Amount; double purchasePrice = Percentage.PercentagePoint * deal.Price; double couponRate = (deal.Coupon_Type == InterestRateType.Fixed) ? Percentage.PercentagePoint * deal.Coupon_Rate : 0.0; double couponSpread = (deal.Coupon_Type == InterestRateType.Fixed) ? 0.0 : BasisPoint.BasisPointValue * deal.Coupon_Spread; double indexTenor = (deal.Index_Tenor > 0.0) ? deal.Index_Tenor : deal.Coupon_Interval; using (var cache = Vector.Cache(factors.NumScenarios)) { bool[] hasDefaulted = (Respect_Default == YesNo.Yes) ? new bool[factors.NumScenarios] : null; Vector defaultTime = (Respect_Default == YesNo.Yes) ? cache.Get() : null; Vector historicalRecovery = (Respect_Default == YesNo.Yes) ? cache.GetClear() : null; if (hasDefaulted != null && CR != null) { DefaultTime(defaultTime, CR); } Vector npv = cache.Get(); Vector cash = cache.Get(); Vector pStart = cache.Get(); Vector pEnd = cache.Get(); Vector amount = cache.Get(); Vector recovery = cache.Get(); Vector dfLast = cache.Get(); Vector df = cache.Get(); cash.Clear(); var defaultedBeforeTheBaseDate = Respect_Default == YesNo.Yes && CreditRating.DefaultedBeforeBaseDate(CR, factors.BaseDate); while (tgi.Next()) { if (defaultedBeforeTheBaseDate) { npv.Clear(); result.AppendVector(tgi.Date, npv); break; } if (!deal.Principal_Guaranteed && Respect_Default == YesNo.Yes) { RealizedRecoveryRate(recovery, RR, tgi.T); } // Assume defaults are rare and start by valuing under all scenarios without realized defaults // Value of principal repayment SurvivalProbability(pEnd, factors, SP, tgi.T, fT.fLast); fDiscountRate.GetValue(dfLast, tgi.T, fT.fLast); if (deal.Principal_Guaranteed) { npv.Assign(dfLast); } else { npv.Assign(dfLast * pEnd); } if (accumulator != null && tgi.T == fT.fLast) { cash.Assign(npv); } // Value of coupons for (int i = PayDates.Count - 1; i >= 0 && tgi.Date <= PayDates[i]; --i) { double tPay = CalcUtils.DaysToYears(PayDates[i] - factors.BaseDate); double tReset = CalcUtils.DaysToYears(ResetDates[i] - factors.BaseDate); double tPrevious = Math.Max(tgi.T, tReset); SurvivalProbability(pStart, factors, SP, tgi.T, tPrevious); if (deal.Coupon_Type == InterestRateType.Floating) { // Forecast a coupon, add the spread InterestRateUtils.LiborRate(amount, fForecastRate, tgi.T, tReset, tReset, tReset + indexTenor, deal.Index_Day_Count); amount.Add(couponSpread); amount.MultiplyBy(Accruals[i]); } else { // Fixed coupon amount.Assign(couponRate * Accruals[i]); } // The value of the coupon if no default npv.Add(amount * fDiscountRate.Get(tgi.T, tPay) * pEnd); if (accumulator != null && tgi.T == tPay) { cash.Assign(amount); } // The recovery value on default - assume guaranteed principal paid at end, recovery paid immediately if (!deal.Principal_Guaranteed) { npv.Add(fDiscountRate.Get(tgi.T, 0.5 * (tPay + tPrevious)) * (pStart - pEnd) * PricingRecoveryRate(SP)); } pEnd.DestructiveAssign(pStart); } // Now check for realized default scenario by scenario, overwriting NPV and cash as appropriate if (Respect_Default == YesNo.Yes && defaultTime != null) { if (tgi.T < tEffective) { fDiscountRate.GetValue(df, tgi.T, tEffective); } for (int i = 0; i < npv.Count; ++i) { if (defaultTime[i] > tgi.T) { continue; } if (deal.Principal_Guaranteed) { npv[i] = dfLast[i]; // full principal paid at maturity } else { if (!hasDefaulted[i]) { historicalRecovery[i] = recovery[i]; // record the historical recovery rate } if (tgi.T < tEffective) { npv[i] = df[i] * historicalRecovery[i]; // The discounted recovery value of the principal will be paid out on the effective date } else if (tgi.T == tEffective || !hasDefaulted[i]) { npv[i] = historicalRecovery[i]; // The full recovery amount is paid out } else { npv[i] = 0.0; // default is in the past but we are after effective date; settlement has already occurred. } } hasDefaulted[i] = true; } } // Value of purchase price if (tgi.T < tEffective) { npv.Add(-purchasePrice * fDiscountRate.Get(tgi.T, tEffective)); } else if (tgi.T == tEffective) { npv.Add(-purchasePrice); if (accumulator != null) { cash.Add(-purchasePrice); } } result.AppendVector(tgi.Date, scale * npv * fFxRate.Get(tgi.T)); if (accumulator != null) { accumulator.Accumulate(fFxRate, tgi.Date, scale * cash); } } // After maturity result.Complete(fT); } }