public PriceFactorList Factors; // temporary expedient
/// <summary>
/// Constructor.
/// </summary>
public CDOBottomUpValuationParameters(DealCDO deal, CDOValuationBottomUp valuation, PriceFactorList factors)
: base(deal, factors)
{
Factors = factors;
IndexCDO = factors.Get <IndexCDO>(deal.Reference_Index);
IndexCDO.SetPricer(new CDOPricer(valuation.Number_Of_Loss_Buckets, valuation.Number_Integration_Steps, valuation.Bucket_Type, !CalcUtils.IsTiny(deal.Spread), deal.Payoff_Is_Digital == YesNo.Yes, deal.Digital_Payoff_Percentage));
}
/// <summary>
/// Prepare for valuation anything that will be shared between scenarios.
/// </summary>
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
FixedCashflowDeal deal = (FixedCashflowDeal)fDeal;
fAmount = deal.Amount;
}
/// <summary>
/// Prepare for valuation anything that is dependent upon the scenario.
/// </summary>
public override void PreValue(PriceFactorList factors)
{
base.PreValue(factors);
CommodityFutureOption deal = (CommodityFutureOption)Deal;
deal.GetCommodityDealHelper().PreValueAsset(out fCommodityPrice, out fCommodityPriceVol, factors);
}
/// <summary>
/// Register price factors.
/// </summary>
public override void RegisterFactors(PriceFactorList factors, ErrorList errors)
{
base.RegisterFactors(factors, errors);
CommodityFutureOption deal = (CommodityFutureOption)Deal;
deal.GetCommodityDealHelper().RegisterFactors(factors, errors);
}
/// <inheritdoc />
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
fItems.PreCloneInitialize(factors, baseTimes, requiredResults);
int fixedCount = fFixedCashflowList.Count();
int floatCount = fFloatCashflowList.Count();
fDates = new DateList();
// Get a list of all the relevant dates for the deal.
for (int i = 0; i < fixedCount; i++)
{
var fixedDate = fFixedCashflowList[i].Payment_Date;
fDates.Add(fixedDate);
}
for (int i = 0; i < floatCount; i++)
{
var payDate = fFloatCashflowList[i].Payment_Date;
var startDate = fFloatCashflowList[i].Resets[0].Rate_Start_Date;
if (!fDates.Contains(payDate))
{
fDates.Add(payDate);
}
if (!fDates.Contains(startDate))
{
fDates.Add(startDate);
}
}
int count = fDates.Count;
fFixedCouponWeight = new double[count];
fFixedCouponRate = new double[count];
// Calucate the static parts of the coefficients
foreach (var cf in fFixedCashflowList)
{
int idx = fDates.IndexOf(cf.Payment_Date);
fFixedCouponWeight[idx] += cf.Accrual_Year_Fraction * cf.Notional;
fFixedCouponRate[idx] = cf.Rate;
}
fFloatingCouponWeight = new double[count];
foreach (var cf in fFloatCashflowList)
{
int idx = fDates.IndexOf(cf.Payment_Date);
double rateYearFraction = cf.Resets[0].Rate_Year_Fraction;
double yearFractionRatio = (rateYearFraction < CalcUtils.TINY) ? 1.0 : cf.Accrual_Year_Fraction / rateYearFraction;
fFloatingCouponWeight[idx] += cf.Notional * yearFractionRatio;
}
}
/// <inheritdoc />
public override void HeadNodeInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.HeadNodeInitialize(factors, baseTimes, requiredResults);
CFListBaseDeal <TCashflowList> deal = (CFListBaseDeal <TCashflowList>)fDeal;
fSettlementOffsetHelper.InitialiseHolidayCalendars(factors.CalendarData);
deal.Cashflows.SetCashflowRounding(Cashflow_Rounding);
}
/// <summary>
/// Prepare for valuation anything that is not dependent upon the scenario.
/// </summary>
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
CFFixedListDeal deal = (CFFixedListDeal)Deal;
// Add to valuation time grid
fT.AddPayDates <CFFixed>(deal.Cashflows);
}
/// <summary>
/// Prepare for valuation anything that will be shared between scenarios.
/// </summary>
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
CommodityForwardDealBase deal = (CommodityForwardDealBase)fDeal;
// Add to valuation time grid
fT.AddPayDate(deal.Maturity_Date, requiredResults.CashRequired());
}
/// <inheritdoc />
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults resultsRequired)
{
base.PreCloneInitialize(factors, baseTimes, resultsRequired);
// Add to valuation time grid
fT.AddPayDate(fPaymentDate, resultsRequired.CashRequired());
fCutoffDate = fSettlementOffsetHelper.GetCutoffDate(factors.BaseDate);
}
/// <summary>
/// Prepare for valuation anything that is not dependent upon the scenario.
/// </summary>
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
var deal = (IDIOptionDeal)Deal;
fStrike = deal.StrikeForValuation();
fBaseDate = factors.BaseDate;
}
/// <summary>
/// Prepare for valuation anything that will be shared between scenarios.
/// </summary>
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
FixedCashflowBaseDeal deal = (FixedCashflowBaseDeal)fDeal;
// Add to valuation time grid
fT.AddPayDate(deal.Payment_Date);
}
/// <summary>
/// Register required price factors.
/// </summary>
public override void RegisterFactors(PriceFactorList factors, ErrorList errors)
{
var deal = (CalendarSpreadOption)Deal;
// Register forward price factor - using a reference price.
var referencePrice = factors.RegisterInterface <IReferencePrice>(deal.Reference_Type);
// Register volatility price factor based on an explicit user-defined property.
// Default to Reference Type if Reference Vol Type is not set.
if (string.IsNullOrEmpty(deal.Reference_Vol_Type))
{
factors.Register <ReferenceVol>(deal.Reference_Type);
}
else
{
factors.Register <ReferenceVol>(deal.Reference_Vol_Type);
}
// Register FX rate price factors.
factors.RegisterInterface <IFxRate>(deal.Currency);
factors.RegisterInterface <IFxRate>(deal.DealCurrency());
factors.RegisterInterface <IFxRate>(factors.BaseCcyCode);
factors.RegisterInterface <IFxRate>(referencePrice.DomesticCurrency());
// Register correlation price factor.
factors.Register <ForwardPriceCorrelations>(referencePrice.GetForwardPrice());
// Register forward price sample price factor for reference prices.
var sample = factors.Register <ForwardPriceSample>(deal.Sampling_Type);
if (!string.IsNullOrWhiteSpace(sample.Sampling_Convention))
{
sample.Prepare();
// Validate period 1.
IEnumerable <ContractPeriod> contractPeriods = deal.GetContractPeriods(deal.Period_Start_1, deal.Period_End_1);
sample.ValidateRange(contractPeriods, "Set 1 of sample dates", deal, errors);
// Validate period 2.
contractPeriods = deal.GetContractPeriods(deal.Period_Start_2, deal.Period_End_2);
sample.ValidateRange(contractPeriods, "Set 2 of sample dates", deal, errors);
}
// Register interest rate price factor to get discount factor.
factors.RegisterInterface <IInterestRate>(deal.Currency);
// Register interest rate price factor for discount rate currency.
if (!string.IsNullOrEmpty(deal.Discount_Rate))
{
string discountRateCurrency = factors.RegisterInterface <IInterestRate>(InterestRateUtils.GetRateId(deal.Discount_Rate, deal.Currency)).GetCurrency();
if (!string.IsNullOrEmpty(discountRateCurrency) && discountRateCurrency != deal.Currency)
{
errors.Add(ErrorLevel.Error, "Currency and currency of Discount_Rate must be the same");
}
}
}
/// <summary>
/// Prepare for valuation anything that is not dependent upon the scenario.
/// </summary>
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
var deal = (CFFloatingInterestListDeal)Deal;
// Set up cashflow list
fCashflows.SetUseConvexityCorrection(Convexity_Correction == YesNo.Yes);
fCashflows.SetUseQuantoCorrection(Quanto_Correction == YesNo.Yes);
fCashflows.SetFasterAveraging(Faster_Averaging_Valuation == YesNo.Yes);
fCashflows.SetOISCashflowGroupSize(OIS_Cashflow_Group_Size);
fCashflows.SetConvexityLowRateCutoff(Convexity_Low_Rate_Cutoff);
fCashflows.SetOISRateRounding(OIS_Rate_Rounding);
double baseDate = factors.BaseDate;
fCharacteristics = fCashflows.Analyze(baseDate);
if (fCharacteristics.IsOIS)
{
fCashflows.InitializeFastOISCalculation(baseDate);
}
if (fCharacteristics.IsVanillaSwap)
{
fCashflows.CalculateAmounts(baseDate);
}
// Add to valuation time grid
bool payDatesRequired = ValueOnCashflowDates() && requiredResults.CashRequired();
fT.AddPayDates(fCashflows, payDatesRequired);
double settlementDate = deal.Settlement_Date;
if (settlementDate > 0.0)
{
fT.AddPayDate(settlementDate, payDatesRequired);
}
if (Use_Settlement_Offset == YesNo.Yes && settlementDate != 0.0)
{
fCutoffDate = 0.0;
}
if (deal.Investment_Horizon > 0.0)
{
fT.AddPayDate(deal.Investment_Horizon, payDatesRequired);
}
if (Use_Survival_Probability == YesNo.Yes)
{
fRecoveryList = new CFRecoveryList();
fRecoveryList.PopulateRecoveryCashflowList(baseDate, settlementDate, fCashflows);
}
}
/// <summary>
/// Prepare for valuation anything that will be shared between scenarios.
/// </summary>
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
CFListBaseDeal <TCashflowList> deal = (CFListBaseDeal <TCashflowList>)fDeal;
fBuySellSign = deal.Buy_Sell == BuySell.Buy ? +1 : -1;
fCutoffDate = fSettlementOffsetHelper.GetCutoffDate(factors.BaseDate);
}
/// <inheritdoc />
protected override void GetDefaultTime(Vector defaultTime, PriceFactorList factors)
{
if (fCreditRating != null)
{
fCreditRating.DefaultTime(defaultTime);
return;
}
base.GetDefaultTime(defaultTime, factors);
}
/// <summary>
/// Returns true if the cashflow list consists of vanilla swaplets, caplets and floorlets.
/// </summary>
private bool IsValidCashflowList(PriceFactorList factors, CFFloatingInterestListDeal deal)
{
// Get characteristics using cashflow list from the original deal.
CashflowListCharacteristics characteristics = deal.Cashflows.Analyze(factors.BaseDate);
bool isCompounding = deal.Cashflows.Compounding_Method != CompoundingMethod.None;
return(!fForecastIsForeign &&
characteristics.IsStandardPayoff &&
characteristics.IsStandardLibor &&
!isCompounding);
}
/// <summary>
/// Prepare for valuation anything that will be shared between scenarios.
/// </summary>
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
FixedInterestCashflowDeal deal = (FixedInterestCashflowDeal)fDeal;
int sign = (deal.Buy_Sell == BuySell.Buy ? +1 : -1);
double accrualDayCountFraction = CalcUtils.DayCountFraction(deal.Accrual_Start_Date, deal.Accrual_End_Date, deal.Accrual_Day_Count, deal.GetHolidayCalendar());
fAmount = sign * deal.Notional * accrualDayCountFraction * deal.Fixed_Rate;
}
/// <summary>
/// Register price factors.
/// </summary>
public override void RegisterFactors(PriceFactorList factors, ErrorList errors)
{
var deal = (SwaptionDeal)Deal;
// Get underlying cashflow lists
SwaptionBaseValuation.SetCashflowLists(errors, deal, ref fFixedCashflowList, ref fFloatCashflowList);
if (!IsVanillaSwaption())
{
Deal.AddToErrors(errors, ErrorLevel.Error, "The Hull White swaption valuation model is for vanilla swaptions only.");
}
// Register deal currency
factors.RegisterInterface <IFxRate>(deal.Currency);
// Register discount rate
var discountId = InterestRateUtils.GetRateId(deal.Discount_Rate, deal.Currency);
string discountRateCurrency = DiscountRate.Register(factors, discountId).GetCurrency();
if (!string.IsNullOrEmpty(discountRateCurrency) && discountRateCurrency != deal.Currency)
{
errors.Add(ErrorLevel.Error, "Settlement currency (Currency) and currency of Discount_Rate must be the same");
}
// Register forecast rate
var forecastId = InterestRateUtils.GetRateId(deal.Forecast_Rate, discountId);
var forecastRateCurrency = factors.RegisterInterface <IInterestRate>(forecastId).GetCurrency();
if (forecastRateCurrency != deal.Currency)
{
errors.Add(ErrorLevel.Error, "Settlement currency (Currency) and currency of Forecast_Rate must be the same");
}
// Register the HW model parameters
fModelParametersId = string.IsNullOrWhiteSpace(Model_Parameters) ? forecastId : Model_Parameters;
factors.Register <HullWhite1FactorModelParameters>(fModelParametersId);
// Check that floating cashflow list is standard enough to be valued by ValueSwap
if (fFloatCashflowList == null || fFixedCashflowList == null)
{
errors.Add(ErrorLevel.Error, "Deal must contain exactly one floating and one fixed leg.");
}
else
{
var characteristics = fFloatCashflowList.Analyze(factors.BaseDate);
if (!characteristics.HasSwaplet || characteristics.HasOptionlet ||
!characteristics.IsStandardPayoff || characteristics.HasCms || !characteristics.IsStandardLibor ||
fFloatCashflowList.Compounding_Method != CompoundingMethod.None || fFixedCashflowList.Compounding == YesNo.Yes)
{
errors.Add(ErrorLevel.Error, "Underlying swap has non-standard floating cashflows.");
}
}
}
/// <inheritdoc />
protected override void RegisterFuturesPriceFactor(PriceFactorList factors, ErrorList errors)
{
BondFutureOption deal = (BondFutureOption)fDeal;
BondFuturesBasis bfb = factors.Register <BondFuturesBasis>(FutureBase.GetFactorID(deal.Contract, deal.Settlement_Date));
if (deal.Settlement_Date >= bfb.CTD_Maturity_Date)
{
errors.Add(ErrorLevel.Error, "Settlement date must be before cheapest-to-deliver maturity date of the Bond Future Basis price factor.");
}
}
/// <summary>
/// Prepare for valuation anything that is dependent upon the scenario.
/// </summary>
public override void PreValue(PriceFactorList factors)
{
base.PreValue(factors);
CFFixedInterestListDeal deal = (CFFixedInterestListDeal)fDeal;
// Get factor for translation from rate currency to settlement currency for cashflows with FX reset date
if (!string.IsNullOrEmpty(deal.Rate_Currency) && deal.Rate_Currency != fCurrency)
{
fRateFxRate = factors.GetInterface <IFxRate>(deal.Rate_Currency);
}
}
/// <summary>
/// Register price factors.
/// </summary>
public override void RegisterFactors(PriceFactorList factors, ErrorList errors)
{
base.RegisterFactors(factors, errors);
CFFixedInterestListDeal deal = (CFFixedInterestListDeal)fDeal;
// Register factor for translation from rate currency to settlement currency for cashflows with FX reset date
if (!string.IsNullOrEmpty(deal.Rate_Currency) && deal.Rate_Currency != fCurrency)
{
factors.RegisterInterface <IFxRate>(deal.Rate_Currency);
}
}
/// <summary>
/// Prepare for valuation anything that is not dependent upon the scenario.
/// </summary>
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
var deal = (CalendarSpreadOption)Deal;
fCallPutSign = deal.Option_Type == OptionType.Call ? 1 : -1;
fScale = (deal.Buy_Sell == BuySell.Buy ? +1.0 : -1.0) * deal.Units * deal.Contract_Size;
// Add to valuation time grid
fT.AddPayDate(deal.Settlement_Date, requiredResults.CashRequired());
}
/// <summary>
/// Fetch the recovery rate price factor, or null if not applicable.
/// </summary>
protected override RecoveryRate GetRecoveryRate(PriceFactorList factors)
{
if (Respect_Default == YesNo.Yes)
{
var deal = (DealCreditLinkedNote)Deal;
return(factors.Get <RecoveryRate>(string.IsNullOrEmpty(deal.Recovery_Rate) ? deal.Name : deal.Recovery_Rate));
}
else
{
return(null);
}
}
/// <summary>
/// Prepare for valuation anything that is not dependent upon the scenario.
/// </summary>
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
// Set up cashflow list
fCashflows.SetUseConvexityCorrection(Convexity_Correction == YesNo.Yes);
fCashflows.SetUseQuantoCorrection(Quanto_Correction == YesNo.Yes);
fCashflows.SetConvexityLowRateCutoff(Convexity_Low_Rate_Cutoff);
// Add to valuation time grid
fT.AddPayDates(fCashflows);
}
/// <summary>
/// Prepare for valuation anything that is not dependent upon the scenario.
/// </summary>
public override void PreCloneInitialize(PriceFactorList factors, BaseTimeGrid baseTimes, RequiredResults requiredResults)
{
base.PreCloneInitialize(factors, baseTimes, requiredResults);
var deal = (CFEquityFloatingInterestListDeal)Deal;
// Set up cashflow list
fCharacteristics = deal.Cashflows.Analyze(factors.BaseDate);
// Add to valuation time grid
fT.AddPayDates(deal.Cashflows);
}
/// <inheritdoc />
protected override void GetDefaultTime(Vector defaultTime, PriceFactorList factors)
{
CreditRating cr = GetCreditRating(factors);
if (cr != null)
{
cr.DefaultTime(defaultTime);
return;
}
base.GetDefaultTime(defaultTime, factors);
}
/// <summary>
/// Calculate vector valuation profile and vector realised cash profile.
/// </summary>
public override void Value(ValuationResults valuationResults, PriceFactorList factors, BaseTimeGrid baseTimes)
{
PreValue(factors);
CalcUtils.CreateDealProfilesIfRequired(valuationResults, fItems, factors);
double paySign = fSwaptionDeal.Payer_Receiver == PayerReceiver.Payer ? +1 : -1;
double buySign = fSwaptionDeal.Buy_Sell == BuySell.Buy ? +1 : -1;
bool isCashSettled = fSwaptionDeal.Settlement_Style == SettlementType.Cash;
bool isPhysicallySettled = fSwaptionDeal.Settlement_Style == SettlementType.Physical;
bool cashRequired = !valuationResults.Cash.Ignore;
TimeGridIterator tgi = new TimeGridIterator(fT);
PVProfiles result = valuationResults.Profile;
using (IntraValuationDiagnosticsHelper.StartDeal(fIntraValuationDiagnosticsWriter, Deal))
{
using (var outerCache = Vector.Cache(factors.NumScenarios))
{
Vector pv = outerCache.Get();
Vector exerciseWeight = outerCache.GetClear();
Vector cash = cashRequired ? outerCache.GetClear() : null;
// For a cash settled swaption, Settlement amount to be paid on Settlement Date.
Vector settlementCash = isCashSettled ? outerCache.GetClear() : null;
VectorEngine.For(tgi, () =>
{
// Work out the PV
if (tgi.Date < fSwaptionDeal.Option_Expiry_Date)
{
ValueBeforeExpiry(pv, factors, isCashSettled, tgi);
}
else
{
ValueOnOrAfterExpiry(pv, exerciseWeight, settlementCash, cash, factors, isCashSettled, isPhysicallySettled, cashRequired, tgi, paySign);
}
result.AppendVector(tgi.Date, buySign * pv * fFxRate.Get(tgi.T));
if (cashRequired)
{
valuationResults.Cash.Accumulate(fFxRate, tgi.Date, buySign * cash);
}
});
}
result.Complete(fT);
}
}
/// <inheritdoc />
protected override void GetDefaultTime(Vector defaultTime, PriceFactorList factors)
{
BondFuture deal = (BondFuture)Deal;
if (NeedRating(Respect_Default, deal.Issuer))
{
var cr = factors.Get <CreditRating>(deal.Issuer);
cr.DefaultTime(defaultTime);
return;
}
base.GetDefaultTime(defaultTime, factors);
}
/// <summary>
/// Register price factors.
/// </summary>
public override void RegisterFactors(PriceFactorList factors, ErrorList errors)
{
base.RegisterFactors(factors, errors);
var deal = (BondLendingBase)fDeal;
if (string.IsNullOrEmpty(deal.Issuer))
{
return;
}
factors.RegisterInterface <ISurvivalProb>(string.IsNullOrEmpty(deal.Survival_Probability) ? deal.Issuer : deal.Survival_Probability);
}
/// <summary>
/// Prepare for valuation anything that is dependent upon the scenario.
/// </summary>
public override void PreValue(PriceFactorList factors)
{
base.PreValue(factors);
var deal = (BondLendingBase)fDeal;
if (string.IsNullOrEmpty(deal.Issuer))
{
return;
}
fSurvivalProb = factors.GetInterface <ISurvivalProb>(string.IsNullOrEmpty(deal.Survival_Probability) ? deal.Issuer : deal.Survival_Probability);
}
