/// <summary> /// Register price factors used in valuation. /// </summary> public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { base.RegisterFactors(factors, errors); if (!string.IsNullOrEmpty(fForecastCurrency) && fForecastCurrency != fCurrency) { errors.Add(ErrorLevel.Error, "Settlement currency (Currency) and currency of Forecast_Rate must be the same"); } SetModelParameters(fItems); ValidateModels(fItems, errors); fItems.RegisterFactors(factors, errors); CallableStructuredDeal deal = (CallableStructuredDeal)fDeal; bool needRating = Respect_Default == YesNo.Yes && !string.IsNullOrEmpty(deal.Issuer); bool needSurvival = Use_Survival_Probability == YesNo.Yes && !string.IsNullOrEmpty(deal.Issuer); if (needRating) { factors.Register <CreditRating>(deal.Issuer); factors.Register <RecoveryRate>(InterestRateUtils.GetRateId(deal.Recovery_Rate, deal.Issuer)); } if (needSurvival) { factors.RegisterInterface <ISurvivalProb>(string.IsNullOrEmpty(deal.Survival_Probability) ? deal.Issuer : deal.Survival_Probability); } }
/// <summary> /// Register price factors. /// </summary> public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { base.RegisterFactors(factors, errors); BondOptionDeal deal = (BondOptionDeal)Deal; InterestVolBase.RegisterInterestYieldVol(factors, deal.Yield_Volatility, fCurrency); bool needRating = Respect_Default == YesNo.Yes && !string.IsNullOrEmpty(deal.Issuer); bool needSurvival = Use_Survival_Probability == YesNo.Yes && !string.IsNullOrEmpty(deal.Issuer); bool needRecovery = needRating; if (needRating) { factors.Register <CreditRating>(deal.Issuer); } if (needRecovery) { factors.Register <RecoveryRate>(string.IsNullOrEmpty(deal.Recovery_Rate) ? deal.Issuer : deal.Recovery_Rate); } if (needSurvival) { factors.RegisterInterface <ISurvivalProb>(string.IsNullOrEmpty(deal.Survival_Probability) ? deal.Issuer : deal.Survival_Probability); } }
/// <summary> /// Register price factors. /// </summary> public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { base.RegisterFactors(factors, errors); IInflationCashflowListDeal deal = (IInflationCashflowListDeal)Deal; if (deal.NeedInflationRate()) { factors.RegisterInterface <IInflationRate>(deal.Index); } if (NeedCreditRating()) { factors.Register <CreditRating>(deal.Issuer); } if (NeedRecoveryRate()) { factors.Register <RecoveryRate>(GetRecoveryRateID()); } if (NeedSurvivalProb()) { factors.RegisterInterface <ISurvivalProb>(GetSurvivalProbID()); } if (!string.IsNullOrEmpty(deal.Repo_Rate)) { factors.RegisterInterface <IInterestRate>(deal.Repo_Rate); } }
/// <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"); } } }
// ----------------------------------------------------------------------------- // Description: Register price factors // ----------------------------------------------------------------------------- public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { DealCreditLinkedNote deal = (DealCreditLinkedNote)Deal; base.RegisterFactors(factors, errors); factors.RegisterInterface <ISurvivalProb>(string.IsNullOrEmpty(deal.Survival_Probability) ? deal.Name : deal.Survival_Probability); if (Respect_Default == YesNo.Yes) { factors.Register <RecoveryRate>(string.IsNullOrEmpty(deal.Recovery_Rate) ? deal.Name : deal.Recovery_Rate); factors.Register <CreditRating>(deal.Name); } }
/// <summary> /// Register price factors. /// </summary> public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { factors.Register <DiscountRate>(InterestRateUtils.GetRateId(fDeal.Discount_Rate, fDeal.Currency)); factors.RegisterInterface <IFxRate>(fDeal.Currency); factors.RegisterInterface <IExpectedLoss>(fDeal.Reference_Index); factors.RegisterInterface <IRealizedLoss>(fDeal.Reference_Index); }
/// <summary> /// Register price factors. /// </summary> public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { base.RegisterFactors(factors, errors); fModelParametersId = string.IsNullOrWhiteSpace(Model_Parameters) ? fForecastCurrency : Model_Parameters; factors.Register <LinearGaussMarkovFactor>(fModelParametersId); }
/// <summary> /// Register price factors. /// </summary> public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { BondFuture deal = (BondFuture)Deal; base.RegisterFactors(factors, errors); if (NeedRating(Respect_Default, deal.Issuer)) { factors.Register <CreditRating>(deal.Issuer); // register realized recovery rate. factors.Register <RecoveryRate>(InterestRateUtils.GetRateId(deal.Recovery_Rate, deal.Issuer)); } if (NeedSurvivalProbability(Use_Survival_Probability, deal.Issuer)) { factors.RegisterInterface <ISurvivalProb>(InterestRateUtils.GetRateId(deal.Survival_Probability, deal.Issuer)); } }
/// <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> /// 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."); } } }
// ----------------------------------------------------------------------------- // Description: Register price factors // ----------------------------------------------------------------------------- public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { factors.Register <DiscountRate>(InterestRateUtils.GetRateId(fCreditBaseDeal.Discount_Rate, fCreditBaseDeal.Currency)); factors.RegisterInterface <IFxRate>(fCreditBaseDeal.Currency); factors.RegisterInterface <ISurvivalProb>(string.IsNullOrEmpty(fCreditBaseDeal.Survival_Probability) ? fCreditBaseDeal.Name : fCreditBaseDeal.Survival_Probability); if (Respect_Default == YesNo.Yes) { if (fCreditBaseDeal.ProtectionReferenceType() == DealCreditBase.ReferenceType.Single_Name) { factors.Register <CreditRating>(fCreditBaseDeal.Name); if (RequiresRecoveryOnDefault()) { factors.Register <RecoveryRate>(string.IsNullOrEmpty(fCreditBaseDeal.Recovery_Rate) ? fCreditBaseDeal.Name : fCreditBaseDeal.Recovery_Rate); } } else { factors.Register <IndexCDSPool>(fCreditBaseDeal.Name); } } }
/// <summary> /// Register price factors. /// </summary> public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { base.RegisterFactors(factors, errors); CallableBondForward deal = (CallableBondForward)Deal; InterestVolBase.RegisterInterestYieldVol(factors, deal.Yield_Volatility, deal.Currency); if (NeedCreditRating()) { factors.Register <CreditRating>(deal.Issuer); } if (NeedRecovery()) { factors.Register <RecoveryRate>(string.IsNullOrEmpty(deal.Recovery_Rate) ? deal.Issuer : deal.Recovery_Rate); } if (NeedSurvivalProb()) { factors.RegisterInterface <ISurvivalProb>(string.IsNullOrEmpty(deal.Survival_Probability) ? deal.Issuer : deal.Survival_Probability); } }
/// <summary> /// Register price factors. /// </summary> public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { base.RegisterFactors(factors, errors); var deal = (BondRepoBase)fDeal; if (string.IsNullOrEmpty(deal.Issuer)) { return; } factors.RegisterInterface <ISurvivalProb>(string.IsNullOrEmpty(deal.Survival_Probability) ? deal.Issuer : deal.Survival_Probability); factors.Register <RecoveryRate>(string.IsNullOrEmpty(deal.Recovery_Rate) ? deal.Issuer : deal.Recovery_Rate); }
/// <summary> /// Register price factors. /// </summary> public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { base.RegisterFactors(factors, errors); CFListBaseDeal <TCashflowList> deal = (CFListBaseDeal <TCashflowList>)fDeal; if (string.IsNullOrEmpty(fDeal.GetIssuer())) { return; } if (UseSurvivalProbability()) { factors.RegisterInterface <ISurvivalProb>(string.IsNullOrEmpty(deal.GetSurvivalProbability()) ? deal.GetIssuer() : deal.GetSurvivalProbability()); } if (RespectDefault()) { factors.Register <RecoveryRate>(InterestRateUtils.GetRateId(deal.GetRecoveryRate(), deal.GetIssuer())); factors.Register <CreditRating>(deal.GetIssuer()); } fSettlementOffsetHelper.ValidateHolidayCalendars(factors.CalendarData, errors); }
/// <summary> /// Register price factors. /// </summary> public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { base.RegisterFactors(factors, errors); var deal = (CFFloatingInterestListDeal)Deal; if (!IsValidCashflowList(factors, deal)) { Deal.AddToErrors(errors, ErrorLevel.Error, string.Format("{0} is for cashflow lists consisting of vanilla swaplets, caplets and floorlets", this.DisplayName())); } var rateIDs = SetCurrencyAndGetRateIds(); fModelParametersId = string.IsNullOrWhiteSpace(Model_Parameters) ? rateIDs.ForecastId1 : Model_Parameters; factors.Register <HullWhite1FactorModelParameters>(fModelParametersId); }
/// <summary> /// Register price factors. /// </summary> public override void RegisterFactors(PriceFactorList factors, ErrorList errors) { base.RegisterFactors(factors, errors); CFGeneralInterestSpreadListDeal deal = (CFGeneralInterestSpreadListDeal)Deal; // Collect registered volatility price factors to check they have the same distribution type var volPriceFactors = new List <IInterestVol>(); // Get spread flow characteristics SpreadCashflowListCharacteristics spreadCashflowCharacteristics = deal.Cashflows.ValuationPriceFactorDependencies(factors.BaseDate, fCurrency, fForecastCurrency, fForecast2Currency); // register volatility surfaces for forecast rate1 if (spreadCashflowCharacteristics.NeedForecast1YieldVol) { volPriceFactors.Add(InterestVolBase.RegisterInterestYieldVol(factors, deal.Forecast_Rate1_Swaption_Volatility, fForecastCurrency)); } if (spreadCashflowCharacteristics.NeedForecast1RateVol) { volPriceFactors.Add(InterestVolBase.RegisterInterestRateVol(factors, deal.Forecast_Rate1_Cap_Volatility, fForecastCurrency)); } // register volatility surfaces for forecast rate2 if (spreadCashflowCharacteristics.NeedForecast2YieldVol) { volPriceFactors.Add(InterestVolBase.RegisterInterestYieldVol(factors, deal.Forecast_Rate2_Swaption_Volatility, fForecast2Currency)); } if (spreadCashflowCharacteristics.NeedForecast2RateVol) { volPriceFactors.Add(InterestVolBase.RegisterInterestRateVol(factors, deal.Forecast_Rate2_Cap_Volatility, fForecast2Currency)); } // vol surfaces for discount rate if (spreadCashflowCharacteristics.NeedDiscountYieldVol) { volPriceFactors.Add(InterestVolBase.RegisterInterestYieldVol(factors, deal.Discount_Rate_Swaption_Volatility, fCurrency)); } if (spreadCashflowCharacteristics.NeedDiscountRateVol) { volPriceFactors.Add(InterestVolBase.RegisterInterestRateVol(factors, deal.Discount_Rate_Cap_Volatility, fCurrency)); } bool convexity = spreadCashflowCharacteristics.NeedDiscountYieldVol || spreadCashflowCharacteristics.NeedDiscountRateVol; if (fForecastCurrency != fCurrency) { if (Quanto_Correction == YesNo.Yes) { // fx vol, fx/ir correl and forecast/discount correl FXVolHelper.Register(factors, fForecastCurrency, fCurrency); CorrelationHelper.Register(factors, typeof(IInterestRate), fForecastCurrency, null, typeof(IFxRate), fForecastCurrency, fCurrency); } if (convexity) { CorrelationHelper.Register(factors, typeof(IInterestRate), fCurrency, null, typeof(IInterestRate), fForecastCurrency, null); } } if (fForecast2Currency != fCurrency) { if (Quanto_Correction == YesNo.Yes) { // fx vol, fx/ir correl and forecast/discount correl FXVolHelper.Register(factors, fForecast2Currency, fCurrency); CorrelationHelper.Register(factors, typeof(IInterestRate), fForecast2Currency, null, typeof(IFxRate), fForecast2Currency, fCurrency); } if (convexity) { CorrelationHelper.Register(factors, typeof(IInterestRate), fCurrency, null, typeof(IInterestRate), fForecast2Currency, null); } } if (spreadCashflowCharacteristics.NeedForecast1Forecast2Correlation) { if (fForecastCurrency == fForecast2Currency) { // correl between forecast rates in same currency factors.Register <CMSRateCorrelations>(fForecastCurrency); } else { CorrelationHelper.Register(factors, typeof(IInterestRate), fForecastCurrency, null, typeof(IInterestRate), fForecast2Currency, null); } } if (volPriceFactors.Select(pf => pf.GetDistributionType()).Distinct().Count() > 1) { Deal.AddToErrors(errors, "Volatility price factors must have the same distribution type."); } ValidateUnnecessaryVolatilities(deal, spreadCashflowCharacteristics, errors); }