Namespaces
namespace	os

Classes
class	AbsoluteStrike

class	AbstractReferenceDatumBuilder

class	AbstractTradeBuilder
	TradeBuilder base class. More...

class	AccrualBondRepoEngineBuilder
	Accrual Bond Repo Engine Builder. More...

class	Accumulator

class	AdjustedInMemoryLoader
	An Adjusted In Memory Loader,. More...

class	AdjustmentFactors
	Class to hold market data adjustment factors - for example equity stock splits. More...

class	AmcModel

class	AmericanOptionBAWEngineBuilder
	Abstract Engine Builder for American Vanilla Options using Barone Adesi Whaley Approximation. More...

class	AmericanOptionEngineBuilder
	Abstract Engine Builder for American Vanilla Options. More...

class	AmericanOptionFDEngineBuilder
	Abstract Engine Builder for American Vanilla Options using Finite Difference Method. More...

class	AmericanOptionWrapper
	American Option Wrapper. More...

class	AmortizationData
	Serializable object holding amortization rules. More...

class	AnalyticBlackRiskParticipationAgreementEngine

class	AnalyticHaganCmsCouponPricerBuilder

class	AnalyticXCcyBlackRiskParticipationAgreementEngine

class	Ascot
	Serializable Convertible Bond. More...

class	AscotEngineBuilder

class	AscotIntrinsicEngineBuilder

class	AsianOption
	Serializable Asian Option. More...

class	AsianOptionEngineBuilder
	Abstract Engine Builder for Asian Options. More...

class	AsianOptionScriptedEngineBuilder

struct	AssetPositionTrsUnderlyingBuilder

struct	AssignmentNode

struct	ASTNode

struct	ASTNodeAnnotation

class	AtmStrike

class	Autocallable_01

class	AverageOisConvention
	Container for storing Average OIS conventions. More...

class	AverageOISYieldCurveSegment
	Average OIS yield curve segment. More...

class	BalanceGuaranteedSwap
	Serializable Balance Guaranteed Swap. More...

class	BalanceGuaranteedSwapDiscountingEngineBuilder
	Balance Guaranteed Swap Discounting Engine Builder. More...

class	BalanceGuaranteedSwapFlexiSwapLGMGridEngineBuilder
	Balance Guaranteed Swap Flexi Swap LGM Grid Engine Builder. More...

class	BarrierData
	Serializable obejct holding barrier data. More...

class	BarrierOption
	Serializable FX Barrier Option. More...

class	BarrierOptionWrapper
	Barrier Option Wrapper. More...

class	BaseCorrelationCurve

class	BaseCorrelationCurveConfig
	Base Correlation term structure configuration. More...

class	BaseCorrelationCurveSpec
	Base Correlation surface description. More...

class	BaseCorrelationQuote
	Base correlation data class. More...

class	BaseStrike

class	BasicReferenceDataManager
	Basic Concrete impl that loads an big XML and keeps data in memory. More...

class	BasicUnderlying

class	BasisSwapQuote
	Basis Swap data class. More...

class	BasketConstituent

class	BasketData

class	BasketOption

class	BasketVarianceSwap

class	BermudanOptionWrapper
	Bermudan Option Wrapper. More...

class	BestEntryOption

class	BGSTrancheData
	Serializable Tranche for use in Balance Guaranteed Swaps. More...

class	BlackCdsOptionEngineBuilder
	Black CDS option engine builder for CDS options. More...

class	BlackIndexCdsOptionEngineBuilder
	Black CDS option engine builder for index CDS options. More...

class	BlackScholes

class	BlackScholesBase

class	BlackScholesCG

class	BlackScholesCGBase

class	BlackScholesModelBuilder

class	BlackScholesModelBuilderBase

class	BMABasisSwapConvention
	Container for storing Libor-BMA Basis Swap conventions. More...

class	BMASwapQuote
	BMA Swap data class. More...

class	Bond
	Serializable Bond. More...

class	BondBasket
	Serializable Bond-Basket Data. More...

class	BondBasketReferenceDatum
	Bond Basket Reference Data. More...

struct	BondBuilder
	Bond Factory that builds bonds from reference data. More...

class	BondData

class	BondDiscountingEngineBuilder
	Discounting Engine Builder class for Bonds. More...

class	BondEngineBuilder
	Engine Builder base class for Bonds. More...

class	BondFactory

class	BondIndexBuilder

class	BondMultiStateDiscountingEngineBuilder
	Multi State Engine Builder class for Bonds. More...

class	BondOption
	Serializable Bond Option. More...

class	BondOptionEngineBuilder
	Engine builder for bond option. More...

class	BondOptionQuote
	Bond option data class. More...

class	BondOptionShiftQuote
	Shift data class (for SLN bond option volatilities) More...

class	BondPosition

class	BondPositionData

class	BondPositionInstrumentWrapper
	Equity Position instrument wrapper. More...

struct	BondPositionTrsUnderlyingBuilder

class	BondPriceQuote
	Bond Price Quote. More...

class	BondReferenceDatum

class	BondRepo

class	BondRepoEngineBuilderBase
	Bond Repo engine builder base class. More...

class	BondSpreadImply

class	BondSpreadImplyMarket

class	BondTRS

class	BondTRSEngineBuilder

struct	BondTrsUnderlyingBuilder

class	BondUnderlying

class	BondYieldConvention

class	BondYieldShiftedYieldCurveSegment
	Bond yield shifted yield curve segment. More...

class	BootstrapConfig

class	BufferLogger
	BufferLogger. More...

class	CachingEngineBuilder
	Abstract template EngineBuilder class that can cache engines and coupon pricers. More...

class	CachingOptionEngineBuilder

class	CalendarAdjustmentConfig

class	CalendarParser

class	CalibrationBasket

class	CalibrationConfiguration

class	CalibrationInstrument

class	CalibrationInstrumentFactory

class	CalibrationPointCache

class	CallableSwap
	Serializable Swaption. More...

class	CamAmcCurrencySwapEngineBuilder
	Multileg option engine builder for external cam, with additional simulation dates (AMC) More...

class	CamAmcFxForwardEngineBuilder
	FX forward engine builder for external cam, with additional simulation dates (AMC) More...

class	CamAmcFxOptionEngineBuilder
	FX option engine builder for external cam, with additional simulation dates (AMC) More...

class	CamAmcMultiLegOptionEngineBuilder
	Multileg option engine builder for external cam, with additional simulation dates (AMC) More...

class	CamAmcSwapEngineBuilder
	Implementation of SwapEngineBuilderBase using MC pricer for external cam / AMC. More...

class	CamMcMultiLegOptionEngineBuilder
	MultiLeg option engine builder for MC pricer. More...

class	CapFloor
	Serializable cap, floor, collar. More...

class	CapFlooredAverageBMACouponLegEngineBuilder
	CouponPricer Builder for CapFlooredAVerageBMACouponLeg. More...

class	CapFlooredAverageONIndexedCouponLegEngineBuilder
	CouponPricer Builder for CapFlooredOvernightIndexedCouponLeg. More...

class	CapFlooredCpiLegCashFlowEngineBuilder

class	CapFlooredCpiLegCouponEngineBuilder
	CouponPricer Builder for Capped/Floored CPI Inflation Leg. More...

class	CapFlooredIborLegEngineBuilder
	CouponPricer Builder for CapFlooredIborLeg. More...

class	CapFlooredNonStandardYoYLegEngineBuilder
	CouponPricer Builder for Capped/Floored YoY Inflation Leg. More...

class	CapFlooredOvernightIndexedCouponLegEngineBuilder
	CouponPricer Builder for CapFlooredOvernightIndexedCouponLeg. More...

class	CapFlooredYoYLegEngineBuilder
	CouponPricer Builder for Capped/Floored YoY Inflation Leg. More...

class	CapFloorEngineBuilder
	Engine Builder for Caps, Floors and Collars on an IborIndex. More...

class	CapFloorQuote
	Cap/Floor data class. More...

class	CapFloorShiftQuote
	Shift data class (for SLN cap/floor volatilities) More...

class	CapFloorVolatilityCurveConfig

class	CapFloorVolatilityCurveSpec
	Cap/Floor Volatility curve description. More...

class	CapFloorVolCurve

class	CashflowData
	Serializable Cashflow Leg Data. More...

class	CashflowLegBuilder

class	CBO

class	CboMCEngineBuilder

class	CboReferenceDatum

struct	CBOTrsUnderlyingBuilder

class	CdoEngineBuilder

class	CdsConvention
	Container for storing Credit Default Swap quote conventions. More...

class	CDSEngineKey

class	CDSProxyVolatilityConfig

class	CdsQuote

class	CdsReferenceInformation

class	CDSVolatilityCurveConfig

class	CDSVolatilityCurveSpec
	CDS Volatility curve description. More...

class	CDSVolCurve

class	CFD

class	CliquetOption
	Serializable Equity Cliquet Option. More...

class	CliquetOptionEngineBuilder
	Engine builder for Cliquet Options. More...

class	CliquetOptionMcScriptEngine

class	ClonedLoader

class	CMBLegBuilder

class	CMBLegData
	Serializable Constant Maturity Bond Yield Leg Data. More...

class	CmsCouponPricerBuilder
	CouponPricer Builder for CmsLeg. More...

class	CMSLegBuilder

class	CMSLegData
	Serializable CMS Leg Data. More...

class	CmsSpreadCouponPricerBuilder
	CouponPricer Builder for CmsSpreadLeg. More...

class	CMSSpreadLegBuilder

class	CMSSpreadLegData
	Serializable CMS Spread Leg Data. More...

class	CmsSpreadOptionConvention
	Container for storing CMS Spread Option conventions. More...

class	CollateralBalance

class	CollateralBalances
	Collateral Balances. More...

class	CommodityAccumulator

class	CommodityAmericanOptionBAWEngineBuilder

class	CommodityAmericanOptionFDEngineBuilder

class	CommodityApoAnalyticalEngineBuilder
	Analytical Engine builder for Commodity Average Price Options. More...

class	CommodityApoBaseEngineBuilder
	Engine builder base class for Commodity Average Price Options. More...

class	CommodityApoModelBuilder

class	CommodityApoMonteCarloEngineBuilder
	Monte Carlo Engine builder for Commodity Average Price Options. More...

class	CommodityAsianOption

class	CommodityAveragePriceOption

class	CommodityBasketOption

class	CommodityBasketVarianceSwap

class	CommodityBestEntryOption

class	CommodityCurve

struct	CommodityCurveCalibrationInfo

class	CommodityCurveConfig
	Commodity curve configuration. More...

class	CommodityCurveSpec
	Commodity curve description. More...

class	CommodityDigitalAveragePriceOption

class	CommodityDigitalOption
	Commodity digital option trade representation as call spread. More...

class	CommodityEuropeanAsianOptionACGAPEngineBuilder
	Continuous Analytic Engine Builder for European Asian Commodity Geometric Average Price Options. More...

class	CommodityEuropeanAsianOptionADGAPEngineBuilder
	Discrete Analytic Engine Builder for European Asian Commodity Geometric Average Price Options. More...

class	CommodityEuropeanAsianOptionADGASEngineBuilder
	Discrete Analytic Engine Builder for European Asian Commodity Geometric Average Strike Options. More...

class	CommodityEuropeanAsianOptionMCDAAPEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Commodity Arithmetic Average Price Options. More...

class	CommodityEuropeanAsianOptionMCDAASEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Commodity Arithmetic Average Strike Options. More...

class	CommodityEuropeanAsianOptionMCDGAPEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Commodity Geometric Average Price Options. More...

class	CommodityEuropeanAsianOptionTWEngineBuilder
	Discrete Analytic TW Engine Builder for European Asian Commodity Arithmetic Average Price Options. More...

class	CommodityEuropeanCSOptionEngineBuilder

class	CommodityEuropeanForwardOptionEngineBuilder

class	CommodityEuropeanOptionEngineBuilder

class	CommodityFixedLegBuilder

class	CommodityFixedLegData

class	CommodityFloatingLegBuilder

class	CommodityFloatingLegData

class	CommodityForward

class	CommodityForwardConvention

class	CommodityForwardEngineBuilder
	Engine builder for commodity forward. More...

class	CommodityForwardQuote
	Commodity forward quote class. More...

class	CommodityFutureConvention

class	CommodityGenericBarrierOption

class	CommodityIndexReferenceDatum
	EquityIndex Reference data, contains the names and weights of an equity index. More...

class	CommodityOption
	Commodity option trade representation. More...

class	CommodityOptionQuote
	Commodity option data class. More...

class	CommodityOptionStrip

class	CommodityPosition
	Serializable Commodity Position. More...

class	CommodityPositionData
	Serializable Commodity Position Data. More...

class	CommodityPositionInstrumentWrapper
	Commodity Position instrument wrapper. More...

class	CommodityPositionInstrumentWrapperEngine

class	CommodityRainbowOption

class	CommoditySchwartzData
	COM Schwartz Model Parameters. More...

class	CommoditySchwartzModelBuilder
	Builder for a COM model component. More...

class	CommoditySpotQuote
	Commodity spot quote class. More...

class	CommoditySpreadOption

class	CommoditySpreadOptionBaseEngineBuilder
	Base Engine builder for Commodity Spread Options. More...

class	CommoditySpreadOptionData

class	CommoditySpreadOptionEngineBuilder
	Analytical Engine builder for Commodity Spread Options. More...

class	CommoditySwap

class	CommoditySwapEngineBuilder
	Engine builder for Commodity Swaps. More...

class	CommoditySwaption

class	CommoditySwaptionAnalyticalEngineBuilder
	Analytical Approximation Engine builder for Commodity Swaptions. More...

class	CommoditySwaptionEngineBuilder
	Engine builder for Commodity Swaptions. More...

class	CommoditySwaptionMonteCarloEngineBuilder
	Monte Carlo Engine builder for Commodity Swaptions. More...

class	CommodityTaRF

class	CommodityUnderlying

class	CommodityVolatilityConfig
	Commodity volatility configuration. More...

class	CommodityVolatilityCurveSpec
	Commodity volatility description. More...

class	CommodityVolCurve
	Wrapper class for building commodity volatility structures. More...

class	CommodityWindowBarrierOption

class	CommodityWorstOfBasketSwap

class	CompositeInstrumentWrapper
	Composite Instrument Wrapper. More...

class	CompositeLoader

class	CompositeTrade
	Composite Trade class. More...

class	ComputationGraphBuilder

class	ComVarSwap

struct	ConditionAndNode

struct	ConditionEqNode

struct	ConditionGeqNode

struct	ConditionGtNode

struct	ConditionLeqNode

struct	ConditionLtNode

struct	ConditionNeqNode

struct	ConditionNotNode

struct	ConditionOrNode

class	ConsoleLog
	Singleton to control console logging. More...

struct	ConstantNumberNode

class	ConstantVolatilityConfig

struct	Context

class	Convention
	Abstract base class for convention objects. More...

class	Conventions
	Repository for currency dependent market conventions. More...

class	ConventionsBasedFutureExpiry
	Perform date calculations for future contracts based on conventions. More...

class	ConvertibleBond
	Serializable Convertible Bond. More...

struct	ConvertibleBondBuilder

class	ConvertibleBondData

class	ConvertibleBondEngineBuilder

class	ConvertibleBondFDDefaultableEquityJumpDiffusionEngineBuilder

class	ConvertibleBondReferenceDatum
	Convertible Bond Reference data. More...

struct	ConvertibleBondTrsUnderlyingBuilder

class	CorrelationCurve
	Wrapper class for building correlation structures. More...

class	CorrelationCurveConfig
	Correlation curve configuration. More...

class	CorrelationCurveSpec
	Correlation curve description. More...

struct	CorrelationFactor

class	CorrelationMatrixBuilder

class	CorrelationQuote
	Spread data class. More...

class	CpiCapFloor

class	CpiCapFloorEngineBuilder
	Engine Builder for CPI Caps, Floors and Collars. More...

class	CPILegBuilder

class	CPILegData
	Serializable CPI Leg Data. More...

class	CPRQuote
	CPR data class. More...

class	CrCirBuilder
	Builder for a cir model component. More...

class	CrCirData

class	CreditDefaultSwap

class	CreditDefaultSwapData

class	CreditDefaultSwapEngineBuilder
	Engine builder base class for credit default swaps. More...

class	CreditDefaultSwapOption

class	CreditDefaultSwapOptionEngineBuilder
	Engine Builder base class for Credit Default Swap Options. More...

class	CreditIndexConstituent

class	CreditIndexReferenceDatum
	Credit index reference data, contains a set of index constituents. More...

class	CreditLinkedSwap

class	CreditLinkedSwapEngineBuilder

class	CreditReferenceDatum
	CreditIndex Reference data, contains the names and weights of a credit index. More...

class	CreditUnderlying

class	CrLgmBuilder

class	CrLgmData
	CR LGM Model Parameters. More...

class	CrossAssetModelBuilder
	Cross Asset Model Builder. More...

class	CrossAssetModelData
	Cross Asset Model Parameters. More...

class	CrossCcyBasisSwapConvention
	Container for storing Cross Currency Basis Swap quote conventions. More...

class	CrossCcyBasisSwapQuote
	Cross Currency Basis Swap data class. More...

class	CrossCcyFixFloatSwapConvention

class	CrossCcyFixFloatSwapQuote
	Cross Currency Fix Float Swap quote holder. More...

class	CrossCcyYieldCurveSegment
	Cross Currency yield curve segment. More...

class	CrossCurrencySwap
	Serializable Cross Currency Swap contract. More...

class	CrossCurrencySwapEngineBuilder
	Discounted Cashflows Engine Builder for Cross Currency Swaps. More...

class	CrossCurrencySwapEngineBuilderBase
	Engine Builder base class for Cross Currency Swaps. More...

class	CSA

class	CSVBufferReader

class	CSVFileReader

class	CSVFileReport

class	CSVLoader
	Utility class for loading market quotes and fixings from a file. More...

class	CSVReader

class	CurrencyConfig
	Currency configuration. More...

class	CurrencyHedgedEquityIndexDecomposition

class	CurrencyHedgedEquityIndexReferenceDatum

class	CurrencyParser

class	CurrencySwapEngineBuilderDeltaGamma
	Engine Builder for Cross Currency Swaps. More...

struct	CurrencyVec

class	CurveConfig
	Base curve configuration. More...

class	CurveConfigurations
	Container class for all Curve Configurations. More...

class	CurveConfigurationsManager

class	CurveSpec
	Curve Specification. More...

class	DateGrid
	Simulation Date Grid. More...

struct	DaycounterVec

struct	DeclarationNumberNode

class	DefaultCurve
	Wrapper class for building Swaption volatility structures. More...

class	DefaultCurveConfig
	Default curve configuration. More...

class	DefaultCurveSpec
	Default curve description. More...

class	DelegatingEngineBuilder
	Delegating Engine Builder. More...

class	DeltaStrike

class	DeltaString
	Utility class for handling delta strings ATM, 10P, 25C, ... used e.g. for FX Surfaces. More...

class	DependencyGraph

class	DepositConvention
	Container for storing Deposit conventions. More...

struct	DerivativeTrsUnderlyingBuilder

class	DigitalCMSLegBuilder

class	DigitalCMSLegData
	Serializable Digital CMS Leg Data. More...

class	DigitalCMSSpreadLegBuilder

class	DigitalCMSSpreadLegData
	Serializable Digital CMS Spread Leg Data. More...

class	DirectYieldCurveSegment
	Direct yield curve segment. More...

class	DiscountingBondRepoEngineBuilder
	Discounting Bond Repo Engine Builder. More...

class	DiscountingBondTRSEngineBuilder

class	DiscountingForwardBondEngineBuilder

class	DiscountQuote
	Discount market data class. More...

class	DiscountRatioYieldCurveSegment
	Discount ratio yield curve segment. More...

class	DoubleBarrierOptionWrapper

class	DoubleDigitalOption

class	DummyModel

class	DurationAdjustedCmsCouponPricerBuilder

class	DurationAdjustedCmsLegBuilder

class	DurationAdjustedCmsLegData

class	EngineBuilder
	Base PricingEngine Builder class for a specific model and engine. More...

class	EngineBuilderFactory
	Engine/ Leg Builder Factory - notice that both engine and leg builders are allowed to maintain a state. More...

class	EngineData
	Pricing engine description. More...

class	EngineFactory
	Pricing Engine Factory class. More...

class	Envelope
	Serializable object holding generic trade data, reporting dimensions. More...

class	EqBsBuilder
	Builder for a Lognormal EQ model component. More...

class	EqBsData
	EQ Model Parameters. More...

class	EqPairwiseVarSwap

class	EquityAccumulator

class	EquityAmericanOptionBAWEngineBuilder
	Engine Builder for American Equity Options using Barone Adesi Whaley Approximation. More...

class	EquityAmericanOptionFDEngineBuilder
	Engine Builder for American Equity Options using Finite Difference Method. More...

class	EquityAsianOption

class	EquityBarrierOption
	Serializable EQ Barrier Option. More...

class	EquityBarrierOptionAnalyticEngineBuilder

class	EquityBarrierOptionEngineBuilder
	Engine Builder for Equity Barrier Options. More...

class	EquityBarrierOptionFDEngineBuilder

class	EquityBasketOption

class	EquityBasketVarianceSwap

class	EquityBestEntryOption

class	EquityCliquetOption

class	EquityCliquetOptionEngineBuilder
	Engine Builder for Equity Cliquet Options. More...

class	EquityCliquetOptionMcScriptEngineBuilder

class	EquityCurve
	Wrapper class for building Equity curves (spot quote, yield term structure, risk free IR term structure) More...

class	EquityCurveConfig
	Equity curve configuration. More...

class	EquityCurveSpec
	Equity curve description. More...

class	EquityDerivative
	Base class for all Equity Derivaties. More...

class	EquityDigitalOption
	Serializable EQ Digital Option. More...

class	EquityDigitalOptionEngineBuilder
	Engine Builder for European EQ Digital Options. More...

class	EquityDividendYieldQuote
	Equity/Index Dividend yield data class. More...

class	EquityDoubleBarrierOption
	Serializable Equity Double Barrier Option. More...

class	EquityDoubleBarrierOptionAnalyticEngineBuilder

class	EquityDoubleBarrierOptionEngineBuilder
	Engine Builder for Equity Double Barrier Options. More...

class	EquityDoubleTouchOption
	SerializableEQ Double One-Touch/No-Touch Option. More...

class	EquityDoubleTouchOptionAnalyticEngineBuilder
	Analytical Engine Builder for EQ Double Touch Options. More...

class	EquityDoubleTouchOptionEngineBuilder
	Abstract Engine Builder for EQ Double Touch Options. More...

class	EquityEuropeanAsianOptionACGAPEngineBuilder
	Continuous Analytic Engine Builder for European Asian Equity Geometric Average Price Options. More...

class	EquityEuropeanAsianOptionADGAPEngineBuilder
	Discrete Analytic Engine Builder for European Asian Equity Geometric Average Price Options. More...

class	EquityEuropeanAsianOptionADGASEngineBuilder
	Discrete Analytic Engine Builder for European Asian Equity Geometric Average Strike Options. More...

class	EquityEuropeanAsianOptionMCDAAPEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Equity Arithmetic Average Price Options. More...

class	EquityEuropeanAsianOptionMCDAASEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Equity Arithmetic Average Strike Options. More...

class	EquityEuropeanAsianOptionMCDGAPEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Equity Geometric Average Price Options. More...

class	EquityEuropeanAsianOptionTWEngineBuilder
	Discrete Analytic TW Engine Builder for European Asian Equity Arithmetic Average Price Options. More...

class	EquityEuropeanBarrierOption
	Serializable EQ European Barrier Option. More...

class	EquityEuropeanCompositeEngineBuilder
	Engine Builder for Composite European Equity Options. More...

class	EquityEuropeanCSOptionEngineBuilder

class	EquityEuropeanOptionEngineBuilder
	Engine Builder for European Equity Option Options. More...

class	EquityEuropeanOptionEngineBuilderDeltaGamma
	Engine Builder for European Equity Options with analytical sensitivities. More...

class	EquityForward
	Serializable Equity Forward contract. More...

class	EquityForwardEngineBuilder
	Engine Builder for European Equity Forwards. More...

class	EquityForwardQuote
	Equity forward data class. More...

class	EquityFutureEuropeanOptionEngineBuilder

class	EquityFutureOption
	Serializable EQ Futures Option. More...

class	EquityGenericBarrierOption

class	EquityIndexReferenceDatum
	EquityIndex Reference data, contains the names and weights of an equity index. More...

class	EquityLegBuilder

class	EquityLegData
	Serializable Fixed Leg Data. More...

class	EquityMarginLegBuilder

class	EquityMarginLegData
	Serializable Equity Margin Leg Data. More...

class	EquityOption
	Serializable Equity Option. More...

class	EquityOptionPosition
	Serializable Equity Option Position. More...

class	EquityOptionPositionData
	Serializable Equity Option Position Data. More...

class	EquityOptionPositionInstrumentWrapper
	Equity Option Position instrument wrapper. More...

class	EquityOptionPositionInstrumentWrapperEngine

struct	EquityOptionPositionTrsUnderlyingBuilder

class	EquityOptionQuote
	Equity/Index Option data class. More...

class	EquityOptionUnderlyingData
	Serializable Equity Option Underlying Data, this represents one underlying in EquityOptionPositionData. More...

class	EquityOptionWithBarrier

class	EquityOutperformanceOption
	Serializable EQ Outperformance Option. More...

class	EquityOutperformanceOptionEngineBuilder
	Engine Builder for EQ Outperformance Option. More...

class	EquityPosition
	Serializable Equity Position. More...

class	EquityPositionData
	Serializable Equity Position Data. More...

class	EquityPositionInstrumentWrapper
	Equity Position instrument wrapper. More...

class	EquityPositionInstrumentWrapperEngine

class	EquityRainbowOption

class	EquityReferenceDatum
	Equity Reference data. More...

class	EquitySingleAssetDerivative
	Base class for all single asset Equity Derivaties. More...

class	EquitySpotQuote
	Equity/Index spot price data class. More...

class	EquitySwap
	Serializable Equity Swap contract. More...

class	EquityTaRF

class	EquityTouchOption
	Serializable EQ One-Touch/No-Touch Option. More...

class	EquityTouchOptionEngineBuilder
	Engine Builder for EQ Touch Options. More...

class	EquityUnderlying

class	EquityVolatilityCurveConfig
	Equity volatility structure configuration. More...

class	EquityVolatilityCurveSpec
	Equity Volatility curve description. More...

class	EquityVolCurve
	Wrapper class for building Equity volatility structures. More...

class	EquityWindowBarrierOption

class	EquityWorstOfBasketSwap

class	EqVarSwap

class	EuropeanAsianOptionACGAPEngineBuilder
	Continuous Analytic Engine Builder for European Asian Geometric Average Price Options. More...

class	EuropeanAsianOptionADGAPEngineBuilder
	Discrete Analytic Engine Builder for European Asian Geometric Average Price Options. More...

class	EuropeanAsianOptionADGASEngineBuilder
	Discrete Analytic Engine Builder for European Asian Geometric Average Strike Options. More...

class	EuropeanAsianOptionMCDAAPEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Arithmetic Average Price Options. More...

class	EuropeanAsianOptionMCDAASEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Arithmetic Average Strike Options. More...

class	EuropeanAsianOptionMCDGAPEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Geometric Average Price Options. More...

class	EuropeanAsianOptionTWEngineBuilder
	Discrete Analytic TW Engine Builder for European Asian Arithmetic Average Price Options. More...

class	EuropeanCSOptionEngineBuilder

class	EuropeanForwardOptionEngineBuilder
	Abstract Engine Builder for European Vanilla Forward Options. More...

class	EuropeanOptionBarrier

class	EuropeanOptionEngineBuilder
	Abstract Engine Builder for European Vanilla Options. More...

class	EuropeanOptionEngineBuilderDeltaGamma
	Engine Builder for European Options with delta/gamma extension. More...

class	EuropeanOptionWrapper
	European Option Wrapper. More...

class	EuropeanSwaptionEngineBuilder
	European Swaption Engine Builder. More...

class	EventLogger
	EventLogger. More...

class	EventMessage

struct	EventVec

class	ExerciseBuilder

class	Expiry

class	ExpiryDate

class	ExpiryPeriod

class	FailedTrade

class	FdBlackScholesBase

class	FdGaussianCam

class	FileIO

class	FileLogger
	FileLogger. More...

struct	FittedBondCurveCalibrationInfo

class	FittedBondCurveHelperMarket

class	FittedBondYieldCurveSegment
	FittedBond yield curve segment. More...

class	FixedLegBuilder

class	FixedLegData
	Serializable Fixed Leg Data. More...

struct	Fixing
	Fixing data structure. More...

class	FixingDateGetter

class	FlexiSwap
	Serializable Flexi-Swap. More...

class	FlexiSwapBGSDiscountingEngineBuilderBase
	Flexi Swap / BGS Discounting Engine Builder. More...

class	FlexiSwapBGSEngineBuilderBase
	Flexi Swap / BGS Engine Builder Base Class (id2 is used for BGS only) More...

class	FlexiSwapBGSLGMGridEngineBuilderBase
	Flexi Swap / BGS Numeric LGM Grid Engine Builder Base Class. More...

class	FlexiSwapDiscountingEngineBuilder
	Flexi Swap Discounting Engine Builder. More...

class	FlexiSwapLGMGridEngineBuilder
	Flexi Swap LGM Grid Engine Builder. More...

class	FloatingLegBuilder

class	FloatingLegData
	Serializable Floating Leg Data. More...

class	FormulaBasedCouponPricerBuilder

class	FormulaBasedLegBuilder

class	FormulaBasedLegData

class	ForwardBond

struct	ForwardBondTrsUnderlyingBuilder

class	ForwardRateAgreement
	Serializable ForwardRateAgreement. More...

class	FraConvention
	Container for storing Forward rate Agreement conventions. More...

class	FRAQuote
	FRA market data class. More...

struct	FunctionAboveProbNode

struct	FunctionAbsNode

struct	FunctionBelowProbNode

struct	FunctionBlackNode

struct	FunctionDateIndexNode

struct	FunctionDaysNode

struct	FunctionDcfNode

struct	FunctionDiscountNode

struct	FunctionExpNode

struct	FunctionFwdAvgNode

struct	FunctionFwdCompNode

struct	FunctionLogNode

struct	FunctionLogPayNode

struct	FunctionMaxNode

struct	FunctionMinNode

struct	FunctionNormalCdfNode

struct	FunctionNormalPdfNode

struct	FunctionNpvMemNode

struct	FunctionNpvNode

struct	FunctionPayNode

struct	FunctionPowNode

struct	FunctionSqrtNode

class	FutureContinuationExpiry

class	FutureConvention
	Container for storing Money Market Futures conventions. More...

class	fwdBondEngineBuilder

class	FxAccumulator

class	FxAmericanOptionBAWEngineBuilder
	Engine Builder for American Fx Options using Barone Adesi Whaley Approximation. More...

class	FxAmericanOptionFDEngineBuilder
	Engine Builder for American Fx Options using Finite Difference Method. More...

class	FxAsianOption

class	FxAverageForward
	Serializable Fx Average Forward. More...

class	FxBarrierOption
	Serializable FX Barrier Option. More...

class	FxBarrierOptionAnalyticEngineBuilder

class	FxBarrierOptionEngineBuilder
	Engine Builder for European FX Barrier Options. More...

class	FxBarrierOptionFDEngineBuilder

class	FxBasketOption

class	FxBasketVarianceSwap

class	FxBestEntryOption

class	FxBsBuilder
	Builder for a Lognormal FX model component. More...

class	FxBsData
	FX Model Parameters. More...

class	FXConvention
	Container for storing FX Spot quote conventions. More...

class	FxDerivative
	Base class for all FX Derivaties. More...

class	FxDigitalBarrierOption
	Serializable FX Digital Barrier Option. More...

class	FxDigitalBarrierOptionEngineBuilder
	Engine Builder for European FX Digital Barrier Options. More...

class	FxDigitalCSOptionEngineBuilder
	Engine Builder for European cash-settled FX Digital Options. More...

class	FxDigitalOption
	Serializable FX Digital Option. More...

class	FxDigitalOptionEngineBuilder
	Engine Builder for European FX Digital Options. More...

class	FxDoubleBarrierOption
	Serializable FX Double Barrier Option. More...

class	FxDoubleBarrierOptionAnalyticEngineBuilder
	Analytical Engine Builder for FX Double Barrier Options. More...

class	FxDoubleBarrierOptionEngineBuilder
	Engine Builder for European FX Double Barrier Options. More...

class	FxDoubleTouchOption
	Serializable FX Double One-Touch/No-Touch Option. More...

class	FxDoubleTouchOptionAnalyticEngineBuilder
	Analytical Engine Builder for FX Double Touch Options. More...

class	FxDoubleTouchOptionEngineBuilder
	Abstract Engine Builder for FX Double Touch Options. More...

struct	FxEqCommVolCalibrationInfo

class	FxEuropeanAsianOptionACGAPEngineBuilder
	Continuous Analytic Engine Builder for European Asian Fx Geometric Average Price Options. More...

class	FxEuropeanAsianOptionADGAPEngineBuilder
	Discrete Analytic Engine Builder for European Asian Fx Geometric Average Price Options. More...

class	FxEuropeanAsianOptionADGASEngineBuilder
	Discrete Analytic Engine Builder for European Asian Fx Geometric Average Strike Options. More...

class	FxEuropeanAsianOptionMCDAAPEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Fx Arithmetic Average Price Options. More...

class	FxEuropeanAsianOptionMCDAASEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Fx Arithmetic Average Strike Options. More...

class	FxEuropeanAsianOptionMCDGAPEngineBuilder
	Discrete Monte Carlo Engine Builder for European Asian Fx Geometric Average Price Options. More...

class	FxEuropeanAsianOptionTWEngineBuilder
	Discrete Analytic TW Engine Builder for European Asian Fx Arithmetic Average Price Options. More...

class	FxEuropeanBarrierOption
	Serializable FX European Barrier Option. More...

class	FxEuropeanCSOptionEngineBuilder

class	FxEuropeanOptionEngineBuilder
	Engine Builder for European Fx Option Options. More...

class	FxEuropeanOptionEngineBuilderDeltaGamma
	Engine Builder for European FX Options with analytical sensitivities. More...

class	FxForward
	Serializable FX Forward. More...

class	FxForwardEngineBuilder
	Engine Builder for FX Forwards. More...

class	FxForwardEngineBuilderBase
	Engine Builder base class for FX Forwards. More...

class	FxForwardEngineBuilderDeltaGamma
	Engine Builder for FX Forwards. More...

class	FXForwardQuote
	Foreign exchange rate data class. More...

class	FxGenericBarrierOption

class	FxKIKOBarrierOption
	Serializable FX KIKO Barrier Option. More...

class	FxOption
	Serializable FX Option. More...

class	FxOptionConvention
	Container for storing FX Option conventions. More...

class	FXOptionQuote
	FX Option data class. More...

class	FxOptionWithBarrier

class	FxPairwiseVarSwap

class	FxRainbowOption

class	FxSingleAssetDerivative
	Base class for all single asset FX Derivaties. More...

class	FXSpotConfig
	FXSpot configuration. More...

class	FXSpotQuote
	Foreign exchange rate data class. More...

class	FXSpotSpec
	FX Spot description. More...

class	FxSwap
	Serializable FX Swap. More...

class	FxTaRF

class	FxTouchOption
	Serializable FX One-Touch/No-Touch Option. More...

class	FxTouchOptionEngineBuilder
	Engine Builder for FX Touch Options. More...

class	FXTriangulation

class	FXUnderlying

class	FxVarSwap

class	FXVolatilityCurveConfig
	FX volatility structure configuration. More...

class	FXVolatilityCurveSpec
	FX Volatility curve description. More...

class	FXVolCurve
	Wrapper class for building FX volatility structures. More...

class	FxWindowBarrierOption

class	FxWorstOfBasketSwap

class	GaussCopulaBucketingCdoEngineBuilder

class	GaussianCam

class	GaussianCamCG

class	GenericBarrierOption

class	GenericYieldVolatilityCurveConfig
	Generic yield volatility curve configuration class. More...

class	GenericYieldVolCurve
	Wrapper class for building Generic yield volatility structures. More...

class	GlobalPseudoCurrencyMarketParameters
	Singleton to store Global parameters, this should be initialised at some point with PEGP. More...

class	HazardRateQuote
	Hazard rate data class. More...

struct	HistFixingNode

class	HwBuilder
	Builder for a Hull White model or a HW component for the CAM. More...

class	HwCG

class	HwModelData
	Hull White Model Parameters. More...

class	IborFallbackConfig

class	IborFallbackCurveSegment
	Ibor Fallback yield curve segment. More...

class	IborIndexConvention
	Container for storing Ibor Index conventions. More...

struct	IfThenElseNode

class	ImmFraQuote
	IMM FRA market data class. More...

class	IndependentLogger
	Base Log handler class that utilises Boost logging to create log sinks. More...

class	IndexCDSOptionQuote
	CDS Index Option data class. More...

class	IndexCreditDefaultSwap

class	IndexCreditDefaultSwapData

class	IndexCreditDefaultSwapEngineBuilder
	Engine Builder base class for Index Credit Default Swaps. More...

class	IndexCreditDefaultSwapOption

class	IndexCreditDefaultSwapOptionEngineBuilder
	Engine Builder base class for Index Credit Default Swap Options. More...

class	IndexInfo

class	Indexing
	Serializable object holding indexing data. More...

class	IndexNameTranslator
	IndexNameTranslator. More...

class	IndexReferenceDatum
	Base class for indices - lets see if we can keep this, they might diverge too much... More...

struct	IndexVec

class	InfDkBuilder

class	InfDkData

class	InfJyBuilder

class	InfJyData

class	InflationCapFloorQuote
	Inflation Cap Floor data class. More...

class	InflationCapFloorVolatilityCurveConfig
	Inflation CapFloor volatility curve configuration class. More...

class	InflationCapFloorVolatilityCurveSpec
	Inflation cap floor volatility description. More...

class	InflationCapFloorVolCurve

class	InflationCurve
	Wrapper class for building inflation curves. More...

struct	InflationCurveCalibrationInfo

class	InflationCurveConfig

class	InflationCurveSpec
	Inflation curve description. More...

class	InflationModelData

class	InflationSwap
	Serializable Cross Currency Swap contract. More...

class	InflationSwapConvention

class	InflationUnderlying

class	InMemoryLoader

class	InMemoryReport

class	InstantaneousCorrelations
	InstantaneousCorrelations. More...

class	InstrumentConventions
	Singleton to hold conventions. More...

class	InstrumentWrapper
	Instrument Wrapper. More...

class	InterestRateUnderlying

class	IrLgmData
	INF Model Parameters. More...

class	IrModelData
	Linear Gauss Markov Model Parameters. More...

class	IRSwapConvention
	Container for storing Interest Rate Swap conventions. More...

struct	IrVolCalibrationInfo

class	JSONMessage

class	KnockOutSwap

class	LegAdditionalData
	Serializable Additional Leg Data. More...

class	LegBuilder

class	LegData
	Serializable object holding leg data. More...

class	LegDataFactory

class	LGMAmcSwaptionEngineBuilder

class	LgmBuilder
	Builder for a Linear Gauss Markov model component. More...

class	LgmCG

class	LgmData
	Linear Gauss Markov Model Parameters. More...

class	LGMFDSwaptionEngineBuilder
	Implementation of BermudanAmericanSwaptionEngineBuilder using LGM FD pricer. More...

class	LGMGridSwaptionEngineBuilder
	Implementation of BermudanAmericanSwaptionEngineBuilder using LGM Grid pricer. More...

class	LGMMCSwaptionEngineBuilder
	Implementation of LGMBermudanAmericanSwaptionEngineBuilder using MC pricer. More...

class	LgmReversionTransformation

class	LGMSwaptionEngineBuilder
	Abstract LGMSwaptionEngineBuilder class. More...

class	LinearTSRCmsCouponPricerBuilder

class	LinearTsrDurationAdjustedCmsCouponPricerBuilder

class	Loader
	Market data loader base class. More...

class	LocalVol

class	LocalVolModelBuilder

struct	LocationInfo

class	Log
	Global static Log class. More...

class	Logger
	The Base Custom Log Handler class. More...

class	LoggerStream
	LoggerStream class that is a std::ostream replacement that will log each line. More...

struct	LoopNode

class	Market
	Market. More...

class	MarketConfiguration

class	MarketDatum
	Base market data class. More...

class	MarketImpl
	Market Implementation. More...

class	MidPointCdsEngineBuilder
	Midpoint engine builder class for credit default swaps. More...

class	MidPointCdsMultiStateEngineBuilder
	Multi State Engine Builder class for CDS. More...

class	MidPointIndexCdsEngineBuilder
	Midpoint Engine Builder class for IndexCreditDefaultSwaps. More...

class	MMFutureQuote
	Money Market Future data class. More...

class	Model

class	ModelCG

class	ModelCGImpl

class	ModelData

class	ModelImpl

class	ModelParameter

class	MoneyMarketQuote
	Money market data class. More...

class	MoneynessStrike

class	MultiLegOption

class	MultiLegOptionEngineBuilderBase
	MultiLeg option engine builder base class. More...

class	MultiThreadedProgressIndicator

struct	NegateNode

class	NettingSetDefinition
	Netting Set Definition. More...

class	NettingSetDetails
	Serializable object holding netting set identification data. More...

class	NettingSetManager
	Netting Set Manager. More...

class	NoProgressBar

class	NumericalHaganCmsCouponPricerBuilder

class	NumericalIntegrationIndexCdsOptionEngineBuilder
	Numerical Integration index CDS option engine. More...

class	NumericLgmRiskParticipationAgreementEngine

class	NumericLgmRiskParticipationAgreementEngineTLock

class	OIFutureQuote
	Overnight index future data class. More...

class	OisConvention
	Container for storing Overnight Index Swap conventions. More...

class	OneDimSolverConfig

struct	OperatorDivideNode

struct	OperatorMinusNode

struct	OperatorMultiplyNode

struct	OperatorPlusNode

class	OptionData
	Serializable object holding option data. More...

class	OptionExerciseData

class	OptionPaymentData

class	OptionWrapper
	Option Wrapper. More...

class	OvernightIndexConvention
	Container for storing Overnight Index conventions. More...

class	PairwiseVarSwap

class	PairwiseVarSwapEngineBuilder
	Engine Builder for Pairwise Variance Swaps. More...

class	ParametricSmileConfiguration

struct	ParserError

class	PayLog

struct	PaymentLagInteger

struct	PaymentLagPeriod

class	PerformanceOption_01

struct	PermuteNode

struct	PiecewiseYieldCurveCalibrationInfo

class	PlainInMemoryReport
	InMemoryReport with access to plain types instead of boost::variant<>, to facilitate language bindings. More...

class	Portfolio
	Serializable portfolio. More...

class	PortfolioBasketReferenceDatum

class	PremiumData
	Serializable object holding premium data. More...

class	PriceSegment

class	ProgressIndicator
	Abstract Base class for a Progress Indicator. More...

class	ProgressLog
	Progress Logger that writes the progress using the LOG macro. More...

class	ProgressLogger

class	ProgressMessage

class	ProgressReporter
	Base class for a Progress Reporter. More...

class	ProxyVolatilityConfig

struct	PseudoCurrencyMarketParameters
	Struct to store parameters for commodities to be treatred as pseudo currencies. More...

class	QuantoEquityEuropeanOptionEngineBuilder
	Engine Builder for Quanto European Equity Option Options. More...

class	QuantoEuropeanOptionEngineBuilder
	Abstract Engine Builder for Quanto European Vanilla Options. More...

class	QuantoVanillaOptionEngineBuilder
	Abstract Engine Builder for Quanto Vanilla Options. More...

class	QuoteBasedVolatilityConfig

class	RainbowOption

class	RangeBound
	Serializable obejct holding range bound data. More...

class	RecoveryRateQuote
	Recovery rate data class. More...

class	ReferenceDataManager
	Interface for Reference Data lookups. More...

class	ReferenceDatum
	Base class for reference data. More...

class	ReferenceDatumBuilder
	Template TradeBuilder class. More...

class	ReferenceDatumFactory

class	Report

class	ReportConfig

class	RequiredFixings

struct	RequireNode

class	ReversionParameter

class	RiskParticipationAgreement
	Serializable risk participation agreement. More...

class	RiskParticipationAgreementBaseEngine

class	RiskParticipationAgreementBlackEngineBuilder
	RPA Black engine builder. More...

class	RiskParticipationAgreementEngineBuilderBase
	RPA base engine builder. More...

class	RiskParticipationAgreementLGMGridEngineBuilder
	RPA Numeric LGM base builder. More...

class	RiskParticipationAgreementSwapLGMGridEngineBuilder
	RPA Numeric LGM engine builder for swap underlyings. More...

class	RiskParticipationAgreementTLockLGMGridEngineBuilder
	RPA Numeric LGM engine builder for tlock underlyings. More...

class	RiskParticipationAgreementXCcyBlackEngineBuilder
	RPA XCcy Black engine builder. More...

class	SafeStack

class	ScheduleBuilder

class	ScheduleData
	Serializable schedule data. More...

class	ScheduleDates
	Serializable object holding schedule Dates data. More...

class	ScheduleDerived
	Serializable object holding Derived schedule data. More...

class	ScheduleRules
	Serializable object holding schedule Rules data. More...

class	ScriptedInstrumentAmcCalculator

class	ScriptedInstrumentPricingEngine

class	ScriptedInstrumentPricingEngineCG

class	ScriptedTrade

class	ScriptedTradeEngineBuilder

class	ScriptedTradeEventData

class	ScriptedTradeScriptData

class	ScriptedTradeValueTypeData

class	ScriptEngine

struct	ScriptGrammar

class	ScriptLibraryData

class	ScriptLibraryStorage

class	ScriptParser

class	SeasonalityQuote
	Inflation seasonality data class. More...

class	Security
	Wrapper class for holding Bond Spread and recovery rate quotes. More...

class	SecurityConfig
	Security configuration. More...

class	SecuritySpec
	Security description. More...

class	SecuritySpreadConvention
	Container for storing Bond Spread Rate conventions. More...

class	SecuritySpreadQuote
	Bond spread data class. More...

struct	SequenceNode

struct	SharedPtrMarketDatumComparator

struct	SimmCreditQualifierMapping

class	SimpleProgressBar
	Simple Progress Bar. More...

class	SimpleYieldCurveSegment
	Simple yield curve segment. More...

class	SingleBarrierOptionWrapper

struct	SizeOpNode

struct	SortNode

class	StaticAnalyser

class	StderrLogger
	Stderr Logger. More...

struct	Strike

class	StructuredConfigurationErrorMessage
	Utility classes for Structured configuration errors, contains the configuration type and ID (NettingSetId, CounterParty, etc.) More...

class	StructuredConfigurationWarningMessage
	Utility classes for Structured warnings, contains the configuration type and ID (NettingSetId, CounterParty, etc.) More...

class	StructuredCurveErrorMessage
	Utility class for Structured Curve errors, contains the curve ID. More...

class	StructuredCurveWarningMessage

class	StructuredLogger

class	StructuredLoggingErrorMessage

class	StructuredMessage

class	StructuredModelErrorMessage
	Utility class for Structured Model errors. More...

class	StructuredModelWarningMessage
	Utility class for Structured Model errors. More...

class	StructuredTradeErrorMessage
	Utility class for Structured Trade errors, contains the Trade ID and Type. More...

class	StructuredTradeWarningMessage
	Utility classes for Structured warnings, contains the Trade ID and Type. More...

class	Swap
	Serializable Swap, Single and Cross Currency. More...

class	SwapEngineBuilder
	Engine Builder for Single Currency Swaps. More...

class	SwapEngineBuilderBase
	Engine Builder base class for Single Currency Swaps. More...

class	SwapEngineBuilderDeltaGamma
	Engine Builder for Single Currency Swaps. More...

class	SwapEngineBuilderOptimised
	Engine Builder for Single Currency Swaps. More...

class	SwapIndexConvention
	Container for storing Swap Index conventions. More...

class	SwapQuote
	Swap market data class. More...

class	Swaption
	Serializable Swaption. More...

class	SwaptionEngineBuilder
	Swaption engine builder base class. More...

class	SwaptionQuote
	Swaption data class. More...

class	SwaptionShiftQuote
	Shift data class (for SLN swaption volatilities) More...

class	SwaptionVolatilityCurveConfig
	Swaption volatility curve configuration class. More...

class	SwaptionVolatilityCurveSpec
	Swaption Volatility curve description. More...

class	SwaptionVolCurve
	Wrapper class for building Swaption volatility structures. More...

class	SyntheticCDO
	Serializable CDS Index Tranche (Synthetic CDO) More...

class	TaRF

class	TenorBasisSwapConvention
	Container for storing Tenor Basis Swap conventions. More...

class	TenorBasisTwoSwapConvention
	Container for storing conventions for Tenor Basis Swaps quoted as a spread of two interest rate swaps. More...

class	TenorBasisYieldCurveSegment
	Tenor Basis yield curve segment. More...

class	TimePeriod
	Handles non-contiguous time period. More...

class	TodaysMarket
	Today's Market. More...

struct	TodaysMarketCalibrationInfo

class	TodaysMarketParameters
	Today's Market Parameters. More...

class	Trade
	Trade base class. More...

class	TradeAction
	Serializable object holding a trade action. More...

class	TradeActions
	Serializable object holding generic trade actions. More...

class	TradeBarrier

class	TradeBuilder
	Template TradeBuilder class. More...

class	TradeFactory
	TradeFactory. More...

class	TradeMonetary

class	TradeStrike

class	TrancheData
	Serializable Bond-Basket Data. More...

class	TransitionProbabilityQuote
	Transition Probability data class. More...

class	TreasuryLockData

class	TRS

struct	TrsUnderlyingBuilder

class	TrsUnderlyingBuilderFactory

class	TRSWrapper
	TRS Instrument Wrapper. More...

class	TRSWrapperAccrualEngine

class	Underlying
	Class to hold Underlyings. More...

class	UnderlyingBuilder

struct	ValueTypeWhich

struct	VanillaBondBuilder

class	VanillaInstrument
	Vanilla Instrument Wrapper. More...

class	VanillaOptionEngineBuilder
	Abstract Engine Builder for Vanilla Options. More...

class	VanillaOptionTrade
	Serializable Vanilla Option. More...

struct	VarEvaluationNode

struct	VariableNode

class	VarSwap

class	VarSwapEngineBuilder
	Engine Builder for Variance Swaps. More...

class	VolatilityApoFutureSurfaceConfig

class	VolatilityConfig

class	VolatilityConfigBuilder

class	VolatilityCurveConfig

class	VolatilityDeltaSurfaceConfig

class	VolatilityMoneynessSurfaceConfig

class	VolatilityParameter

class	VolatilityStrikeSurfaceConfig

class	VolatilitySurfaceConfig

class	WeightedAverageYieldCurveSegment
	Weighted average yield curve segment. More...

class	Wildcard

class	WindowBarrierOption

class	WorstOfBasketSwap

class	WrappedMarket
	Wrapped Market. More...

class	XMLDocument
	Small XML Document wrapper class. More...

class	XMLSerializable
	Base class for all serializable classes. More...

class	XMLUtils
	XML Utilities Class. More...

class	YieldCurve
	Wrapper class for building yield term structures. More...

struct	YieldCurveCalibrationInfo

class	YieldCurveConfig
	Yield Curve configuration. More...

class	YieldCurveSegment
	Base class for yield curve segments. More...

class	YieldCurveSpec
	Yield curve description. More...

class	YieldPlusDefaultYieldCurveSegment
	Yield plus default curves segment. More...

class	YieldVolatilityCurveConfig
	Yield volatility curve configuration. More...

class	YieldVolatilityCurveSpec
	Yield volatility curve description. More...

class	YieldVolCurve
	Wrapper class for building Yield volatility structures. More...

class	YoYCapFloor

class	YoYCapFloorEngineBuilder
	Engine Builder for Year on Year Caps, Floors and Collars on an IborIndex. More...

struct	YoYInflationCurveCalibrationInfo

class	YoYInflationSwapQuote
	YoY Inflation swap data class. More...

class	YoYLegData
	Serializable YoY Leg Data. More...

class	YoYSwap

class	YyInflationCapFloorQuote
	YY Cap Floor data class. More...

class	YYLegBuilder

class	ZcInflationCapFloorQuote
	ZC Cap Floor data class. More...

class	ZcInflationSwapQuote
	ZC Inflation swap data class. More...

class	ZeroCouponFixedLegBuilder

class	ZeroCouponFixedLegData
	Serializable Fixed Leg Data. More...

struct	ZeroInflationCurveCalibrationInfo

class	ZeroInflationIndexConvention

class	ZeroQuote

class	ZeroRateConvention
	Container for storing Zero Rate conventions. More...

class	ZeroSpreadedYieldCurveSegment
	Zero Spreaded yield curve segment. More...

Typedefs
typedef boost::bimap< string, CapFloorVolatilityCurveConfig::VolatilityType >	BmType

using	YieldCurveConfigMap = std::map< string, QuantLib::ext::shared_ptr< YieldCurveConfig > >

template<class I >
using	Crv = QuantExt::PiecewisePriceCurve< I, QuantExt::IterativeBootstrap >

template<class C >
using	BS = QuantExt::IterativeBootstrap< C >

using	Helpers = InfJyBuilder::Helpers

template<class T , typename... Args>
using	CachingPricingEngineBuilder = CachingEngineBuilder< T, PricingEngine, Args... >

template<class T , typename... Args>
using	CachingCouponPricerBuilder = CachingEngineBuilder< T, FloatingRateCouponPricer, Args... >

template<class T , typename... Args>
using	CachingInflationCouponPricerBuilder = CachingEngineBuilder< T, InflationCouponPricer, Args... >

template<class T , typename... Args>
using	CachingInflationCashFlowPricerBuilder = CachingEngineBuilder< T, QuantExt::InflationCashFlowPricer, Args... >

using	ASI = CreditDefaultSwapOption::AuctionSettlementInformation

typedef AssetPositionTrsUnderlyingBuilder< ore::data::EquityPosition >	EquityPositionTrsUnderlyingBuilder

typedef AssetPositionTrsUnderlyingBuilder< ore::data::CommodityPosition >	CommodityPositionTrsUnderlyingBuilder

typedef boost::variant< QuantLib::Period, QuantLib::Natural >	PaymentLag

using	ASTNodePtr = QuantLib::ext::shared_ptr< ASTNode >

using	ScriptGrammarIterator = boost::spirit::line_pos_iterator< std::string::const_iterator >

using	ValueType = boost::variant< RandomVariable, EventVec, CurrencyVec, IndexVec, DaycounterVec, Filter >

typedef boost::log::sinks::synchronous_sink< boost::log::sinks::text_file_backend >	file_sink

typedef boost::log::sinks::synchronous_sink< boost::log::sinks::text_ostream_backend >	text_sink

using	ADCP = CommodityFutureConvention::AveragingData::CalculationPeriod

using	PST = PriceSegment::Type

using	CQF = CommodityQuantityFrequency

typedef rapidxml::xml_node< char >	XMLNode

Enumerations
enum class	YieldCurveType { Discount = 0 , Yield = 1 , EquityDividend = 2 }

enum class	MarketObject { DiscountCurve = 0 , YieldCurve = 1 , IndexCurve = 2 , SwapIndexCurve = 3 , FXSpot = 4 , FXVol = 5 , SwaptionVol = 6 , DefaultCurve = 7 , CDSVol = 8 , BaseCorrelation = 9 , CapFloorVol = 10 , ZeroInflationCurve = 11 , YoYInflationCurve = 12 , ZeroInflationCapFloorVol = 13 , YoYInflationCapFloorVol = 14 , EquityCurve = 15 , EquityVol = 16 , Security = 17 , CommodityCurve = 18 , CommodityVolatility = 19 , Correlation = 20 , YieldVol = 21 }

enum class	ParamType { Constant , Piecewise }
	Supported calibration parameter type. More...

enum class	CalibrationType { Bootstrap , BestFit , None }
	Supported calibration types. More...

enum class	CalibrationStrategy { CoterminalATM , CoterminalDealStrike , UnderlyingATM , UnderlyingDealStrike , None }
	Supported calibration strategies. More...

enum class	CommodityPayRelativeTo { CalculationPeriodEndDate , CalculationPeriodStartDate , TerminationDate , FutureExpiryDate }

enum class	CommodityPriceType { Spot , FutureSettlement }

enum class	CommodityPricingDateRule { FutureExpiryDate , None }

enum class	CdsTier { SNRFOR , SUBLT2 , SNRLAC , SECDOM , JRSUBUT2 , PREFT1 , LIEN1 , LIEN2 , LIEN3 }
	CDS debt tier enumeration. More...

enum class	CdsDocClause { CR , MM , MR , XR , CR14 , MM14 , MR14 , XR14 }
	CDS documentation clause enumeration. More...

enum class	IsdaRulesDefinitions { y2003 = 2003 , y2014 = 2014 }
	ISDA CDS documentation rules set enumeration. More...

enum class	CreditEventType { BANKRUPTCY , FAILURE_TO_PAY , RESTRUCTURING , OBLIGATION_ACCELERATION , OBLIGATION_DEFAULT , REPUDIATION_MORATORIUM , GOVERNMENTAL_INTERVENTION }
	ISDA credit event types enumeration. More...

enum class	CreditEventTiers { SNR , SUB , SNRLAC , SNR_SUB , SNR_SNRLAC , SUB_SNRLAC , SNR_SUB_SNRLAC }
	ISDA credit event seniority sets enumeration. More...

enum class	MarketContext { irCalibration , fxCalibration , eqCalibration , pricing }

enum class	AmortizationType { None , FixedAmount , RelativeToInitialNotional , RelativeToPreviousNotional , Annuity , LinearToMaturity }

enum class	AssetClass { EQ , FX , COM , IR , INF , CR , BOND , BOND_INDEX }

enum class	Extrapolation { None , UseInterpolator , Flat }
	Enumeration for holding various extrapolation settings. More...

enum class	MomentType { Variance , Volatility }

enum class	CreditPortfolioSensitivityDecomposition { Underlying , NotionalWeighted , LossWeighted , DeltaWeighted }
	Enumeration CreditPortfolioSensitivityDecomposition. More...

enum	MporCashFlowMode { Unspecified , NonePay , BothPay , WePay , TheyPay }

Functions
VolatilityType	volatilityType (CapFloorVolatilityCurveConfig::VolatilityType type)
	Imply QuantLib::VolatilityType from CapFloorVolatilityCurveConfig::VolatilityType. More...

bool	operator< (const CommodityFutureConvention::ProhibitedExpiry &lhs, const CommodityFutureConvention::ProhibitedExpiry &rhs)
	Compare two prohibited expiries. More...

std::ostream &	operator<< (std::ostream &out, Convention::Type type)

std::ostream &	operator<< (std::ostream &out, CorrelationCurveConfig::CorrelationType t)

std::ostream &	operator<< (std::ostream &out, CorrelationCurveConfig::Dimension t)

bool	indexNameLessThan (const std::string &index1, const std::string &index2)

template<class T >
void	addMinimalCurves (const char *nodeName, const map< string, QuantLib::ext::shared_ptr< T > > &m, map< string, QuantLib::ext::shared_ptr< T > > &n, CurveSpec::CurveType curveType, const map< CurveSpec::CurveType, set< string > > configIds)

std::ostream &	operator<< (std::ostream &out, EquityCurveConfig::Type t)

EquityCurveConfig::Type	parseEquityCurveConfigType (const std::string &str)

std::ostream &	operator<< (std::ostream &out, GenericYieldVolatilityCurveConfig::VolatilityType t)

std::ostream &	operator<< (std::ostream &out, InflationCapFloorVolatilityCurveConfig::VolatilityType t)

std::ostream &	operator<< (std::ostream &out, InflationCapFloorVolatilityCurveConfig::QuoteType t)

ReportConfig	effectiveReportConfig (const ReportConfig &globalConfig, const ReportConfig &localConfig)

bool	operator< (const VolatilityConfig &vc1, const VolatilityConfig &vc2)

YieldCurveSegment::Type	parseYieldCurveSegment (const string &s)

bool	interpOnOpt (CapFloorVolatilityCurveConfig &config)

QuantLib::ext::shared_ptr< MarketDatum >	makeDummyMarketDatum (const Date &d, const std::string &name)

bool	operator< (const CurveSpec &lhs, const CurveSpec &rhs)
	Relational operators for CurveSpecs. More...

bool	operator== (const CurveSpec &lhs, const CurveSpec &rhs)

bool	operator< (const QuantLib::ext::shared_ptr< CurveSpec > &lhs, const QuantLib::ext::shared_ptr< CurveSpec > &rhs)

bool	operator== (const QuantLib::ext::shared_ptr< CurveSpec > &lhs, const QuantLib::ext::shared_ptr< CurveSpec > &rhs)

std::ostream &	operator<< (std::ostream &os, const CurveSpec &spec)
	Stream operator for CurveSpec. More...

std::ostream &	operator<< (std::ostream &os, const CurveSpec::CurveType &t)
	Stream operator for CurveType. More...

QuantLib::ext::shared_ptr< CurveSpec >	parseCurveSpec (const string &s)
	function to convert a string into a curve spec More...

CurveSpec::CurveType	parseCurveConfigurationType (const std::string &)
	function to convert a curve configuration node string into a curve spec type More...

bool	operator== (const Expiry &lhs, const Expiry &rhs)

ostream &	operator<< (std::ostream &os, const Expiry &expiry)
	Write `strike` to stream. More...

QuantLib::ext::shared_ptr< Expiry >	parseExpiry (const std::string &strExpiry)
	Parse an Expiry from its string representation, `strExpiry`. More...

void	applyFixings (const std::set< Fixing > &fixings)
	Utility to write a vector of fixings in the QuantLib index manager's fixing history. More...

bool	operator< (const Fixing &f1, const Fixing &f2)
	Compare fixings. More...

Handle< QuantExt::CorrelationTermStructure >	getCorrelationCurve (const std::string &index1, const std::string &index2, const map< string, QuantLib::ext::shared_ptr< CorrelationCurve > > &correlationCurves)

QuantLib::Date	getInflationSwapStart (const Date &asof, const InflationSwapConvention &convention)

void	load (InMemoryLoader &loader, const vector< string > &data, bool isMarket, bool implyTodaysFixings)

void	loadDataFromBuffers ( InMemoryLoader &loader, const std::vector< std::string > &marketData, const std::vector< std::string > &fixingData, bool implyTodaysFixings=false)
	Utility function for loading market quotes and fixings from an in memory csv buffer. More...

PseudoCurrencyMarketParameters	buildPseudoCurrencyMarketParameters (const std::map< string, string > &pricingEngineGlobalParameters=std::map< string, string >())
	Function to build parameters from PricingEngine GlobalParametrs. More...

std::ostream &	operator<< (std::ostream &os, const struct PseudoCurrencyMarketParameters &p)

bool	operator< (const MarketDatum &a, const MarketDatum &b)

std::ostream &	operator<< (std::ostream &out, const MarketDatum::QuoteType &type)

std::ostream &	operator<< (std::ostream &out, const MarketDatum::InstrumentType &type)

Date	getDateFromDateOrPeriod (const string &token, Date asof, QuantLib::Calendar cal=QuantLib::WeekendsOnly(), QuantLib::BusinessDayConvention bdc=QuantLib::BusinessDayConvention::Following)
	Get a date from a date string or period. More...

boost::variant< QuantLib::Period, FXForwardQuote::FxFwdString >	parseFxPeriod (const string &s)
	Convert text to QuantLib::Period of Fx forward string. More...

QuantLib::Period	fxFwdQuoteTenor (const boost::variant< QuantLib::Period, FXForwardQuote::FxFwdString > &term)

QuantLib::Period	fxFwdQuoteStartTenor (const boost::variant< QuantLib::Period, FXForwardQuote::FxFwdString > &term, const QuantLib::ext::shared_ptr< FXConvention > &fxConvention)

bool	matchFxFwdStringTerm (const boost::variant< QuantLib::Period, FXForwardQuote::FxFwdString > &term, const FXForwardQuote::FxFwdString &fxfwdString)

QuantLib::ext::shared_ptr< MarketDatum >	parseMarketDatum (const Date &asof, const string &datumName, const Real &value)
	Function to parse a market datum. More...

bool	operator== (const BaseStrike &lhs, const BaseStrike &rhs)

ostream &	operator<< (std::ostream &os, const BaseStrike &strike)
	Write `strike` to stream. More...

ostream &	operator<< (ostream &os, DeltaVolQuote::DeltaType type)

ostream &	operator<< (ostream &os, DeltaVolQuote::AtmType type)

ostream &	operator<< (std::ostream &os, MoneynessStrike::Type type)
	Write MoneynessStrike::Type, `type`, to stream. More...

MoneynessStrike::Type	parseMoneynessType (const std::string &type)
	Parse MoneynessStrike::Type from `type`. More...

QuantLib::ext::shared_ptr< BaseStrike >	parseBaseStrike (const std::string &strStrike)
	Parse a Strike from its string representation, `strStrike`. More...

std::ostream &	operator<< (std::ostream &os, QuantLib::DeltaVolQuote::DeltaType type)
	Write `deltaType` to stream. Not provided in QuantLib so add it here. More...

std::ostream &	operator<< (std::ostream &os, QuantLib::DeltaVolQuote::AtmType type)
	Write `atmType` to stream. Not provided in QuantLib so add it here. More...

template<class Archive >
void	registerBaseStrike (Archive &ar)

std::ostream &	operator<< (std::ostream &o, const DependencyGraph::Node &n)

std::ostream &	operator<< (std::ostream &out, const MarketObject &o)
	Market Configuration structure. More...

std::set< MarketObject >	getMarketObjectTypes ()

template<template< class > class CurveType>
QuantLib::ext::shared_ptr< YieldTermStructure >	buildYieldCurve (const vector< Date > &dates, const vector< QuantLib::Real > &rates, const DayCounter &dayCounter, YieldCurve::InterpolationMethod interpolationMethod, Size n=0)
	Templated function to build a YieldTermStructure and apply interpolation methods to it. More...

QuantLib::ext::shared_ptr< YieldTermStructure >	zerocurve (const vector< Date > &dates, const vector< Rate > &yields, const DayCounter &dayCounter, YieldCurve::InterpolationMethod interpolationMethod, Size n=0)
	Create a Interpolated Zero Curve and apply interpolators. More...

QuantLib::ext::shared_ptr< YieldTermStructure >	discountcurve (const vector< Date > &dates, const vector< DiscountFactor > &dfs, const DayCounter &dayCounter, YieldCurve::InterpolationMethod interpolationMethod, Size n=0)
	Create a Interpolated Discount Curve and apply interpolators. More...

QuantLib::ext::shared_ptr< YieldTermStructure >	forwardcurve (const vector< Date > &dates, const vector< Rate > &forwards, const DayCounter &dayCounter, YieldCurve::InterpolationMethod interpolationMethod, Size n=0)
	Create a Interpolated Forward Curve and apply interpolators. More...

YieldCurve::InterpolationMethod	parseYieldCurveInterpolationMethod (const string &s)
	Helper function for parsing interpolation method. More...

YieldCurve::InterpolationVariable	parseYieldCurveInterpolationVariable (const string &s)
	Helper function for parsing interpolation variable. More...

std::ostream &	operator<< (std::ostream &out, const YieldCurve::InterpolationMethod m)
	Output operator for interpolation method. More...

template<class T >
QuantLib::ext::shared_ptr< CalibrationInstrument >	createCalibrationInstrument ()

CrCirData::CalibrationStrategy	parseCirCalibrationStrategy (const string &s)

std::ostream &	operator<< (std::ostream &oss, const CrCirData::CalibrationStrategy &s)

std::vector< std::string >	pairToStrings (std::pair< std::string, std::string > p)

QuantExt::CrossAssetModel::Discretization	parseDiscretization (const string &s)

std::ostream &	operator<< (std::ostream &oss, const ParamType &type)
	Convert enumerated class value into a string. More...

ParamType	parseParamType (const string &s)
	Convert parameter type string into enumerated class value. More...

CalibrationType	parseCalibrationType (const string &s)
	Convert calibration type string into enumerated class value. More...

std::ostream &	operator<< (std::ostream &oss, const CalibrationType &type)
	Convert enumerated class value into a string. More...

CalibrationStrategy	parseCalibrationStrategy (const string &s)
	Convert calibration strategy string into enumerated class value. More...

std::ostream &	operator<< (std::ostream &oss, const CalibrationStrategy &type)
	Convert enumerated class value into a string. More...

LgmData::ReversionType	parseReversionType (const string &s)
	Enum parsers. More...

std::ostream &	operator<< (std::ostream &oss, const LgmData::ReversionType &type)
	Enum to string. More...

LgmData::VolatilityType	parseVolatilityType (const string &s)

std::ostream &	operator<< (std::ostream &oss, const LgmData::VolatilityType &type)

QuantExt::AnalyticLgmSwaptionEngine::FloatSpreadMapping	parseFloatSpreadMapping (const string &s)

std::ostream &	operator<< (std::ostream &oss, const QuantExt::AnalyticLgmSwaptionEngine::FloatSpreadMapping &m)

std::string	getCalibrationDetails (LgmCalibrationInfo &info, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &basket, const QuantLib::ext::shared_ptr< IrLgm1fParametrization > &parametrization)

std::string	getCalibrationDetails (const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &basket, const QuantLib::ext::shared_ptr< FxBsParametrization > &parametrization, const QuantLib::ext::shared_ptr< Parametrization > &domesticIrModel)

std::string	getCalibrationDetails (const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &basket, const QuantLib::ext::shared_ptr< FxBsParametrization > &parametrization, const QuantLib::ext::shared_ptr< IrLgm1fParametrization > &domesticLgm)

std::string	getCalibrationDetails (const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &basket, const QuantLib::ext::shared_ptr< EqBsParametrization > &parametrization, const QuantLib::ext::shared_ptr< Parametrization > &domesticIrModel)

std::string	getCalibrationDetails (const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &basket, const QuantLib::ext::shared_ptr< EqBsParametrization > &parametrization, const QuantLib::ext::shared_ptr< IrLgm1fParametrization > &domesticLgm)

std::string	getCalibrationDetails (const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &basket, const QuantLib::ext::shared_ptr< CommoditySchwartzParametrization > &parametrization)

std::string	getCalibrationDetails (const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &basket, const QuantLib::ext::shared_ptr< InfDkParametrization > &parametrization, bool indexIsInterpolated)

string	getCalibrationDetails (const vector< QuantLib::ext::shared_ptr< CalibrationHelper > > &rrBasket, const vector< QuantLib::ext::shared_ptr< CalibrationHelper > > &idxBasket, const QuantLib::ext::shared_ptr< InfJyParameterization > &p, bool calibrateRealRateVol)

string	getCalibrationDetails (const QuantLib::ext::shared_ptr< IrLgm1fParametrization > &parametrization)

Date	optionMaturity (const boost::variant< Date, Period > &maturity, const QuantLib::Calendar &calendar, const QuantLib::Date &referenceDate)

Real	cpiCapFloorStrikeValue (const QuantLib::ext::shared_ptr< BaseStrike > &strike, const QuantLib::ext::shared_ptr< ZeroInflationTermStructure > &curve, const QuantLib::Date &optionMaturityDate)
	Return a cpi cap/floor strike value, the input strike can be of type absolute or atm forward. More...

Real	yoyCapFloorStrikeValue (const QuantLib::ext::shared_ptr< BaseStrike > &strike, const QuantLib::ext::shared_ptr< YoYInflationTermStructure > &curve, const QuantLib::Date &optionMaturityDate)
	Return a yoy cap/floor strike value, the input strike can be of type absolute or atm forward. More...

Real	atmForward (const Real s0, const Handle< YieldTermStructure > &r, const Handle< YieldTermStructure > &q, const Real t)
	helper function that computes the atm forward More...

template<typename Helper >
Real	getCalibrationError (const std::vector< QuantLib::ext::shared_ptr< Helper > > &basket)

QuantLib::Date	optionMaturity (const boost::variant< QuantLib::Date, QuantLib::Period > &maturity, const QuantLib::Calendar &calendar, const QuantLib::Date &referenceDate=Settings::instance().evaluationDate())
	Return an option's maturity date, given an explicit date or a period. More...

bool	operator< (const BasketConstituent &lhs, const BasketConstituent &rhs)

void	populateFromBondReferenceData (std::string &subType, std::string &issuerId, std::string &settlementDays, std::string &calendar, std::string &issueDate, std::string &priceQuoteMethod, std::string &priceQuoteBaseValue, std::string &creditCurveId, std::string &creditGroup, std::string &referenceCurveId, std::string &incomeCurveId, std::string &volatilityCurveId, std::vector< LegData > &coupons, const std::string &name, const QuantLib::ext::shared_ptr< BondReferenceDatum > &bondRefData, const std::string &startDate="", const std::string &endDate="")
	Populate bond data from name and ReferenceDataManager. More...

Date	getOpenEndDateReplacement (const std::string &replacementPeriodStr, const Calendar &calendar)

std::vector< Handle< DefaultProbabilityTermStructure > >	buildPerformanceOptimizedDefaultCurves (const std::vector< Handle< DefaultProbabilityTermStructure > > &curves)

std::vector< QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > >	buildPerformanceOptimizedDefaultCurves (const std::vector< QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > > &curves)
	Engine Builder base class for CDOs. More...

GFunctionFactory::YieldCurveModel	ycmFromString (const string &s)

bool	operator== (const CDSEngineKey &lhs, const CDSEngineKey &rhs)

bool	operator< (const CDSEngineKey &lhs, const CDSEngineKey &rhs)

bool	operator!= (const CDSEngineKey &lhs, const CDSEngineKey &rhs)

bool	operator> (const CDSEngineKey &lhs, const CDSEngineKey &rhs)

bool	operator<= (const CDSEngineKey &lhs, const CDSEngineKey &rhs)

bool	operator>= (const CDSEngineKey &lhs, const CDSEngineKey &rhs)

CommodityPayRelativeTo	parseCommodityPayRelativeTo (const string &s)

ostream &	operator<< (ostream &out, const CommodityPayRelativeTo &cprt)

CommodityPriceType	parseCommodityPriceType (const string &s)

ostream &	operator<< (ostream &out, const CommodityPriceType &cpt)

CommodityPricingDateRule	parseCommodityPricingDateRule (const string &s)

ostream &	operator<< (std::ostream &out, const CommodityPricingDateRule &cpdr)

QuantLib::ext::shared_ptr< OptionPaymentDateAdjuster >	makeOptionPaymentDateAdjuster (CommoditySpreadOptionData &optionData, const std::vector< Date > &expiryDates)

CdsTier	parseCdsTier (const string &s)

ostream &	operator<< (ostream &out, const CdsTier &cdsTier)

CdsDocClause	parseCdsDocClause (const string &s)

ostream &	operator<< (ostream &out, const CdsDocClause &cdsDocClause)

IsdaRulesDefinitions	parseIsdaRulesDefinitions (const string &s)

ostream &	operator<< (ostream &out, const IsdaRulesDefinitions &isdaRulesDefinitions)

IsdaRulesDefinitions	isdaRulesDefinitionsFromDocClause (const CdsDocClause &cdsDocClause)

CreditEventType	parseCreditEventType (const string &s)

ostream &	operator<< (ostream &out, const CreditEventType &creditEventType)

bool	isTriggeredDocClause (CdsDocClause contractDocClause, CreditEventType creditEventType)

CreditEventTiers	parseCreditEventTiers (const string &s)

ostream &	operator<< (ostream &out, const CreditEventTiers &creditEventTiers)

bool	isAuctionedSeniority (CdsTier contractTier, CreditEventTiers creditEventTiers)

bool	tryParseCdsInformation (string strInfo, CdsReferenceInformation &cdsInfo)

std::pair< std::string, std::string >	getLowerAndUpperBound (const std::string &type, const std::string &binaryLevelA, const std::string &binaryLevelB)

bool	operator== (const EngineData &lhs, const EngineData &rhs)

bool	operator!= (const EngineData &lhs, const EngineData &rhs)

QuantExt::Leg	makeEquityMarginLeg (const LegData &data, const QuantLib::ext::shared_ptr< EquityIndex2 > &equityCurve, const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &fxIndex, const QuantLib::Date &openEndDateReplacement)

bool	operator< (const RequiredFixings::FixingEntry &lhs, const RequiredFixings::FixingEntry &rhs)

bool	operator< (const RequiredFixings::InflationFixingEntry &lhs, const RequiredFixings::InflationFixingEntry &rhs)

bool	operator< (const RequiredFixings::ZeroInflationFixingEntry &lhs, const RequiredFixings::ZeroInflationFixingEntry &rhs)

std::ostream &	operator<< (std::ostream &out, const ore::data::RequiredFixings::FixingEntry &f)

std::ostream &	operator<< (std::ostream &out, const std::set< ore::data::RequiredFixings::FixingEntry > &entries)

std::ostream &	operator<< (std::ostream &out, const std::set< ore::data::RequiredFixings::InflationFixingEntry > &entries)

std::ostream &	operator<< (std::ostream &out, const std::set< ore::data::RequiredFixings::ZeroInflationFixingEntry > &entries)

std::ostream &	operator<< (std::ostream &out, const RequiredFixings &requiredFixings)

void	addToRequiredFixings (const QuantLib::Leg &leg, const QuantLib::ext::shared_ptr< FixingDateGetter > &fixingDateGetter)

void	amendInflationFixingDates (std::map< std::string, RequiredFixings::FixingDates > &fixings)

void	addMarketFixingDates (const Date &asof, map< string, RequiredFixings::FixingDates > &fixings, const TodaysMarketParameters &mktParams, const Period &iborLookback, const Period &oisLookback, const Period &bmaLookback, const Period &inflationLookback)

void	addMarketFixingDates (const QuantLib::Date &asof, std::map< std::string, RequiredFixings::FixingDates > &fixings, const TodaysMarketParameters &mktParams, const QuantLib::Period &iborLookback=5 QuantLib::Days, const QuantLib::Period &oisLookback=4 QuantLib::Months, const QuantLib::Period &bmaLookback=2 QuantLib::Weeks, const QuantLib::Period &inflationLookback=1 QuantLib::Years)

QuantLib::ext::shared_ptr< QuantExt::FormulaBasedIndex >	makeFormulaBasedIndex (const std::string &formula, const QuantLib::ext::shared_ptr< ore::data::Market > market, const std::string &configuration, std::map< std::string, QuantLib::ext::shared_ptr< QuantLib::InterestRateIndex > > &indexMaps, const Calendar &fixingCalendar)

Leg	makeFormulaBasedLeg (const LegData &data, const QuantLib::ext::shared_ptr< QuantExt::FormulaBasedIndex > &formulaBasedIndex, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const std::map< std::string, QuantLib::ext::shared_ptr< QuantLib::InterestRateIndex > > &indexMaps, const QuantLib::Date &openEndDateReplacement)

bool	checkBarrier (Real spot, Barrier::Type type, Real barrier)

bool	lessThan (const string &s1, const string &s2)

Leg	makeNotionalLeg (const Leg &refLeg, const bool initNomFlow, const bool finalNomFlow, const bool amortNomFlow, const Natural notionalPaymentLag, const BusinessDayConvention paymentConvention, const Calendar paymentCalendar, const bool excludeIndexing)

Leg	makeEquityLeg (const LegData &data, const QuantLib::ext::shared_ptr< EquityIndex2 > &equityCurve, const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &fxIndex, const QuantLib::Date &openEndDateReplacement)

vector< double >	buildAmortizationScheduleLinearToMaturity (const vector< double > &notionals, const Schedule &schedule, const AmortizationData &data)

template<class T >
QuantLib::ext::shared_ptr< LegAdditionalData >	createLegData ()

Leg	makeNonStandardIborLeg (const QuantLib::ext::shared_ptr< IborIndex > &index, const std::vector< Date > &calcDates, const std::vector< Date > &payDatesInput, const std::vector< Date > &fixingDatesInput, const std::vector< Date > &resetDatesInput, const Size fixingDays, const std::vector< Real > &notionals, const std::vector< Date > &notionalDatesInput, const std::vector< Real > &spreadsInput, const std::vector< Date > &spreadDatesInput, const std::vector< Real > &gearingsInput, const std::vector< Date > &gearingDatesInput, const bool strictNotionalDates, const DayCounter &dayCounter, const Calendar &payCalendar, const BusinessDayConvention payConv, const Period &payLag, const bool isInArrears)

Leg	makeNonStandardFixedLeg (const std::vector< Date > &calcDates, const std::vector< Date > &payDatesInput, const std::vector< Real > &notionals, const std::vector< Date > &notionalDatesInput, const std::vector< Real > &rates, const std::vector< Date > &rateDatesInput, const bool strictNotionalDates, const DayCounter &dayCounter, const Calendar &payCalendar, const BusinessDayConvention payConv, const Period &payLag)

QuantLib::Leg	makeNonStandardIborLeg (const QuantLib::ext::shared_ptr< QuantLib::IborIndex > &index, const std::vector< QuantLib::Date > &calcDates, const std::vector< QuantLib::Date > &payDates, const std::vector< QuantLib::Date > &fixingDates, const std::vector< QuantLib::Date > &resetDates, const QuantLib::Size fixingDays, const std::vector< QuantLib::Real > &notionals, const std::vector< QuantLib::Date > &notionalDates, const std::vector< QuantLib::Real > &spreads, const std::vector< QuantLib::Date > &spreadDates, const std::vector< QuantLib::Real > &gearings, const std::vector< QuantLib::Date > &gearingDates, const bool strictNotionalDates, const QuantLib::DayCounter &dayCounter, const QuantLib::Calendar &payCalendar, const QuantLib::BusinessDayConvention payConv, const QuantLib::Period &payLag, const bool isInArrears)

QuantLib::Leg	makeNonStandardFixedLeg (const std::vector< QuantLib::Date > &calcDates, const std::vector< QuantLib::Date > &payDates, const std::vector< QuantLib::Real > &notionals, const std::vector< QuantLib::Date > &notionalDates, const std::vector< QuantLib::Real > &rates, const std::vector< QuantLib::Date > &rateDates, const bool strictNotionalDates, const QuantLib::DayCounter &dayCounter, const QuantLib::Calendar &payCalendar, const QuantLib::BusinessDayConvention payConv, const QuantLib::Period &payLag)

CSA::Type	parseCsaType (const string &s)

std::ostream &	operator<< (std::ostream &out, CSA::Type t)

bool	operator< (const NettingSetDetails &lhs, const NettingSetDetails &rhs)
	Comparison operators. More...

bool	operator== (const NettingSetDetails &lhs, const NettingSetDetails &rhs)

bool	operator!= (const NettingSetDetails &lhs, const NettingSetDetails &rhs)

std::ostream &	operator<< (std::ostream &out, const NettingSetDetails &nettingSetDetails)
	Enable writing of netting set details. More...

ostream &	operator<< (std::ostream &out, const OptionPaymentData::RelativeTo &relativeTo)
	Print RelativeTo enum values. More...

std::pair< QuantLib::ext::shared_ptr< Trade >, bool >	buildTrade (QuantLib::ext::shared_ptr< Trade > &trade, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const std::string &context, const bool ignoreTradeBuildFail, const bool buildFailedTrades, const bool emitStructuredError)

bool	operator== (const RangeBound &a, const RangeBound &b)

std::ostream &	operator<< (std::ostream &out, const RangeBound &t)

std::ostream &	operator<< (std::ostream &out, const std::vector< RangeBound > &t)

bool	operator< (const CreditIndexConstituent &lhs, const CreditIndexConstituent &rhs)
	Compare CreditIndexConstituent instances using their name. More...

template<class T >
QuantLib::ext::shared_ptr< AbstractReferenceDatumBuilder >	createReferenceDatumBuilder ()

Schedule	makeSchedule (const ScheduleDates &data)

Schedule	makeSchedule (const ScheduleDerived &data, const Schedule &baseSchedule)

Schedule	makeSchedule (const ScheduleRules &data, const Date &openEndDateReplacement)

Schedule	makeSchedule (const ScheduleData &data, const Date &openEndDateReplacement, const map< string, QuantLib::Schedule > &baseSchedules)

QuantLib::Schedule	makeSchedule (const ScheduleData &data, const QuantLib::Date &openEndDateReplacement=QuantLib::Null< QuantLib::Date >(), const map< string, QuantLib::Schedule > &baseSchedules=map< string, QuantLib::Schedule >())
	Functions. More...

QuantLib::Schedule	makeSchedule (const ScheduleRules &rules, const QuantLib::Date &openEndDateReplacement=QuantLib::Null< QuantLib::Date >())

QuantLib::Schedule	makeSchedule (const ScheduleDerived &derived, const QuantLib::Schedule &baseSchedule)

std::string	isdaSubProductSwap (const std::string &tradeId, const vector< LegData > &legData)

void	addTRSRequiredFixings (RequiredFixings &fixings, const std::vector< Leg > &returnLegs, const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &ind=nullptr)

TRS::FundingData::NotionalType	parseTrsFundingNotionalType (const std::string &s)

std::ostream &	operator<< (std::ostream &os, const TRS::FundingData::NotionalType t)

void	modifyBondTRSLeg (QuantLib::Leg &leg, QuantLib::Date issueDate)

Leg	makeBondTRSLeg (const std::vector< Date > &valuationDates, const std::vector< Date > &paymentDates, const BondIndexBuilder &bondIndexBuilder, Real initialPrice, QuantLib::ext::shared_ptr< QuantExt::FxIndex > fxIndex)

Leg	makeBondTRSLeg (const std::vector< Date > &valuationDates, const std::vector< Date > &paymentDates, const BondIndexBuilder &bondIndexBuilder, QuantLib::Real initialPrice=QuantLib::Null< QuantLib::Real >(), QuantLib::ext::shared_ptr< QuantExt::FxIndex > fxIndex=nullptr)

ScriptedTradeEventData	readEventData (XMLNode *node)

XMLNode *	writeEventData (XMLDocument &doc, ScriptedTradeEventData &eventData)

QuantLib::ext::shared_ptr< ore::data::InMemoryReport >	addColumnToExisitingReport (const std::string &columnName, const std::string &value, const QuantLib::ext::shared_ptr< ore::data::InMemoryReport > &report)

QuantLib::ext::shared_ptr< ore::data::InMemoryReport >	addColumnsToExisitingReport (const QuantLib::ext::shared_ptr< ore::data::InMemoryReport > &newColsReport, const QuantLib::ext::shared_ptr< ore::data::InMemoryReport > &report)

QuantLib::ext::shared_ptr< ore::data::InMemoryReport >	concatenateReports (const std::vector< QuantLib::ext::shared_ptr< ore::data::InMemoryReport > > &reports)

std::string	to_string (const LocationInfo &l)

std::string	to_string (const ASTNodePtr root, const bool printLocationInfo)

void	reset (const ASTNodePtr root)

std::string	to_script (const ASTNodePtr root)

std::ostream &	operator<< (std::ostream &out, const Context &context)

std::size_t	addModelParameter (ComputationGraph &g, std::vector< std::pair< std::size_t, std::function< double(void)> > > &m, const std::string &id, std::function< double(void)> f)

Date	getSloppyDate (const Date &d, const bool sloppyDates, const std::set< Date > &dates)

ASTNodePtr	generateRandomAST (const Size maxSequenceLength, const Size maxDepth, const Size seed)

std::ostream &	operator<< (std::ostream &out, const ParserError &error)

std::string	printCodeContext (std::string script, const ASTNode *loc, bool compact)

std::vector< Date >	coarsenDateGrid (const std::vector< Date > &dates, const std::string &rule, const Date &referenceDate)

std::pair< std::string, ScriptedTradeScriptData >	getScript (const ScriptedTrade &scriptedTrade, const ScriptLibraryData &scriptLibrary, const std::string &purpose, const bool fallBackOnEmptyPurpose)

ASTNodePtr	parseScript (const std::string &code)

std::pair< std::string, Period >	convertIndexToCamCorrelationEntry (const std::string &i)

void	checkDuplicateName (const QuantLib::ext::shared_ptr< Context > context, const std::string &name)

QuantLib::ext::shared_ptr< Context >	makeContext (Size nPaths, const std::string &gridCoarsening, const std::vector< std::string > &schedulesEligibleForCoarsening, const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceData, const std::vector< ScriptedTradeEventData > &events, const std::vector< ScriptedTradeValueTypeData > &numbers, const std::vector< ScriptedTradeValueTypeData > &indices, const std::vector< ScriptedTradeValueTypeData > &currencies, const std::vector< ScriptedTradeValueTypeData > &daycounters)

void	addNewSchedulesToContext (QuantLib::ext::shared_ptr< Context > context, const std::vector< ScriptedTradeScriptData::NewScheduleData > &newSchedules)

void	amendContextVariablesSizes (QuantLib::ext::shared_ptr< Context > context, const Size newSize)

std::ostream &	operator<< (std::ostream &o, const IndexInfo &i)

QuantLib::ext::shared_ptr< QuantExt::CommodityIndex >	parseScriptedCommodityIndex (const std::string &indexName, const QuantLib::Date &obsDate)

QL_DEPRECATED_DISABLE_WARNING std::pair< QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex >, std::string >	parseScriptedInflationIndex (const std::string &indexName)

QL_DEPRECATED_ENABLE_WARNING std::string	scriptedIndexName (const QuantLib::ext::shared_ptr< Underlying > &underlying)

Size	getInflationSimulationLag (const QuantLib::ext::shared_ptr< ZeroInflationIndex > &index)

std::map< std::string, std::vector< Real > >	getCalibrationStrikes (const std::vector< ScriptedTradeScriptData::CalibrationData > &calibrationSpec, const QuantLib::ext::shared_ptr< Context > &context)

std::ostream &	operator<< (std::ostream &out, const EventVec &a)

std::ostream &	operator<< (std::ostream &out, const CurrencyVec &a)

std::ostream &	operator<< (std::ostream &out, const IndexVec &a)

std::ostream &	operator<< (std::ostream &out, const DaycounterVec &a)

bool	deterministic (const ValueType &v)

Size	size (const ValueType &v)

bool	operator== (const EventVec &a, const EventVec &b)

bool	operator== (const CurrencyVec &a, const CurrencyVec &b)

bool	operator== (const IndexVec &a, const IndexVec &b)

bool	operator== (const DaycounterVec &a, const DaycounterVec &b)

ValueType	operator+ (const ValueType &x, const ValueType &y)

ValueType	operator- (const ValueType &x, const ValueType &y)

ValueType	operator* (const ValueType &x, const ValueType &y)

ValueType	operator/ (const ValueType &x, const ValueType &y)

ValueType	min (const ValueType &x, const ValueType &y)

ValueType	max (const ValueType &x, const ValueType &y)

ValueType	pow (const ValueType &x, const ValueType &y)

ValueType	operator- (const ValueType &x)

ValueType	abs (const ValueType &x)

ValueType	exp (const ValueType &x)

ValueType	log (const ValueType &x)

ValueType	sqrt (const ValueType &x)

ValueType	normalCdf (const ValueType &x)

ValueType	normalPdf (const ValueType &x)

ValueType	typeSafeAssign (ValueType &x, const ValueType &y)

Filter	equal (const ValueType &x, const ValueType &y)

Filter	notequal (const ValueType &x, const ValueType &y)

Filter	lt (const ValueType &x, const ValueType &y)

Filter	gt (const ValueType &x, const ValueType &y)

Filter	leq (const ValueType &x, const ValueType &y)

Filter	geq (const ValueType &x, const ValueType &y)

Filter	logicalNot (const ValueType &x)

Filter	logicalAnd (const ValueType &x, const ValueType &y)

Filter	logicalOr (const ValueType &x, const ValueType &y)

QuantLib::ext::shared_ptr< CurrencyHedgedEquityIndexDecomposition >	loadCurrencyHedgedIndexDecomposition (const std::string &name, const QuantLib::ext::shared_ptr< ReferenceDataManager > &refDataMgr, const QuantLib::ext::shared_ptr< CurveConfigurations > &curveConfigs)

QuantLib::ext::shared_ptr< CurrencyHedgedEquityIndexDecomposition >	loadCurrencyHedgedIndexDecomposition (const std::string &name, const QuantLib::ext::shared_ptr< ore::data::ReferenceDataManager > &refDataMgr, const QuantLib::ext::shared_ptr< ore::data::CurveConfigurations > &curveConfigs)

void	dataBuilders ()

QuantLib::ext::shared_ptr< DateGrid >	generateShiftedDateGrid (const QuantLib::ext::shared_ptr< DateGrid > &dg, const QuantLib::Period &shift)

QuantLib::ext::shared_ptr< DateGrid >	combineDateGrids (const QuantLib::ext::shared_ptr< DateGrid > &dg1, const QuantLib::ext::shared_ptr< DateGrid > &dg2)

vector< vector< string > >	flowAnalysis (const QuantLib::Leg &)
	Flow Analysis. More...

QuantExt::CompiledFormula	parseFormula (const std::string &text, std::vector< std::string > &variables)

template<class T >
T	parseFormula (const std::string &text, const std::function< T(std::string)> &variableMapping={})

double	gtZero (const double x)

double	geqZero (const double x)

double	max (const double x, const double y)

double	min (const double x, const double y)

void	checkOneToOne (const map< string, QuantLib::ext::shared_ptr< OvernightIndex > > &onIndices, const map< string, QuantLib::ext::shared_ptr< IborIndexParser > > &iborIndices)

QuantLib::ext::shared_ptr< FxIndex >	parseFxIndex (const string &s, const Handle< Quote > &fxSpot=Handle< Quote >(), const Handle< YieldTermStructure > &sourceYts=Handle< YieldTermStructure >(), const Handle< YieldTermStructure > &targetYts=Handle< YieldTermStructure >(), const bool useConventions=false)
	Convert std::string to QuantExt::FxIndex. More...

QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 >	parseEquityIndex (const string &s)
	Convert std::string (e.g SP5) to QuantExt::EquityIndex. More...

QuantLib::ext::shared_ptr< QuantLib::Index >	parseGenericIndex (const string &s)
	Convert std::string (GENERIC-...) to QuantExt::Index. More...

bool	tryParseIborIndex (const string &s, QuantLib::ext::shared_ptr< IborIndex > &index)
	Try to convert std::string to QuantLib::IborIndex. More...

QuantLib::ext::shared_ptr< IborIndex >	parseIborIndex (const string &s, const Handle< YieldTermStructure > &h=Handle< YieldTermStructure >())
	Convert std::string to QuantLib::IborIndex. More...

QuantLib::ext::shared_ptr< IborIndex >	parseIborIndex (const string &s, string &tenor, const Handle< YieldTermStructure > &h)

bool	isGenericIborIndex (const string &indexName)
	Return true if the `indexName` is that of a generic ibor index, otherwise false. More...

pair< bool, QuantLib::ext::shared_ptr< ZeroInflationIndex > >	isInflationIndex (const string &indexName)

bool	isEquityIndex (const std::string &indexName)
	Return true if the `indexName` is that of an EquityIndex, otherwise false. More...

bool	isCommodityIndex (const std::string &indexName)
	Return true if the `indexName` is that of an CommodityIndex, otherwise false. More...

bool	isGenericIndex (const string &indexName)

QuantLib::ext::shared_ptr< SwapIndex >	parseSwapIndex (const string &s, const Handle< YieldTermStructure > &forwarding=Handle< YieldTermStructure >(), const Handle< YieldTermStructure > &discounting=Handle< YieldTermStructure >())
	Convert std::string to QuantLib::SwapIndex. More...

QuantLib::ext::shared_ptr< ZeroInflationIndex >	parseZeroInflationIndex (const string &s, const Handle< ZeroInflationTermStructure > &h=Handle< ZeroInflationTermStructure >())
	Convert std::string to QuantLib::ZeroInflationIndex. More...

QuantLib::ext::shared_ptr< ZeroInflationIndex >	parseZeroInflationIndex (const string &s, bool isInterpolated, const Handle< ZeroInflationTermStructure > &h)

QuantLib::ext::shared_ptr< BondIndex >	parseBondIndex (const string &s)
	Convert std::string to QuantExt::BondIndex. More...

QuantLib::ext::shared_ptr< ConstantMaturityBondIndex >	parseConstantMaturityBondIndex (const string &s)
	Convert std::string to QuantExt::ConstantMaturityBondIndex. More...

QuantLib::ext::shared_ptr< QuantExt::CommodityIndex >	parseCommodityIndex (const string &name, bool hasPrefix, const Handle< PriceTermStructure > &ts, const Calendar &cal, const bool enforceFutureIndex)

QuantLib::ext::shared_ptr< Index >	parseIndex (const string &s)
	Convert std::string to QuantLib::Index. More...

bool	isOvernightIndex (const std::string &indexName)
	Return true if the `indexName` is that of an overnight index, otherwise false. More...

bool	isBmaIndex (const std::string &indexName)
	Return true if the `indexName` is that of an bma/sifma index, otherwise false. More...

string	internalIndexName (const string &indexName)

bool	isFxIndex (const std::string &indexName)

std::string	inverseFxIndex (const std::string &indexName)

QuantLib::ext::shared_ptr< IborIndex >	parseIborIndex (const std::string &strIndex, std::string &outTenor, const QuantLib::Handle< QuantLib::YieldTermStructure > &h=QuantLib::Handle< QuantLib::YieldTermStructure >())
	Convert std::string to QuantLib::IborIndex and return the tenor string component of the index. More...

QuantLib::ext::shared_ptr< QuantExt::CommodityIndex >	parseCommodityIndex (const std::string &name, bool hasPrefix=true, const QuantLib::Handle< QuantExt::PriceTermStructure > &ts=QuantLib::Handle< QuantExt::PriceTermStructure >(), const QuantLib::Calendar &cal=QuantLib::NullCalendar(), const bool enforceFutureIndex=true)

std::pair< QuantLib::Date, QuantLib::Period >	getStartAndLag (const QuantLib::Date &asof, const InflationSwapConvention &conv)

QuantLib::Date	getInflationSwapStart (const QuantLib::Date &asof, const InflationSwapConvention &conv)

std::ostream &	operator<< (std::ostream &out, const StructuredMessage::Category &category)

std::ostream &	operator<< (std::ostream &out, const StructuredMessage::Group &group)

string	xccyCurveName (const string &ccyCode)

Handle< YieldTermStructure >	xccyYieldCurve (const QuantLib::ext::shared_ptr< Market > &market, const string &ccyCode, const string &configuration)

Handle< YieldTermStructure >	xccyYieldCurve (const QuantLib::ext::shared_ptr< Market > &market, const string &ccyCode, bool &outXccyExists, const string &configuration)

Handle< YieldTermStructure >	indexOrYieldCurve (const QuantLib::ext::shared_ptr< Market > &market, const std::string &name, const std::string &configuration)

std::string	securitySpecificCreditCurveName (const std::string &securityId, const std::string &creditCurveId)

std::string	creditCurveNameFromSecuritySpecificCreditCurveName (const std::string &name)

QuantLib::Handle< QuantExt::CreditCurve >	securitySpecificCreditCurve (const QuantLib::ext::shared_ptr< Market > &market, const std::string &securityId, const std::string &creditCurveId, const std::string &configuration)

std::string	prettyPrintInternalCurveName (std::string name)

QuantLib::ext::shared_ptr< QuantExt::FxIndex >	buildFxIndex (const string &fxIndex, const string &domestic, const string &foreign, const QuantLib::ext::shared_ptr< Market > &market, const string &configuration, bool useXbsCurves)

std::tuple< Natural, Calendar, BusinessDayConvention >	getFxIndexConventions (const string &index)

std::pair< std::string, QuantLib::Period >	splitCurveIdWithTenor (const std::string &creditCurveId)

QuantLib::Handle< QuantExt::CreditCurve >	indexCdsDefaultCurve (const QuantLib::ext::shared_ptr< Market > &market, const std::string &creditCurveId, const std::string &config)

Date	parseDate (const string &s)
	Convert std::string to QuantLib::Date. More...

Real	parseReal (const string &s)
	Convert text to Real. More...

Real	parseRealOrNull (const string &s)
	Convert text to Real, empty string to Null<Real>() More...

bool	tryParseReal (const string &s, QuantLib::Real &result)
	Attempt to convert text to Real. More...

Integer	parseInteger (const string &s)
	Convert text to QuantLib::Integer. More...

bool	parseBool (const string &s)
	Convert text to bool. More...

Calendar	parseCalendar (const string &s)
	Convert text to QuantLib::Calendar. More...

bool	isOnePeriod (const string &s)
	return true if s represents a period of the form [0-9][D\|W\|M\|Y] (i.e. 1Y6M would return false) More...

Period	parsePeriod (const string &s)
	Convert text to QuantLib::Period. More...

BusinessDayConvention	parseBusinessDayConvention (const string &s)
	Convert text to QuantLib::BusinessDayConvention. More...

DayCounter	parseDayCounter (const string &s)
	Convert text to QuantLib::DayCounter. More...

Currency	parseCurrency (const string &s)
	Convert text to QuantLib::Currency. More...

QuantExt::ConfigurableCurrency::Type	parseCurrencyType (const string &s)
	Convert text to QuantExt::ConfigurableCurrency::Type (Major, Minor, Metal, Crypto) More...

Currency	parseMinorCurrency (const string &s)
	Convert text to QuantLib::Currency for minor currencies e.g GBp -> GBPCurrency() More...

Currency	parseCurrencyWithMinors (const string &s)
	Convert text to QuantLib::Currency. More...

pair< Currency, Currency >	parseCurrencyPair (const string &s, const string &delimiters)
	Convert text to std::pair<QuantLib::Currency, QuantLib::Currency> More...

bool	checkCurrency (const string &code)
	check for vaid currency code, including minors and pseudo currencies More...

bool	isPseudoCurrency (const string &code)
	check for pseudo currency = precious metal or crypto currency *‍/ More...

bool	isPreciousMetal (const string &code)
	check for precious metal *‍/ More...

bool	isCryptoCurrency (const string &code)
	check for crypto currency *‍/ More...

QuantLib::Real	convertMinorToMajorCurrency (const std::string &s, QuantLib::Real value)
	Convert a value from a minor ccy to major. More...

DateGeneration::Rule	parseDateGenerationRule (const string &s)
	Convert text to QuantLib::DateGeneration::Rule. More...

Frequency	parseFrequency (const string &s)
	Convert text to QuantLib::Frequency. More...

Compounding	parseCompounding (const string &s)
	Convert text to QuantLib::Compounding;. More...

QuantLib::Bond::Price::Type	parseBondPriceType (const string &s)
	Convert text to QuantLib::Bond::Price::Type. More...

Position::Type	parsePositionType (const string &s)
	Convert text to QuantLib::Position::Type. More...

Protection::Side	parseProtectionSide (const string &s)
	Convert text to QuantLib::Protection::Side. More...

Settlement::Type	parseSettlementType (const string &s)
	Convert text to QuantLib::Settlement::Type. More...

Settlement::Method	parseSettlementMethod (const string &s)
	Convert text to QuantLib::Settlement::Method. More...

Exercise::Type	parseExerciseType (const string &s)
	Convert text to QuantLib::Exercise::Type. More...

Option::Type	parseOptionType (const string &s)
	Convert text to QuantLib::Option::Type. More...

boost::variant< QuantLib::Date, QuantLib::Period >	parseDateOrPeriod (const string &s)
	Convert text to QuantLib::Period or QuantLib::Date. More...

void	parseDateOrPeriod (const string &s, Date &d, Period &p, bool &isDate)

QuantLib::LsmBasisSystem::PolynomialType	parsePolynomType (const std::string &s)
	Convert text to QuantLib::LsmBasisSystem::PolynomialType. More...

std::ostream &	operator<< (std::ostream &os, QuantLib::LsmBasisSystem::PolynomialType a)
	Write QuantLib::LsmBasisSystem::PolynomialType to stream. More...

SobolBrownianGenerator::Ordering	parseSobolBrownianGeneratorOrdering (const std::string &s)
	Convert text to QuantLib::SobolBrownianGenerator::Ordering. More...

SobolRsg::DirectionIntegers	parseSobolRsgDirectionIntegers (const std::string &s)
	Convert text to QuantLib::SobolRsg::DirectionIntegers. More...

Weekday	parseWeekday (const string &s)

Month	parseMonth (const string &s)

PaymentLag	parsePaymentLag (const string &s)
	Convert text to PaymentLag. More...

std::vector< string >	parseListOfValues (string s, const char escape, const char delim, const char quote)

AmortizationType	parseAmortizationType (const std::string &s)

SequenceType	parseSequenceType (const std::string &s)
	Convert string to sequence type. More...

QuantLib::CPI::InterpolationType	parseObservationInterpolation (const std::string &s)
	Convert string to observation interpolation. More...

FdmSchemeDesc	parseFdmSchemeDesc (const std::string &s)
	Convert string to fdm scheme desc. More...

AssetClass	parseAssetClass (const std::string &s)
	Convert text to ore::data::AssetClass. More...

std::ostream &	operator<< (std::ostream &os, AssetClass a)
	Write ore::data::AssetClass to stream. More...

DeltaVolQuote::AtmType	parseAtmType (const std::string &s)
	Convert text to QuantLib::DeltaVolQuote::AtmType. More...

DeltaVolQuote::DeltaType	parseDeltaType (const std::string &s)
	Convert text to QuantLib::DeltaVolQuote::DeltaType. More...

Extrapolation	parseExtrapolation (const string &s)
	Parse Extrapolation from string. More...

std::ostream &	operator<< (std::ostream &os, Extrapolation extrap)
	Write Extrapolation, `extrap`, to stream. More...

VolatilityType	parseVolatilityQuoteType (const string &s)

CapFloor::Type	parseCapFloorType (const string &s)

YoYInflationCapFloor::Type	parseYoYInflationCapFloorType (const string &s)

QuantExt::CrossAssetModel::AssetType	parseCamAssetType (const string &s)

pair< string, string >	parseBoostAny (const boost::any &anyType, Size precision)

QuantLib::RateAveraging::Type	parseOvernightIndexFutureNettingType (const std::string &s)
	Convert text to QuantLib::RateAveraging::Type. More...

std::ostream &	operator<< (std::ostream &os, QuantLib::RateAveraging::Type t)
	Write QuantLib::RateAveraging::Type to stream. More...

FutureConvention::DateGenerationRule	parseFutureDateGenerationRule (const std::string &s)
	Convert text to FutureConvention::DateGeneration. More...

std::ostream &	operator<< (std::ostream &os, FutureConvention::DateGenerationRule t)
	Write QuantLib::RateAveraging::Type to stream. More...

InflationSwapConvention::PublicationRoll	parseInflationSwapPublicationRoll (const std::string &s)
	Convert text to InflationSwapConvention::PublicationRoll. More...

QuantLib::Rounding::Type	parseRoundingType (const std::string &s)
	Convert text to QuantLib::Rounding. More...

Barrier::Type	parseBarrierType (const string &s)
	Convert std::string to QuantLib::BarrierType. More...

DoubleBarrier::Type	parseDoubleBarrierType (const string &s)
	Convert std::string to QuantLib::DoubleBarrierType. More...

ostream &	operator<< (std::ostream &os, InflationSwapConvention::PublicationRoll pr)
	Write InflationSwapConvention::PublicationRoll to stream. More...

std::ostream &	operator<< (std::ostream &os, SobolBrownianGenerator::Ordering t)
	Write QuantLib::SobolBrownianGenerator::Ordering to stream. More...

std::ostream &	operator<< (std::ostream &os, SobolRsg::DirectionIntegers t)
	Write QuantLib::SobolRsg::DirectionIntegers to stream. More...

std::ostream &	operator<< (std::ostream &os, QuantExt::CrossAssetModel::Discretization type)
	Enum to string used in ScenarioGeneratorData's toXML. More...

ADCP	parseAveragingDataPeriod (const std::string &s)
	Convert text to CommodityFutureConvention::AveragingData::CalculationPeriod. More...

ostream &	operator<< (std::ostream &os, CommodityFutureConvention::AveragingData::CalculationPeriod cp)
	Write CommodityFutureConvention::AveragingData::CalculationPeriod to stream. More...

PriceSegment::Type	parsePriceSegmentType (const std::string &s)
	Convert text to PriceSegment::Type. More...

ostream &	operator<< (std::ostream &os, PriceSegment::Type pst)
	Write PriceSegment::Type to stream. More...

CommodityQuantityFrequency	parseCommodityQuantityFrequency (const std::string &s)
	Convert text to QuantExt::CommodityQuantityFrequency. More...

ostream &	operator<< (std::ostream &os, QuantExt::CommodityQuantityFrequency cqf)
	Write QuantExt::CommodityQuantityFrequency to stream. More...

ostream &	operator<< (ostream &os, Rounding::Type t)

CdsOption::StrikeType	parseCdsOptionStrikeType (const string &s)

Average::Type	parseAverageType (const std::string &s)

QuantExt::BondIndex::PriceQuoteMethod	parsePriceQuoteMethod (const std::string &s)

std::ostream &	operator<< (std::ostream &os, QuantExt::BondIndex::PriceQuoteMethod)
	Write PriceQuoteMethod to stream. More...

std::vector< std::string >	getCorrelationTokens (const std::string &name)
	Helper function to get the two tokens in a correlation name Index2:Index1. More...

string	fxDominance (const string &s1, const string &s2)
	Convert FX pair to market standard dominance. More...

string	normaliseFxIndex (const std::string &indexName)
	Convert FX index name to market standard dominance. More...

MomentType	parseMomentType (const std::string &s)
	Convert text to ore::data::MomentType. More...

CreditPortfolioSensitivityDecomposition	parseCreditPortfolioSensitivityDecomposition (const std::string &s)
	Convert text to CreditPortfolioSensitivitiyDecomposition. More...

std::ostream &	operator<< (std::ostream &os, const CreditPortfolioSensitivityDecomposition d)
	Output operator for CreditPortfolioSensitivityDecomposition. More...

QuantLib::Pillar::Choice	parsePillarChoice (const std::string &s)
	Convert text to QuantLib::Pillar::Choice. More...

QuantExt::McMultiLegBaseEngine::RegressorModel	parseRegressorModel (const std::string &s)
	Convert text to QuantExt::McMultiLegBaseEngine::RegressorModel. More...

MporCashFlowMode	parseMporCashFlowMode (const std::string &s)
	Convert text to MporCashFlowMode. More...

std::ostream &	operator<< (std::ostream &os, MporCashFlowMode t)
	Write MporCashFlowMode to stream. More...

SabrParametricVolatility::ModelVariant	parseSabrParametricVolatilityModelVariant (const std::string &s)
	Parse SabrParametricVolatility::ModelVariant. More...

std::ostream &	operator<< (std::ostream &out, SabrParametricVolatility::ModelVariant m)

std::ostream &	operator<< (std::ostream &os, Exercise::Type type)

void	parseDateOrPeriod (const string &s, QuantLib::Date &d, QuantLib::Period &p, bool &isDate)
	Convert text to QuantLib::Period or QuantLib::Date (deprecated version) More...

template<class T >
std::vector< T >	parseListOfValues (string s, std::function< T(string)> parser)
	Convert comma separated list of values to vector of values. More...

template<class T >
std::vector< T >	parseVectorOfValues (std::vector< std::string > str, std::function< T(string)> parser)

template<class T >
bool	tryParse (const std::string &str, T &obj, std::function< T(const std::string &)> parser)

bool	tryParseCurrency (const std::string &str, Currency &obj)

std::ostream &	operator<< (std::ostream &out, QuantExt::SabrParametricVolatility::ModelVariant m)
	Write SabrParametricVolatility::ModelVariant. More...

std::ostream &	operator<< (std::ostream &os, QuantLib::Exercise::Type type)
	Write QuantLib::Exercise::Type. More...

Strike	parseStrike (const std::string &s)
	Convert text to Strike. More...

std::ostream &	operator<< (std::ostream &out, const Strike &s)
	Convert Strike to text. More...

bool	operator== (const Strike &s1, const Strike &s2)
	Logical comparison of strikes. More...

QuantLib::Real	computeAbsoluteStrike (const Strike &s, const QuantLib::Real atm, const QuantLib::Real atmf)
	Convenience function that computes an absolute strike. More...

std::ostream &	operator<< (std::ostream &out, const TimePeriod &t)

TimePeriod	totalTimePeriod (std::vector< std::string > timePeriods, Size mporDays, const QuantLib::Calendar &calendar)

std::string	to_string (const Date &date)

string	to_string (bool aBool)
	Convert bool to std::string. More...

std::string	to_string (const Period &period)

std::string	to_string (const QuantLib::Date &date)
	Convert QuantLib::Date to std::string. More...

std::string	to_string (const QuantLib::Period &period)
	Convert QuantLib::Period to std::string. More...

template<class T >
std::string	to_string (const std::vector< T > &vec, const std::string &sep=",")
	Convert vector to std::string. More...

template<class T >
std::string	to_string (const std::set< T > &set, const std::string &sep=",")
	Convert set to std::string. More...

template<class T >
std::string	to_string (const T &t)
	Convert type to std::string. More...

template<typename T , typename Compare >
std::vector< std::size_t >	sort_permutation (const std::vector< T > &vec, Compare &compare)

template<typename T >
std::vector< T >	apply_permutation (const std::vector< T > &vec, const std::vector< std::size_t > &p)

template<typename T >
void	apply_permutation_in_place (std::vector< T > &vec, const std::vector< std::size_t > &p)

void	partitionQuotes (const set< string > &quoteNames, set< string > &names, set< string > &regexes)

void	partitionQuotes (const set< string > &quoteNames, set< string > &names, set< string > &regexes, std::set< std::string > &prefixes, const bool aggressivePrefixes)

template<class C >
boost::optional< Wildcard >	getUniqueWildcard (const C &c)
	checks if at most one element in C has a wild card and returns it in this case More...

Utilities for building QuantLib Legs
QuantExt::Leg	makeEquityMarginLeg (const ore::data::LegData &data, const QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 > &equityCurve, const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &fxIndex=nullptr, const QuantLib::Date &openEndDateReplacement=QuantLib::Null< QuantLib::Date >())

Leg	makeSimpleLeg (const LegData &data)

Leg	makeFixedLeg (const LegData &data, const QuantLib::Date &openEndDateReplacement)

Leg	makeZCFixedLeg (const LegData &data, const QuantLib::Date &openEndDateReplacement)

Leg	makeIborLeg (const LegData &data, const QuantLib::ext::shared_ptr< IborIndex > &index, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const bool attachPricer, const QuantLib::Date &openEndDateReplacement)

Leg	makeOISLeg (const LegData &data, const QuantLib::ext::shared_ptr< OvernightIndex > &index, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const bool attachPricer, const QuantLib::Date &openEndDateReplacement)

Leg	makeBMALeg (const LegData &data, const QuantLib::ext::shared_ptr< QuantExt::BMAIndexWrapper > &indexWrapper, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const QuantLib::Date &openEndDateReplacement)

Leg	makeCPILeg (const LegData &data, const QuantLib::ext::shared_ptr< ZeroInflationIndex > &index, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const QuantLib::Date &openEndDateReplacement)

Leg	makeYoYLeg (const LegData &data, const QuantLib::ext::shared_ptr< InflationIndex > &index, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const QuantLib::Date &openEndDateReplacement)

Leg	makeCMSLeg (const LegData &data, const QuantLib::ext::shared_ptr< QuantLib::SwapIndex > &swapIndex, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const bool attachPricer, const QuantLib::Date &openEndDateReplacement)

Leg	makeCMBLeg (const LegData &data, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const bool attachPricer, const QuantLib::Date &openEndDateReplacement)

Leg	makeDigitalCMSLeg (const LegData &data, const QuantLib::ext::shared_ptr< QuantLib::SwapIndex > &swapIndex, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const bool attachPricer, const QuantLib::Date &openEndDateReplacement)

Leg	makeCMSSpreadLeg (const LegData &data, const QuantLib::ext::shared_ptr< QuantLib::SwapSpreadIndex > &swapSpreadIndex, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const bool attachPricer, const QuantLib::Date &openEndDateReplacement)

Leg	makeDigitalCMSSpreadLeg (const LegData &data, const QuantLib::ext::shared_ptr< QuantLib::SwapSpreadIndex > &swapSpreadIndex, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const QuantLib::Date &openEndDateReplacement)

Real	currentNotional (const Leg &leg)

Real	originalNotional (const Leg &leg)

vector< double >	buildAmortizationScheduleFixedAmount (const vector< double > &notionals, const Schedule &schedule, const AmortizationData &data)

vector< double >	buildAmortizationScheduleRelativeToInitialNotional (const vector< double > &notionals, const Schedule &schedule, const AmortizationData &data)

vector< double >	buildAmortizationScheduleRelativeToPreviousNotional (const vector< double > &notionals, const Schedule &schedule, const AmortizationData &data)

vector< double >	buildAmortizationScheduleFixedAnnuity (const vector< double > &notionals, const vector< double > &rates, const Schedule &schedule, const AmortizationData &data, const DayCounter &dc)

void	applyAmortization (std::vector< Real > &notionals, const LegData &data, const Schedule &schedule, const bool annuityAllowed, const std::vector< Real > &rates)

void	applyIndexing (Leg &leg, const LegData &data, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, RequiredFixings &requiredFixings, const QuantLib::Date &openEndDateReplacement, const bool useXbsCurves)

Leg	joinLegs (const std::vector< Leg > &legs)

Leg	buildNotionalLeg (const LegData &data, const Leg &leg, RequiredFixings &requiredFixings, const QuantLib::ext::shared_ptr< Market > &market, const std::string &configuration)

std::string	getCmbLegCreditRiskCurrency (const CMBLegData &ld, const QuantLib::ext::shared_ptr< ReferenceDataManager > &refData)

std::pair< std::string, SimmCreditQualifierMapping >	getCmbLegCreditQualifierMapping (const CMBLegData &ld, const QuantLib::ext::shared_ptr< ReferenceDataManager > &refData, const std::string &tradeId, const std::string &tradeType)

Leg	makeNotionalLeg (const Leg &refLeg, const bool initNomFlow, const bool finalNomFlow, const bool amortNomFlow, const QuantLib::Natural notionalPaymentLag, const BusinessDayConvention paymentConvention, const Calendar paymentCalendar, const bool excludeIndexing=true)

Leg	makeEquityLeg (const LegData &data, const QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 > &equityCurve, const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &fxIndex=nullptr, const QuantLib::Date &openEndDateReplacement=Null< Date >())

template<typename T >
vector< T >	buildScheduledVector (const vector< T > &values, const vector< string > &dates, const Schedule &schedule, const bool checkAllValuesAppearInResult=false)

template<typename T >
vector< T >	normaliseToSchedule (const vector< T > &values, const Schedule &schedule, const T &defaultValue)

template<typename T >
vector< T >	buildScheduledVectorNormalised (const vector< T > &values, const vector< string > &dates, const Schedule &schedule, const T &defaultValue, const bool checkAllValuesAppearInResult=false)

template<typename T >
vector< T >::const_iterator	checkAllValuesAppearInScheduledVector (const vector< T > &scheduledVecotr, const vector< T > &inputValues)

Variables
const BmType	volatilityTypeMap

const set< string >	validInterps = {"Linear", "LinearFlat", "BackwardFlat", "Cubic", "CubicFlat"}

boost::bimap< std::string, TRS::FundingData::NotionalType >	types

const string	xccyCurveNamePrefix = "__XCCY__"

Compare <code>CorrelationFactor</code>s.
typedef std::pair< CorrelationFactor, CorrelationFactor >	CorrelationKey

bool	operator< (const CorrelationFactor &lhs, const CorrelationFactor &rhs)

bool	operator== (const CorrelationFactor &lhs, const CorrelationFactor &rhs)

bool	operator!= (const CorrelationFactor &lhs, const CorrelationFactor &rhs)

ostream &	operator<< (std::ostream &out, const CorrelationFactor &f)
	Allow `CorrelationFactor`s to be written. More...

CorrelationFactor	parseCorrelationFactor (const string &name, const char separator)

Detailed Description

Data Checks namespace

Typedef Documentation

◆ BmType

typedef boost::bimap<string, CapFloorVolatilityCurveConfig::VolatilityType> BmType

Definition at line 44 of file capfloorvolcurveconfig.cpp.

◆ YieldCurveConfigMap

using YieldCurveConfigMap = std::map<string, QuantLib::ext::shared_ptr<YieldCurveConfig> >

Definition at line 714 of file yieldcurveconfig.hpp.

◆ Crv

using Crv = QuantExt::PiecewisePriceCurve<I, QuantExt::IterativeBootstrap>

Definition at line 444 of file commoditycurve.cpp.

◆ BS

using BS = QuantExt::IterativeBootstrap<C>

Definition at line 445 of file commoditycurve.cpp.

◆ Helpers

using Helpers = InfJyBuilder::Helpers

Definition at line 75 of file infjybuilder.cpp.

◆ CachingPricingEngineBuilder

using CachingPricingEngineBuilder = CachingEngineBuilder<T, PricingEngine, Args...>

Definition at line 83 of file cachingenginebuilder.hpp.

◆ CachingCouponPricerBuilder

using CachingCouponPricerBuilder = CachingEngineBuilder<T, FloatingRateCouponPricer, Args...>

Definition at line 86 of file cachingenginebuilder.hpp.

◆ CachingInflationCouponPricerBuilder

using CachingInflationCouponPricerBuilder = CachingEngineBuilder<T, InflationCouponPricer, Args...>

Definition at line 89 of file cachingenginebuilder.hpp.

◆ CachingInflationCashFlowPricerBuilder

using CachingInflationCashFlowPricerBuilder = CachingEngineBuilder<T, QuantExt::InflationCashFlowPricer, Args...>

Definition at line 92 of file cachingenginebuilder.hpp.

◆ ASI

using ASI = CreditDefaultSwapOption::AuctionSettlementInformation

Definition at line 141 of file creditdefaultswapoption.cpp.

◆ EquityPositionTrsUnderlyingBuilder

typedef AssetPositionTrsUnderlyingBuilder<ore::data::EquityPosition> EquityPositionTrsUnderlyingBuilder

Definition at line 121 of file trsunderlyingbuilder.hpp.

◆ CommodityPositionTrsUnderlyingBuilder

typedef AssetPositionTrsUnderlyingBuilder<ore::data::CommodityPosition> CommodityPositionTrsUnderlyingBuilder

Definition at line 122 of file trsunderlyingbuilder.hpp.

◆ PaymentLag

typedef boost::variant<QuantLib::Period, QuantLib::Natural> PaymentLag

Definition at line 32 of file types.hpp.

◆ ASTNodePtr

using ASTNodePtr = QuantLib::ext::shared_ptr<ASTNode>

Definition at line 46 of file ast.hpp.

◆ ScriptGrammarIterator

using ScriptGrammarIterator = boost::spirit::line_pos_iterator<std::string::const_iterator>

Definition at line 46 of file grammar.hpp.

◆ ValueType

using ValueType = boost::variant<RandomVariable, EventVec, CurrencyVec, IndexVec, DaycounterVec, Filter>

Definition at line 60 of file value.hpp.

◆ CorrelationKey

typedef std::pair<CorrelationFactor, CorrelationFactor> CorrelationKey

The key for storing the correlation data is the pair of factors.

Definition at line 61 of file correlationmatrix.hpp.

◆ file_sink

typedef boost::log::sinks::synchronous_sink<boost::log::sinks::text_file_backend> file_sink

Definition at line 120 of file log.hpp.

◆ text_sink

typedef boost::log::sinks::synchronous_sink<boost::log::sinks::text_ostream_backend> text_sink

Definition at line 121 of file log.hpp.

◆ ADCP

using ADCP = CommodityFutureConvention::AveragingData::CalculationPeriod

Definition at line 1135 of file parsers.cpp.

◆ PST

using PST = PriceSegment::Type

Definition at line 1157 of file parsers.cpp.

◆ CQF

using CQF = CommodityQuantityFrequency

Definition at line 1191 of file parsers.cpp.

◆ XMLNode

typedef rapidxml::xml_node<char> XMLNode

Definition at line 60 of file xmlutils.hpp.

Enumeration Type Documentation

◆ YieldCurveType

enum class YieldCurveType

strong

Enumerator
Discount
Yield
EquityDividend

Definition at line 59 of file market.hpp.

                          {
    Discount = 0, // Chosen to match MarketObject::DiscountCurve
    Yield = 1,    // Chosen to match MarketObject::YieldCurve
    EquityDividend = 2
};

◆ MarketObject

enum class MarketObject

strong

Enumerator
DiscountCurve
YieldCurve
IndexCurve
SwapIndexCurve
FXSpot
FXVol
SwaptionVol
DefaultCurve
CDSVol
BaseCorrelation
CapFloorVol
ZeroInflationCurve
YoYInflationCurve
ZeroInflationCapFloorVol
YoYInflationCapFloorVol
EquityCurve
EquityVol
Security
CommodityCurve
CommodityVolatility
Correlation
YieldVol

Definition at line 65 of file market.hpp.

                        {
    DiscountCurve = 0,
    YieldCurve = 1,
    IndexCurve = 2,
    SwapIndexCurve = 3,
    FXSpot = 4,
    FXVol = 5,
    SwaptionVol = 6,
    DefaultCurve = 7,
    CDSVol = 8,
    BaseCorrelation = 9,
    CapFloorVol = 10,
    ZeroInflationCurve = 11,
    YoYInflationCurve = 12,
    ZeroInflationCapFloorVol = 13,
    YoYInflationCapFloorVol = 14,
    EquityCurve = 15,
    EquityVol = 16,
    Security = 17,
    CommodityCurve = 18,
    CommodityVolatility = 19,
    Correlation = 20,
    YieldVol = 21
};

◆ ParamType

enum class ParamType

strong

Supported calibration parameter type.

Enumerator
Constant
Piecewise

Definition at line 35 of file irmodeldata.hpp.

                     {
    Constant,
    Piecewise // i.e. time-dependent, but piecewise constant
};

◆ CalibrationType

enum class CalibrationType

strong

Supported calibration types.

Enumerator
Bootstrap	Choose this option if the component's calibration strategy is expected to yield a perfect match of model to market prices. For example, this can be achieved when calibrating an IR component to a series of co-terminal swaptions with given mean reversion speed and piecewise volatility function (alpha) where jump times coincide with expiry dates in the swaption basket. Similarly, when calibrating an FX component to a series of FX Options. The calibration routine will throw an exception if no perfect match is achieved.
BestFit	Choose this if no perfect match like above can be expected, for example when an IR component with constant parameters is calibrated to a basket of swaptions. The calibration routine will consequently not throw an exception when the match is imperfect.
None	No calibration

Definition at line 46 of file irmodeldata.hpp.

                           {
    /*! Choose this option if the component's calibration strategy is expected to
      yield a perfect match of model to market prices. For example, this can be
      achieved when calibrating an IR component to a series of co-terminal
      swaptions with given mean reversion speed and piecewise volatility
      function (alpha) where jump times coincide with expiry dates in the swaption
      basket. Similarly, when calibrating an FX component to a series of FX Options.
      The calibration routine will throw an exception if no perfect match is
      achieved.
     */
    Bootstrap,
    /*! Choose this if no perfect match like above can be expected, for example when
      an IR component with constant parameters is calibrated to a basket of swaptions.
      The calibration routine will consequently not throw an exception when the match
      is imperfect.
     */
    BestFit,
    /*! No calibration
     */
    None
};

◆ CalibrationStrategy

enum class CalibrationStrategy

strong

Supported calibration strategies.

Enumerator
CoterminalATM
CoterminalDealStrike
UnderlyingATM
UnderlyingDealStrike
None

Definition at line 69 of file irmodeldata.hpp.

69{ CoterminalATM, CoterminalDealStrike, UnderlyingATM, UnderlyingDealStrike, None };

ore::data::CalibrationStrategy::UnderlyingDealStrike

@ UnderlyingDealStrike

ore::data::CalibrationStrategy::CoterminalDealStrike

@ CoterminalDealStrike

ore::data::CalibrationStrategy::CoterminalATM

@ CoterminalATM

ore::data::CalibrationStrategy::UnderlyingATM

@ UnderlyingATM

◆ CommodityPayRelativeTo

enum class CommodityPayRelativeTo

strong

Enumerator
CalculationPeriodEndDate
CalculationPeriodStartDate
TerminationDate
FutureExpiryDate

Definition at line 33 of file commoditylegdata.hpp.

                                  {
    CalculationPeriodEndDate,
    CalculationPeriodStartDate,
    TerminationDate,
    FutureExpiryDate
};

◆ CommodityPriceType

enum class CommodityPriceType

strong

Enumerator
Spot
FutureSettlement

Definition at line 42 of file commoditylegdata.hpp.

42{ Spot, FutureSettlement };

ore::data::CommodityPriceType::Spot

@ Spot

ore::data::CommodityPriceType::FutureSettlement

@ FutureSettlement

◆ CommodityPricingDateRule

enum class CommodityPricingDateRule

strong

Enumerator
FutureExpiryDate
None

Definition at line 46 of file commoditylegdata.hpp.

46{ FutureExpiryDate, None };

◆ CdsTier

enum class CdsTier

strong

CDS debt tier enumeration.

Enumerator
SNRFOR
SUBLT2
SNRLAC
SECDOM
JRSUBUT2
PREFT1
LIEN1
LIEN2
LIEN3

Definition at line 36 of file creditdefaultswapdata.hpp.

36{ SNRFOR, SUBLT2, SNRLAC, SECDOM, JRSUBUT2, PREFT1, LIEN1, LIEN2, LIEN3 };

ore::data::CdsTier::SNRLAC

@ SNRLAC

ore::data::CdsTier::JRSUBUT2

@ JRSUBUT2

ore::data::CdsTier::LIEN3

@ LIEN3

ore::data::CdsTier::SUBLT2

@ SUBLT2

ore::data::CdsTier::PREFT1

@ PREFT1

ore::data::CdsTier::LIEN2

@ LIEN2

ore::data::CdsTier::SNRFOR

@ SNRFOR

ore::data::CdsTier::LIEN1

@ LIEN1

ore::data::CdsTier::SECDOM

@ SECDOM

◆ CdsDocClause

enum class CdsDocClause

strong

CDS documentation clause enumeration.

Enumerator
CR
MM
MR
XR
CR14
MM14
MR14
XR14

Definition at line 41 of file creditdefaultswapdata.hpp.

41{ CR, MM, MR, XR, CR14, MM14, MR14, XR14 };

ore::data::CdsDocClause::CR

@ CR

ore::data::CdsDocClause::XR14

@ XR14

ore::data::CdsDocClause::XR

@ XR

ore::data::CdsDocClause::MR14

@ MR14

ore::data::CdsDocClause::MM14

@ MM14

ore::data::CdsDocClause::MM

@ MM

ore::data::CdsDocClause::MR

@ MR

ore::data::CdsDocClause::CR14

@ CR14

◆ IsdaRulesDefinitions

enum class IsdaRulesDefinitions

strong

ISDA CDS documentation rules set enumeration.

Enumerator
y2003
y2014

Definition at line 47 of file creditdefaultswapdata.hpp.

47{ y2003 = 2003, y2014 = 2014 };

ore::data::IsdaRulesDefinitions::y2014

@ y2014

ore::data::IsdaRulesDefinitions::y2003

@ y2003

◆ CreditEventType

enum class CreditEventType

strong

ISDA credit event types enumeration.

Enumerator
BANKRUPTCY
FAILURE_TO_PAY
RESTRUCTURING
OBLIGATION_ACCELERATION
OBLIGATION_DEFAULT
REPUDIATION_MORATORIUM
GOVERNMENTAL_INTERVENTION

Definition at line 53 of file creditdefaultswapdata.hpp.

                           {
    BANKRUPTCY,
    FAILURE_TO_PAY,
    RESTRUCTURING,
    OBLIGATION_ACCELERATION,
    OBLIGATION_DEFAULT,
    REPUDIATION_MORATORIUM,
    GOVERNMENTAL_INTERVENTION
};

◆ CreditEventTiers

enum class CreditEventTiers

strong

ISDA credit event seniority sets enumeration.

Enumerator
SNR
SUB
SNRLAC
SNR_SUB
SNR_SNRLAC
SUB_SNRLAC
SNR_SUB_SNRLAC

Definition at line 67 of file creditdefaultswapdata.hpp.

67{ SNR, SUB, SNRLAC, SNR_SUB, SNR_SNRLAC, SUB_SNRLAC, SNR_SUB_SNRLAC };

ore::data::CreditEventTiers::SUB

@ SUB

ore::data::CreditEventTiers::SUB_SNRLAC

@ SUB_SNRLAC

ore::data::CreditEventTiers::SNR_SUB_SNRLAC

@ SNR_SUB_SNRLAC

ore::data::CreditEventTiers::SNR_SUB

@ SNR_SUB

ore::data::CreditEventTiers::SNR

@ SNR

ore::data::CreditEventTiers::SNR_SNRLAC

@ SNR_SNRLAC

◆ MarketContext

enum class MarketContext

strong

Market configuration contexts. Note that there is only one pricing context. If several are needed (for different trade types, different collateral currencies etc.), several engine factories should be set up for each such portfolio subset.

Enumerator
irCalibration
fxCalibration
eqCalibration
pricing

Definition at line 60 of file enginefactory.hpp.

60{ irCalibration, fxCalibration, eqCalibration, pricing };

ore::data::MarketContext::eqCalibration

@ eqCalibration

ore::data::MarketContext::fxCalibration

@ fxCalibration

ore::data::MarketContext::pricing

@ pricing

ore::data::MarketContext::irCalibration

@ irCalibration

◆ AmortizationType

enum class AmortizationType

strong

Enumerator
None
FixedAmount
RelativeToInitialNotional
RelativeToPreviousNotional
Annuity
LinearToMaturity

Definition at line 346 of file parsers.hpp.

                            {
    None,
    FixedAmount,
    RelativeToInitialNotional,
    RelativeToPreviousNotional,
    Annuity,
    LinearToMaturity
};

◆ AssetClass

enum class AssetClass

strong

Enumerator
EQ
FX
COM
IR
INF
CR
BOND
BOND_INDEX

Definition at line 374 of file parsers.hpp.

374{ EQ, FX, COM, IR, INF, CR, BOND, BOND_INDEX };

ore::data::AssetClass::EQ

@ EQ

ore::data::AssetClass::IR

@ IR

ore::data::AssetClass::INF

@ INF

ore::data::AssetClass::BOND_INDEX

@ BOND_INDEX

ore::data::AssetClass::FX

@ FX

ore::data::AssetClass::BOND

@ BOND

ore::data::AssetClass::COM

@ COM

◆ Extrapolation

enum class Extrapolation

strong

Enumeration for holding various extrapolation settings.

Enumerator
None
UseInterpolator
Flat

Definition at line 450 of file parsers.hpp.

450{ None, UseInterpolator, Flat };

ore::data::Extrapolation::UseInterpolator

@ UseInterpolator

ore::data::Extrapolation::Flat

@ Flat

◆ MomentType

enum class MomentType

strong

Enumerator
Variance
Volatility

Definition at line 559 of file parsers.hpp.

559{ Variance, Volatility };

ore::data::MomentType::Variance

@ Variance

ore::data::MomentType::Volatility

@ Volatility

◆ CreditPortfolioSensitivityDecomposition

enum class CreditPortfolioSensitivityDecomposition

strong

Enumeration CreditPortfolioSensitivityDecomposition.

Enumerator
Underlying
NotionalWeighted
LossWeighted
DeltaWeighted

Definition at line 568 of file parsers.hpp.

568{ Underlying, NotionalWeighted, LossWeighted, DeltaWeighted };

ore::data::Underlying

Class to hold Underlyings.

Definition: underlying.hpp:37

ore::data::CreditPortfolioSensitivityDecomposition::LossWeighted

@ LossWeighted

ore::data::CreditPortfolioSensitivityDecomposition::DeltaWeighted

@ DeltaWeighted

ore::data::CreditPortfolioSensitivityDecomposition::NotionalWeighted

@ NotionalWeighted

◆ MporCashFlowMode

enum MporCashFlowMode

Enumerator
Unspecified
NonePay
BothPay
WePay
TheyPay

Definition at line 588 of file parsers.hpp.

588{ Unspecified, NonePay, BothPay, WePay, TheyPay };

ore::data::BothPay

@ BothPay

Definition: parsers.hpp:588

ore::data::TheyPay

@ TheyPay

Definition: parsers.hpp:588

ore::data::Unspecified

@ Unspecified

Definition: parsers.hpp:588

ore::data::WePay

@ WePay

Definition: parsers.hpp:588

ore::data::NonePay

@ NonePay

Definition: parsers.hpp:588

Function Documentation

◆ volatilityType()

QuantLib::VolatilityType volatilityType ( CapFloorVolatilityCurveConfig::VolatilityType type )

Imply QuantLib::VolatilityType from CapFloorVolatilityCurveConfig::VolatilityType.

Definition at line 433 of file capfloorvolcurveconfig.cpp.

                                                                                {
    switch (type) {
    case CapFloorVolatilityCurveConfig::VolatilityType::Lognormal:
    case CapFloorVolatilityCurveConfig::VolatilityType::ShiftedLognormal:
        return ShiftedLognormal;
    case CapFloorVolatilityCurveConfig::VolatilityType::Normal:
        return Normal;
    default:
        QL_FAIL("Unknown VolatilityType (" << static_cast<int>(type) << ")");
    }
}

Here is the caller graph for this function:

◆ operator<() [1/14]

bool operator<	(	const CommodityFutureConvention::ProhibitedExpiry &	lhs,
		const CommodityFutureConvention::ProhibitedExpiry &	rhs
	)

Compare two prohibited expiries.

Definition at line 1707 of file conventions.cpp.

                                                          {
    return lhs.expiry() < rhs.expiry();
}

Here is the call graph for this function:

◆ operator<<() [1/73]

std::ostream & operator<<	(	std::ostream &	out,
		Convention::Type	type
	)

Definition at line 2748 of file conventions.cpp.

                                                             {
    switch (type) {
    case Convention::Type::Zero:
        return out << "Zero";
    case Convention::Type::Deposit:
        return out << "Deposit";
    case Convention::Type::Future:
        return out << "Future";
    case Convention::Type::FRA:
        return out << "FRA";
    case Convention::Type::OIS:
        return out << "OIS";
    case Convention::Type::Swap:
        return out << "Swap";
    case Convention::Type::AverageOIS:
        return out << "AverageOIS";
    case Convention::Type::TenorBasisSwap:
        return out << "TenorBasisSwap";
    case Convention::Type::TenorBasisTwoSwap:
        return out << "TenorBasisTwoSwap";
    case Convention::Type::BMABasisSwap:
        return out << "BMABasisSwap";
    case Convention::Type::FX:
        return out << "FX";
    case Convention::Type::CrossCcyBasis:
        return out << "CrossCcyBasis";
    case Convention::Type::CrossCcyFixFloat:
        return out << "CrossCcyFixFloat";
    case Convention::Type::CDS:
        return out << "CDS";
    case Convention::Type::IborIndex:
        return out << "IborIndex";
    case Convention::Type::OvernightIndex:
        return out << "OvernightIndex";
    case Convention::Type::SwapIndex:
        return out << "SwapIndex";
    case Convention::Type::ZeroInflationIndex:
        return out << "ZeroInflationIndex";
    case Convention::Type::InflationSwap:
        return out << "InflationSwap";
    case Convention::Type::SecuritySpread:
        return out << "SecuritySpread";
    case Convention::Type::CMSSpreadOption:
        return out << "CMSSpreadOption";
    case Convention::Type::CommodityForward:
        return out << "CommodityForward";
    case Convention::Type::CommodityFuture:
        return out << "CommodityFuture";
    case Convention::Type::FxOption:
        return out << "FxOption";
    case Convention::Type::BondYield:
        return out << "BondYield";
    default:
        return out << "unknown convention type (" << static_cast<int>(type) << ")";
    }
}

◆ operator<<() [2/73]

std::ostream & operator<<	(	std::ostream &	out,
		CorrelationCurveConfig::CorrelationType	t
	)

Definition at line 30 of file correlationcurveconfig.cpp.

                                                                                 {
    switch (t) {
    case CorrelationCurveConfig::CorrelationType::CMSSpread:
        return out << "CMSSpread";
    case CorrelationCurveConfig::CorrelationType::Generic:
        return out << "Generic";
    default:
        QL_FAIL("unknown QuoteType(" << Integer(t) << ")");
    }
}

◆ operator<<() [3/73]

std::ostream & operator<<	(	std::ostream &	out,
		CorrelationCurveConfig::Dimension	t
	)

Definition at line 40 of file correlationcurveconfig.cpp.

                                                                           {
    switch (t) {
    case CorrelationCurveConfig::Dimension::ATM:
        return out << "ATM";
    case CorrelationCurveConfig::Dimension::Constant:
        return out << "Constant";
    default:
        QL_FAIL("unknown Dimension(" << Integer(t) << ")");
    }
}

◆ indexNameLessThan()

bool indexNameLessThan	(	const std::string &	index1,
		const std::string &	index2
	)

Definition at line 224 of file correlationcurveconfig.cpp.

                                                                         {
    vector<string> tokens1;
    boost::split(tokens1, index1, boost::is_any_of("-"));
    vector<string> tokens2;
    boost::split(tokens2, index2, boost::is_any_of("-"));
 
    QL_REQUIRE(tokens1.size() >= 2, "at least two tokens expected in " << index1);
    QL_REQUIRE(tokens2.size() >= 2, "at least two tokens expected in " << index2);
 
    Size s1, s2;
 
    if (tokens1[1] == "CMS")
        s1 = 4;
    else if (tokens1[0] == "FX")
        s1 = 2;
    else if (tokens1[0] == "EQ")
        s1 = 1;
    else if (tokens1[0] == "COMM")
        s1 = 0;
    else
        s1 = 3; // assume Ibor
 
    if (tokens2[1] == "CMS")
        s2 = 4;
    else if (tokens2[0] == "FX")
        s2 = 2;
    else if (tokens2[0] == "EQ")
        s2 = 1;
    else if (tokens2[0] == "COMM")
        s2 = 0;
    else
        s2 = 3; // assume Ibor
 
    if (s1 < s2)
        return true;
    else if (s2 < s1)
        return false;
 
    // both EQ or both COM
    if (s1 == 0 || s1 == 1)
        return tokens1[1] < tokens2[1];
 
    QL_REQUIRE(tokens1.size() >= 3, "at least three tokens expected in " << index1);
    QL_REQUIRE(tokens2.size() >= 3, "at least three tokens expected in " << index2);
 
    // both CMS or both Ibor, tenor is the last token (3rd or even 4th for customised CMS indices)
    if (s1 == 3 || s1 == 4)
        return parsePeriod(tokens1.back()) < parsePeriod(tokens2.back());
 
    QL_REQUIRE(tokens1.size() >= 4, "at least four tokens expected in " << index1);
    QL_REQUIRE(tokens2.size() >= 4, "at least four tokens expected in " << index2);
 
    // both FX, compare CCY1 then CCY2 alphabetical
    if (s1 == 2) {
        return (tokens1[2] + "-" + tokens1[3]) < (tokens2[2] + "-" + tokens2[3]);
    }
 
    QL_FAIL("indexNameLessThan(): internal error");
}

Here is the call graph for this function:

◆ addMinimalCurves()

void addMinimalCurves	(	const char *	nodeName,
		const map< string, QuantLib::ext::shared_ptr< T > > &	m,
		map< string, QuantLib::ext::shared_ptr< T > > &	n,
		CurveSpec::CurveType	curveType,
		const map< CurveSpec::CurveType, set< string > >	configIds
	)

Definition at line 33 of file curveconfigurations.cpp.

                                                                            {
    for (auto it : m) {
        if ((configIds.count(curveType) && configIds.at(curveType).count(it.first))) {
            const string& id = it.second->curveID();
            n[id] = it.second;
        }
    }
}

◆ operator<<() [4/73]

std::ostream & operator<<	(	std::ostream &	out,
		EquityCurveConfig::Type	t
	)

Definition at line 115 of file equitycurveconfig.cpp.

                                                                 {
    switch (t) {
    case EquityCurveConfig::Type::DividendYield:
        return out << "DividendYield";
    case EquityCurveConfig::Type::ForwardPrice:
        return out << "ForwardPrice";
    case EquityCurveConfig::Type::ForwardDividendPrice:
        return out << "ForwardDividendPrice";
    case EquityCurveConfig::Type::OptionPremium:
        return out << "OptionPremium";
    case EquityCurveConfig::Type::NoDividends:
        return out << "NoDividends";
    default:
        QL_FAIL("unknown EquityCurveConfig::Type(" << int(t) << ")");
    }
}

◆ parseEquityCurveConfigType()

EquityCurveConfig::Type parseEquityCurveConfigType ( const std::string & str )

Definition at line 132 of file equitycurveconfig.cpp.

                                                                       {
    if (str == "DividendYield")
        return EquityCurveConfig::Type::DividendYield;
    else if (str == "ForwardPrice")
        return EquityCurveConfig::Type::ForwardPrice;
    else if (str == "ForwardDividendPrice")
        return EquityCurveConfig::Type::ForwardDividendPrice;
    else if (str == "OptionPremium")
        return EquityCurveConfig::Type::OptionPremium;
    else if (str == "NoDividends")
        return EquityCurveConfig::Type::NoDividends;
    QL_FAIL("Invalid EquityCurveConfig::Type " << str);
}

Here is the caller graph for this function:

◆ operator<<() [5/73]

std::ostream & operator<<	(	std::ostream &	out,
		GenericYieldVolatilityCurveConfig::VolatilityType	t
	)

Definition at line 31 of file genericyieldvolcurveconfig.cpp.

                                                                                           {
    switch (t) {
    case GenericYieldVolatilityCurveConfig::VolatilityType::Lognormal:
        return out << "RATE_LNVOL";
    case GenericYieldVolatilityCurveConfig::VolatilityType::Normal:
        return out << "RATE_NVOL";
    case GenericYieldVolatilityCurveConfig::VolatilityType::ShiftedLognormal:
        return out << "RATE_SLNVOL";
    default:
        QL_FAIL("unknown VolatilityType(" << Integer(t) << ")");
    }
}

◆ operator<<() [6/73]

std::ostream & operator<<	(	std::ostream &	out,
		InflationCapFloorVolatilityCurveConfig::VolatilityType	t
	)

Definition at line 32 of file inflationcapfloorvolcurveconfig.cpp.

                                                                                                {
    switch (t) {
    case InflationCapFloorVolatilityCurveConfig::VolatilityType::Lognormal:
        return out << "RATE_LNVOL";
    case InflationCapFloorVolatilityCurveConfig::VolatilityType::Normal:
        return out << "RATE_NVOL";
    case InflationCapFloorVolatilityCurveConfig::VolatilityType::ShiftedLognormal:
        return out << "RATE_SLNVOL";
    default:
        QL_FAIL("unknown VolatilityType(" << Integer(t) << ")");
    }
}

◆ operator<<() [7/73]

std::ostream & operator<<	(	std::ostream &	out,
		InflationCapFloorVolatilityCurveConfig::QuoteType	t
	)

Definition at line 45 of file inflationcapfloorvolcurveconfig.cpp.

                                                                                           {
    switch (t) {
    case InflationCapFloorVolatilityCurveConfig::QuoteType::Price:
        return out << "PRICE";
    case InflationCapFloorVolatilityCurveConfig::QuoteType::Volatility:
        return out << "VOLATILITY";
    default:
        QL_FAIL("unknown QuoteType(" << Integer(t) << ")");
    }
}

◆ effectiveReportConfig()

ReportConfig effectiveReportConfig	(	const ReportConfig &	globalConfig,
		const ReportConfig &	localConfig
	)

Definition at line 109 of file reportconfig.cpp.

                                                                                                      {
    bool reportOnDeltaGrid = false;
    bool reportOnMoneynessGrid = false;
    bool reportOnStrikeGrid = false;
    bool reportOnStrikeSpreadGrid = false;
    std::vector<Real> moneyness;
    std::vector<std::string> deltas;
    std::vector<Real> strikes;
    std::vector<Real> strikeSpreads;
    std::vector<Period> expiries;
    std::vector<Period> underlyingTenors;
 
    if (localConfig.reportOnDeltaGrid())
        reportOnDeltaGrid = *localConfig.reportOnDeltaGrid();
    else if (globalConfig.reportOnDeltaGrid())
        reportOnDeltaGrid = *globalConfig.reportOnDeltaGrid();
 
    if (localConfig.reportOnMoneynessGrid())
        reportOnMoneynessGrid = *localConfig.reportOnMoneynessGrid();
    else if (globalConfig.reportOnMoneynessGrid())
        reportOnMoneynessGrid = *globalConfig.reportOnMoneynessGrid();
 
    if (localConfig.reportOnStrikeGrid())
        reportOnStrikeGrid = *localConfig.reportOnStrikeGrid();
    else if (globalConfig.reportOnStrikeGrid())
        reportOnStrikeGrid = *globalConfig.reportOnStrikeGrid();
 
    if (localConfig.reportOnStrikeSpreadGrid())
        reportOnStrikeSpreadGrid = *localConfig.reportOnStrikeSpreadGrid();
    else if (globalConfig.reportOnStrikeSpreadGrid())
        reportOnStrikeSpreadGrid = *globalConfig.reportOnStrikeSpreadGrid();
 
    if (localConfig.moneyness())
        moneyness = *localConfig.moneyness();
    else if (globalConfig.moneyness())
        moneyness = *globalConfig.moneyness();
 
    if (localConfig.deltas())
        deltas = *localConfig.deltas();
    else if (globalConfig.deltas())
        deltas = *globalConfig.deltas();
 
    if (localConfig.strikes())
        strikes = *localConfig.strikes();
    else if (globalConfig.strikes())
        strikes = *globalConfig.strikes();
 
    if (localConfig.strikeSpreads())
        strikeSpreads = *localConfig.strikeSpreads();
    else if (globalConfig.strikeSpreads())
        strikeSpreads = *globalConfig.strikeSpreads();
 
    if (localConfig.expiries())
        expiries = *localConfig.expiries();
    else if (globalConfig.expiries())
        expiries = *globalConfig.expiries();
 
    if (localConfig.underlyingTenors())
        underlyingTenors = *localConfig.underlyingTenors();
    else if (globalConfig.underlyingTenors())
        underlyingTenors = *globalConfig.underlyingTenors();
 
    return ReportConfig(reportOnDeltaGrid, reportOnMoneynessGrid, reportOnStrikeGrid, reportOnStrikeSpreadGrid, deltas,
                        moneyness, strikes, strikeSpreads, expiries, underlyingTenors);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator<() [2/14]

bool operator<	(	const VolatilityConfig &	vc1,
		const VolatilityConfig &	vc2
	)

Definition at line 31 of file volatilityconfig.cpp.

                                                                         {
    return vc1.priority() < vc2.priority();
}

Here is the call graph for this function:

◆ parseYieldCurveSegment()

YieldCurveSegment::Type parseYieldCurveSegment ( const string & s )

Definition at line 40 of file yieldcurveconfig.cpp.

                                                              {
    if (iequals(s, "Zero"))
        return YieldCurveSegment::Type::Zero;
    else if (iequals(s, "Zero Spread"))
        return YieldCurveSegment::Type::ZeroSpread;
    else if (iequals(s, "Discount"))
        return YieldCurveSegment::Type::Discount;
    else if (iequals(s, "Deposit"))
        return YieldCurveSegment::Type::Deposit;
    else if (iequals(s, "FRA"))
        return YieldCurveSegment::Type::FRA;
    else if (iequals(s, "Future"))
        return YieldCurveSegment::Type::Future;
    else if (iequals(s, "OIS"))
        return YieldCurveSegment::Type::OIS;
    else if (iequals(s, "Swap"))
        return YieldCurveSegment::Type::Swap;
    else if (iequals(s, "Average OIS"))
        return YieldCurveSegment::Type::AverageOIS;
    else if (iequals(s, "Tenor Basis Swap"))
        return YieldCurveSegment::Type::TenorBasis;
    else if (iequals(s, "Tenor Basis Two Swaps"))
        return YieldCurveSegment::Type::TenorBasisTwo;
    else if (iequals(s, "BMA Basis Swap"))
        return YieldCurveSegment::Type::BMABasis;
    else if (iequals(s, "FX Forward"))
        return YieldCurveSegment::Type::FXForward;
    else if (iequals(s, "Cross Currency Basis Swap"))
        return YieldCurveSegment::Type::CrossCcyBasis;
    else if (iequals(s, "Cross Currency Fix Float Swap"))
        return YieldCurveSegment::Type::CrossCcyFixFloat;
    else if (iequals(s, "Discount Ratio"))
        return YieldCurveSegment::Type::DiscountRatio;
    else if (iequals(s, "FittedBond"))
        return YieldCurveSegment::Type::FittedBond;
    else if (iequals(s, "Yield Plus Default"))
        return YieldCurveSegment::Type::YieldPlusDefault;
    else if (iequals(s, "Weighted Average"))
        return YieldCurveSegment::Type::WeightedAverage;
    else if (iequals(s, "Ibor Fallback"))
        return YieldCurveSegment::Type::IborFallback;
    else if (iequals(s, "Bond Yield Shifted"))
        return YieldCurveSegment::Type::BondYieldShifted;
    QL_FAIL("Yield curve segment type " << s << " not recognized");
}

Here is the caller graph for this function:

◆ interpOnOpt()

bool interpOnOpt ( CapFloorVolatilityCurveConfig & config )

Definition at line 63 of file capfloorvolcurve.cpp.

                                                        {
    QL_REQUIRE(config.interpolateOn() == "TermVolatilities" || config.interpolateOn() == "OptionletVolatilities",
               "Expected InterpolateOn to be one of TermVolatilities or OptionletVolatilities");
    return config.interpolateOn() == "OptionletVolatilities";
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeDummyMarketDatum()

QuantLib::ext::shared_ptr< MarketDatum > makeDummyMarketDatum	(	const Date &	d,
		const std::string &	name
	)

Definition at line 95 of file csvloader.cpp.

                                                                                              {
    return QuantLib::ext::make_shared<MarketDatum>(0.0, d, name, MarketDatum::QuoteType::NONE,
                                           MarketDatum::InstrumentType::NONE);
}

Here is the caller graph for this function:

◆ operator<() [3/14]

bool operator<	(	const CurveSpec &	lhs,
		const CurveSpec &	rhs
	)

Relational operators for CurveSpecs.

Definition at line 27 of file curvespec.cpp.

                                                           {
    if (lhs == rhs) {
        /* If CurveSpecs are equal (i.e. have same name), return false. */
        return false;
    } else if (lhs.baseType() != rhs.baseType()) {
        /* If types are not the same, use the enum value for ordering along type.
         * The enum order in the header file is deliberate, it ensures that FX comes before FXVol
         * this property is used in data::order() (see curveloader.hpp)
         */
        return lhs.baseType() < rhs.baseType();
    } else {
        /* If types are the same and CurveSpecs are different, use default < for string */
        return lhs.name() < rhs.name();
    }
}

Here is the call graph for this function:

◆ operator==() [1/13]

bool operator==	(	const CurveSpec &	lhs,
		const CurveSpec &	rhs
	)

Definition at line 43 of file curvespec.cpp.

                                                            {
    /* We consider two CurveSpecs equal if they have the same name. */
    return lhs.name() == rhs.name();
}

Here is the call graph for this function:

◆ operator<() [4/14]

bool operator<	(	const QuantLib::ext::shared_ptr< CurveSpec > &	lhs,
		const QuantLib::ext::shared_ptr< CurveSpec > &	rhs
	)

Definition at line 48 of file curvespec.cpp.

48{ return *lhs < *rhs; }

◆ operator==() [2/13]

bool operator==	(	const QuantLib::ext::shared_ptr< CurveSpec > &	lhs,
		const QuantLib::ext::shared_ptr< CurveSpec > &	rhs
	)

Definition at line 50 of file curvespec.cpp.

                                                                                                          {
    return *lhs == *rhs;
}

◆ operator<<() [8/73]

std::ostream & operator<<	(	std::ostream &	os,
		const CurveSpec &	spec
	)

Stream operator for CurveSpec.

Definition at line 54 of file curvespec.cpp.

54{ return os << spec.name(); }

Here is the call graph for this function:

◆ operator<<() [9/73]

std::ostream & operator<<	(	std::ostream &	os,
		const CurveSpec::CurveType &	t
	)

Stream operator for CurveType.

Definition at line 56 of file curvespec.cpp.

                                                                    {
    switch (t) {
    case CurveSpec::CurveType::Yield:
        return os << "Yield";
    case CurveSpec::CurveType::CapFloorVolatility:
        return os << "CapFloorVolatility";
    case CurveSpec::CurveType::SwaptionVolatility:
        return os << "SwaptionVolatility";
    case CurveSpec::CurveType::YieldVolatility:
        return os << "YieldVolatility";
    case CurveSpec::CurveType::FX:
        return os << "FX";
    case CurveSpec::CurveType::FXVolatility:
        return os << "FXVolatility";
    case CurveSpec::CurveType::Security:
        return os << "Security";
    case CurveSpec::CurveType::Default:
        return os << "Default";
    case CurveSpec::CurveType::CDSVolatility:
        return os << "CDSVolatility";
    case CurveSpec::CurveType::Inflation:
        return os << "Inflation";
    case CurveSpec::CurveType::InflationCapFloorVolatility:
        return os << "InflationCapFloorVolatility";
    case CurveSpec::CurveType::Equity:
        return os << "Equity";
    case CurveSpec::CurveType::EquityVolatility:
        return os << "EquityVolatility";
    case CurveSpec::CurveType::BaseCorrelation:
        return os << "BaseCorrelation";
    case CurveSpec::CurveType::Commodity:
        return os << "Commodity";
    case CurveSpec::CurveType::CommodityVolatility:
        return os << "CommodityVolatility";
    case CurveSpec::CurveType::Correlation:
        return os << "Correlation";
    default:
        return os << "N/A";
    }
}

◆ operator==() [3/13]

bool operator==	(	const Expiry &	lhs,
		const Expiry &	rhs
	)

Definition at line 33 of file expiry.cpp.

33{ return lhs.equal_to(rhs); }

ore::data::Expiry::equal_to

virtual bool equal_to(const Expiry &other) const =0

Override in derived classes to compare specific expiries.

◆ operator<<() [10/73]

std::ostream & operator<<	(	ostream &	os,
		const Expiry &	expiry
	)

Write strike to stream.

Definition at line 108 of file expiry.cpp.

108{ return os << expiry.toString(); }

ore::data::Expiry::toString

virtual std::string toString() const =0

Write the Expiry object to string.

Here is the call graph for this function:

◆ parseExpiry()

QuantLib::ext::shared_ptr< Expiry > parseExpiry ( const string & strExpiry )

Parse an Expiry from its string representation, strExpiry.

Definition at line 110 of file expiry.cpp.

                                                                   {
 
    QL_REQUIRE(strExpiry.size() > 1, "Expiry string must have at least 2 characters");
 
    if (strExpiry.at(0) == 'c') {
        auto expiry = QuantLib::ext::make_shared<FutureContinuationExpiry>();
        expiry->fromString(strExpiry);
        return expiry;
    } else {
        Date date;
        Period period;
        bool isDate;
        parseDateOrPeriod(strExpiry, date, period, isDate);
        if (isDate) {
            return QuantLib::ext::make_shared<ExpiryDate>(date);
        } else {
            return QuantLib::ext::make_shared<ExpiryPeriod>(period);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyFixings()

void applyFixings ( const set< Fixing > & fixings )

Utility to write a vector of fixings in the QuantLib index manager's fixing history.

Definition at line 41 of file fixings.cpp.

                                              {
 
    QuantExt::SavedObservableSettings savedObservableSettings;
    ObservableSettings::instance().disableUpdates(true);
 
    Size count = 0;
    cpu_timer timer;
    QuantLib::ext::shared_ptr<Index> index;
    std::string lastIndexName;
    for (auto& f : fixings) {
        if(f.name.empty()) {
            WLOG("Skipping fixing with empty name, value " << f.fixing << ", date " << f.date);
        }
        try {
            if (lastIndexName != f.name) {
                index = parseIndex(f.name);
                lastIndexName = f.name;
            }
            index->addFixing(f.date, f.fixing, true);
            TLOG("Added fixing for " << f.name << " (" << io::iso_date(f.date) << ") value:" << f.fixing);
            ++count;
        } catch (const std::exception& e) {
            WLOG("Error during adding fixing for " << f.name << ": " << e.what());
        }
    }
    timer.stop();
    LOG("Added " << count << " of " << fixings.size() << " fixings in " << timer.format(default_places, "%w")
                 << " seconds");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator<() [5/14]

bool operator<	(	const Fixing &	f1,
		const Fixing &	f2
	)

Compare fixings.

Definition at line 71 of file fixings.cpp.

                                                   {
    if (f1.name != f2.name)
        return f1.name < f2.name;
    return f1.date < f2.date;
}

◆ getCorrelationCurve()

Handle< QuantExt::CorrelationTermStructure > getCorrelationCurve	(	const std::string &	index1,
		const std::string &	index2,
		const map< string, QuantLib::ext::shared_ptr< CorrelationCurve > > &	correlationCurves
	)

Definition at line 665 of file fxvolcurve.cpp.

                                                                                                   {
    // straight pair
    auto tmpCorr = correlationCurves.find("Correlation/" + index1 + "&" + index2);
    if (tmpCorr != correlationCurves.end()) {
        return Handle<QuantExt::CorrelationTermStructure>(tmpCorr->second->corrTermStructure());
    }
    // inverse pair
    tmpCorr = correlationCurves.find("Correlation/" + index2 + "&" + index1);
    if (tmpCorr != correlationCurves.end()) {
        return Handle<QuantExt::CorrelationTermStructure>(tmpCorr->second->corrTermStructure());
    }
    // inverse fx index1
    tmpCorr = correlationCurves.find("Correlation/" + inverseFxIndex(index1) + "&" + index2);
    if (tmpCorr != correlationCurves.end()) {
        Handle<QuantExt::CorrelationTermStructure> h =
            Handle<QuantExt::CorrelationTermStructure>(tmpCorr->second->corrTermStructure());
        return Handle<QuantExt::CorrelationTermStructure>(
            QuantLib::ext::make_shared<QuantExt::NegativeCorrelationTermStructure>(h));
    }
    tmpCorr = correlationCurves.find("Correlation/" + index2 + "&" + inverseFxIndex(index1));
    if (tmpCorr != correlationCurves.end()) {
        Handle<QuantExt::CorrelationTermStructure> h =
            Handle<QuantExt::CorrelationTermStructure>(tmpCorr->second->corrTermStructure());
        return Handle<QuantExt::CorrelationTermStructure>(
            QuantLib::ext::make_shared<QuantExt::NegativeCorrelationTermStructure>(h));
    }
    // inverse fx index2
    tmpCorr = correlationCurves.find("Correlation/" + index1 + "&" + inverseFxIndex(index2));
    if (tmpCorr != correlationCurves.end()) {
        Handle<QuantExt::CorrelationTermStructure> h =
            Handle<QuantExt::CorrelationTermStructure>(tmpCorr->second->corrTermStructure());
        return Handle<QuantExt::CorrelationTermStructure>(
            QuantLib::ext::make_shared<QuantExt::NegativeCorrelationTermStructure>(h));
    }
    tmpCorr = correlationCurves.find("Correlation/" + inverseFxIndex(index2) + "&" + index1);
    if (tmpCorr != correlationCurves.end()) {
        Handle<QuantExt::CorrelationTermStructure> h =
            Handle<QuantExt::CorrelationTermStructure>(tmpCorr->second->corrTermStructure());
        return Handle<QuantExt::CorrelationTermStructure>(
            QuantLib::ext::make_shared<QuantExt::NegativeCorrelationTermStructure>(h));
    }
    // both fx indices inverted
    tmpCorr = correlationCurves.find("Correlation/" + inverseFxIndex(index1) + "&" + inverseFxIndex(index2));
    if (tmpCorr != correlationCurves.end()) {
        return Handle<QuantExt::CorrelationTermStructure>(tmpCorr->second->corrTermStructure());
    }
    tmpCorr = correlationCurves.find("Correlation/" + inverseFxIndex(index2) + "&" + inverseFxIndex(index1));
    if (tmpCorr != correlationCurves.end()) {
        return Handle<QuantExt::CorrelationTermStructure>(tmpCorr->second->corrTermStructure());
    }
 
    QL_FAIL("no correlation curve found for " << index1 << ":" << index2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getInflationSwapStart() [1/2]

QuantLib::Date getInflationSwapStart	(	const Date &	asof,
		const InflationSwapConvention &	convention
	)

Given an asof and inflation swap convention, determine the start date of an inflation swap.

In general, this just returns the asof. If the convention has a publication roll and a publication schedule, the swap start date will be generated according to this schedule.

Here is the caller graph for this function:

◆ load()

void load	(	InMemoryLoader &	loader,
		const vector< string > &	data,
		bool	isMarket,
		bool	implyTodaysFixings
	)

Definition at line 152 of file inmemoryloader.cpp.

                                                                                                      {
    LOG("MemoryLoader started");
 
    Date today = QuantLib::Settings::instance().evaluationDate();
 
    for (Size i = 0; i < data.size(); ++i) {
        string line = data[i];
        // skip blank and comment lines
        if (line.size() > 0 && line[0] != '#') {
            vector<string> tokens;
            boost::trim(line);
            boost::split(tokens, line, boost::is_any_of(",;\t "), boost::token_compress_on);
 
            // TODO: should we try, catch and log any invalid lines?
            QL_REQUIRE(tokens.size() == 3, "Invalid MemoryLoader line, 3 tokens expected " << line);
            Date date = parseDate(tokens[0]);
            const string& key = tokens[1];
            Real value = parseReal(tokens[2]);
 
            if (isMarket) {
                // process market
                // build market datum and add to map
                try {
                    loader.add(date, key, value);
                    TLOG("Added MarketDatum " << key);
                } catch (std::exception& e) {
                    WLOG("Failed to parse MarketDatum " << key << ": " << e.what());
                }
            } else {
                // process fixings
                if (date < today || (date == today && !implyTodaysFixings))
                    loader.addFixing(date, key, value);
            }
        }
    }
    LOG("MemoryLoader completed");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ loadDataFromBuffers()

void loadDataFromBuffers	(	InMemoryLoader &	loader,
		const std::vector< std::string > &	marketData,
		const std::vector< std::string > &	fixingData,
		bool	implyTodaysFixings
	)

Utility function for loading market quotes and fixings from an in memory csv buffer.

Parameters

loader	The loader that will be populated
marketData	QuantLib::Date Key Value in a single std::string, separated by blanks, tabs, colons or commas
fixingData	QuantLib::Date Index Fixing in a single std::string, separated by blanks, tabs, colons or commas
implyTodaysFixings	Enable/disable implying today's fixings

Definition at line 190 of file inmemoryloader.cpp.

                                                                                          {
    load(loader, marketData, true, implyTodaysFixings);
    load(loader, fixingData, false, implyTodaysFixings);
}

Here is the call graph for this function:

◆ buildPseudoCurrencyMarketParameters()

struct PseudoCurrencyMarketParameters buildPseudoCurrencyMarketParameters ( const std::map< string, string > & pricingEngineGlobalParameters = std::map< string, string >() )

Function to build parameters from PricingEngine GlobalParametrs.

If no PricingEngine Global Parameters (PEGP) are provided the default params are returned which have treatAsFX = true. If PEGP are present, we look for the following fields

name="PseudoCurrency.TreatAsFX" value = true or false name="PseudoCurrency.BaseCurrency" value = currency code name="PseudoCurrency.FXIndexTag" value = Tag name for FX indices, e.g. GENERIC means we request correlation for "FX-GENERIC-USD-EUR" name="PseudeoCurrency.Curves.XXX" value = curve name, here XXX should be a 3 letter Precious metal or Crypto currency code name="PseudoCurrency.DefaultCorrelation" value = correlation. This is optional, if present we use this when the market has no correlation

A typical configuration is <pre> <GlobalParameters> <Parameter name="PseudoCurrency.TreatAsFX">false</Parameter> <Parameter name="PseudoCurrency.BaseCurrency">USD</Parameter> <Parameter name="PseudoCurrency.FXIndexTag">GENERIC</Parameter> <Parameter name="PseudoCurrency.Curve.XAU">PM:XAUUSD</Parameter> <Parameter name="PseudoCurrency.Curve.XBT">CRYPTO:XBTUSD</Parameter> </GlobalParameters> </pre>

Definition at line 54 of file market.cpp.

                                                                                                       {
    PseudoCurrencyMarketParameters params;
 
    // default
    params.treatAsFX = true;
 
    auto it = pegp.find("PseudoCurrency.TreatAsFX");
    if (it != pegp.end()) {
        DLOG("Building PseudoCurrencyMarketParameters from PricingEngine GlobalParameters");
        try {
            // Build the params
            params.treatAsFX = parseBool(it->second);
            it = pegp.find("PseudoCurrency.BaseCurrency");
            QL_REQUIRE(it != pegp.end(), "No BaseCurrency field");
            params.baseCurrency = it->second;
            parseCurrency(params.baseCurrency); // to check it is valid
 
            // Now just search for the 4 precious metals and 7 crypto currencies
            for (const string& pm : CurrencyParser::instance().pseudoCurrencyCodes()) {
                it = pegp.find("PseudoCurrency.Curve." + pm);
                if (it != pegp.end())
                    params.curves[pm] = it->second;
            }
            QL_REQUIRE(!params.curves.empty(), "At least one PM Curve required");
 
            // Look for fxIndexTag
            it = pegp.find("PseudoCurrency.FXIndexTag");
            QL_REQUIRE(it != pegp.end(), "No FXIndexTag field");
            params.fxIndexTag = it->second;
 
            // Look for Optional default correlation
            it = pegp.find("PseudoCurrency.DefaultCorrelation");
            if (it == pegp.end()) {
                LOG("No Default Correlation present");
                params.defaultCorrelation = Null<Real>();
            } else {
                LOG("Default Correlation is \"" << it->second << "\"");
                params.defaultCorrelation = parseReal(it->second);
                QL_REQUIRE(-1.0 <= params.defaultCorrelation && params.defaultCorrelation <= 1.0,
                           "Invalid DefaultCorrelation value " << it->second);
            }
        } catch (std::exception& e) {
            QL_FAIL("Failed to build PseudoCurrencyMarketParameters : " << e.what());
        }
    } else {
        DLOG("Building default PseudoCurrencyMarketParameters");
    }
    DLOG(params);
 
    return params;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator<<() [11/73]

std::ostream & operator<<	(	std::ostream &	os,
		const struct PseudoCurrencyMarketParameters &	p
	)

Definition at line 106 of file market.cpp.

                                                                                       {
    // we don't need to write everything out, this is enough for debugging most things
    return os << "PseudoCurrencyMarketParameters { "
              << "TreatAsFX:" << (p.treatAsFX ? "True" : "False") << ", BaseCurrency:" << p.baseCurrency << "}";
}

◆ operator<() [6/14]

bool operator<	(	const MarketDatum &	a,
		const MarketDatum &	b
	)

Definition at line 32 of file marketdatum.cpp.

                                                           {
    if (a.asofDate() != b.asofDate())
        return a.asofDate() < b.asofDate();
    // the name determines the instrument and quote type uniquely by construction
    return a.name() < b.name();
}

Here is the call graph for this function:

◆ operator<<() [12/73]

std::ostream & operator<<	(	std::ostream &	out,
		const MarketDatum::QuoteType &	type
	)

Definition at line 39 of file marketdatum.cpp.

                                                                          {
    switch (type) {
    case MarketDatum::QuoteType::BASIS_SPREAD:
        return out << "BASIS_SPREAD";
    case MarketDatum::QuoteType::CREDIT_SPREAD:
        return out << "CREDIT_SPREAD";
    case MarketDatum::QuoteType::CONV_CREDIT_SPREAD:
        return out << "CONV_CREDIT_SPREAD";
    case MarketDatum::QuoteType::YIELD_SPREAD:
        return out << "YIELD_SPREAD";
    case MarketDatum::QuoteType::RATE:
        return out << "RATE";
    case MarketDatum::QuoteType::RATIO:
        return out << "RATIO";
    case MarketDatum::QuoteType::PRICE:
        return out << "PRICE";
    case MarketDatum::QuoteType::RATE_LNVOL:
        return out << "RATE_LNVOL";
    case MarketDatum::QuoteType::RATE_NVOL:
        return out << "RATE_NVOL";
    case MarketDatum::QuoteType::RATE_SLNVOL:
        return out << "RATE_SLNVOL";
    case MarketDatum::QuoteType::BASE_CORRELATION:
        return out << "BASE_CORRELATION";
    case MarketDatum::QuoteType::SHIFT:
        return out << "SHIFT";
    case MarketDatum::QuoteType::TRANSITION_PROBABILITY:
        return out << "TRANSITION_PROBABILITY";
    case MarketDatum::QuoteType::NONE:
        return out << "NULL";
    default:
        return out << "?";
    }
}

◆ operator<<() [13/73]

std::ostream & operator<<	(	std::ostream &	out,
		const MarketDatum::InstrumentType &	type
	)

Definition at line 74 of file marketdatum.cpp.

                                                                               {
    switch (type) {
    case MarketDatum::InstrumentType::ZERO:
        return out << "ZERO";
    case MarketDatum::InstrumentType::DISCOUNT:
        return out << "DISCOUNT";
    case MarketDatum::InstrumentType::MM:
        return out << "MM";
    case MarketDatum::InstrumentType::MM_FUTURE:
        return out << "MM_FUTURE";
    case MarketDatum::InstrumentType::OI_FUTURE:
        return out << "OI_FUTURE";
    case MarketDatum::InstrumentType::FRA:
        return out << "FRA";
    case MarketDatum::InstrumentType::IMM_FRA:
        return out << "IMM_FRA";
    case MarketDatum::InstrumentType::IR_SWAP:
        return out << "IR_SWAP";
    case MarketDatum::InstrumentType::BASIS_SWAP:
        return out << "BASIS_SWAP";
    case MarketDatum::InstrumentType::BMA_SWAP:
        return out << "BMA_SWAP";
    case MarketDatum::InstrumentType::CC_BASIS_SWAP:
        return out << "CC_BASIS_SWAP";
    case MarketDatum::InstrumentType::CC_FIX_FLOAT_SWAP:
        return out << "CC_FIX_FLOAT_SWAP";
    case MarketDatum::InstrumentType::CDS:
        return out << "CDS";
    case MarketDatum::InstrumentType::CDS_INDEX:
        return out << "CDS_INDEX";
    case MarketDatum::InstrumentType::FX_SPOT:
        return out << "FX_SPOT";
    case MarketDatum::InstrumentType::FX_FWD:
        return out << "FX_FWD";
    case MarketDatum::InstrumentType::HAZARD_RATE:
        return out << "HAZARD_RATE";
    case MarketDatum::InstrumentType::RECOVERY_RATE:
        return out << "RECOVERY_RATE";
    case MarketDatum::InstrumentType::SWAPTION:
        return out << "SWAPTION";
    case MarketDatum::InstrumentType::CAPFLOOR:
        return out << "CAPFLOOR";
    case MarketDatum::InstrumentType::FX_OPTION:
        return out << "FX_OPTION";
    case MarketDatum::InstrumentType::ZC_INFLATIONSWAP:
        return out << "ZC_INFLATIONSWAP";
    case MarketDatum::InstrumentType::ZC_INFLATIONCAPFLOOR:
        return out << "ZC_INFLATIONCAPFLOOR";
    case MarketDatum::InstrumentType::YY_INFLATIONSWAP:
        return out << "YY_INFLATIONSWAP";
    case MarketDatum::InstrumentType::YY_INFLATIONCAPFLOOR:
        return out << "YY_INFLATIONCAPFLOOR";
    case MarketDatum::InstrumentType::SEASONALITY:
        return out << "SEASONALITY";
    case MarketDatum::InstrumentType::EQUITY_SPOT:
        return out << "EQUITY_SPOT";
    case MarketDatum::InstrumentType::EQUITY_FWD:
        return out << "EQUITY_FWD";
    case MarketDatum::InstrumentType::EQUITY_DIVIDEND:
        return out << "EQUITY_DIVIDEND";
    case MarketDatum::InstrumentType::EQUITY_OPTION:
        return out << "EQUITY_OPTION";
    case MarketDatum::InstrumentType::BOND:
        return out << "BOND";
    case MarketDatum::InstrumentType::BOND_OPTION:
        return out << "BOND_OPTION";
    case MarketDatum::InstrumentType::INDEX_CDS_OPTION:
        return out << "INDEX_CDS_OPTION";
    case MarketDatum::InstrumentType::COMMODITY_SPOT:
        return out << "COMMODITY_SPOT";
    case MarketDatum::InstrumentType::COMMODITY_FWD:
        return out << "COMMODITY_FWD";
    case MarketDatum::InstrumentType::CORRELATION:
        return out << "CORRELATION";
    case MarketDatum::InstrumentType::COMMODITY_OPTION:
        return out << "COMMODITY_OPTION";
    case MarketDatum::InstrumentType::CPR:
        return out << "CPR";
    case MarketDatum::InstrumentType::RATING:
        return out << "RATING";
    case MarketDatum::InstrumentType::NONE:
        return out << "NONE";
    default:
        return out << "?";
    }
}

◆ fxFwdQuoteTenor()

QuantLib::Period fxFwdQuoteTenor ( const boost::variant< QuantLib::Period, FXForwardQuote::FxFwdString > & term )

Definition at line 206 of file marketdatumparser.cpp.

                                                                                                    {
    return boost::apply_visitor(FxTenorGetter(), term);
}

Here is the caller graph for this function:

◆ fxFwdQuoteStartTenor()

QuantLib::Period fxFwdQuoteStartTenor	(	const boost::variant< QuantLib::Period, FXForwardQuote::FxFwdString > &	term,
		const QuantLib::ext::shared_ptr< FXConvention > &	fxConvention
	)

Definition at line 210 of file marketdatumparser.cpp.

                                                                                               {
    return boost::apply_visitor(FxStartTenorGetter(fxConvention), term);
}

Here is the caller graph for this function:

◆ matchFxFwdStringTerm()

bool matchFxFwdStringTerm	(	const boost::variant< QuantLib::Period, FXForwardQuote::FxFwdString > &	term,
		const FXForwardQuote::FxFwdString &	fxfwdString
	)

Definition at line 215 of file marketdatumparser.cpp.

                                                                   {
    return boost::apply_visitor(FxFwdStringCompare(fxfwdString), term);
}

Here is the caller graph for this function:

◆ operator==() [4/13]

bool operator==	(	const BaseStrike &	lhs,
		const BaseStrike &	rhs
	)

Definition at line 38 of file strike.cpp.

38{ return lhs.equal_to(rhs); }

ore::data::BaseStrike::equal_to

virtual bool equal_to(const BaseStrike &other) const =0

Override in derived classes to compare specific Strikes.

◆ operator<<() [14/73]

std::ostream & operator<<	(	ostream &	os,
		const BaseStrike &	strike
	)

Write strike to stream.

Definition at line 203 of file strike.cpp.

203{ return os << strike.toString(); }

ore::data::BaseStrike::toString

virtual std::string toString() const =0

Write the Strike object to string.

Here is the call graph for this function:

◆ operator<<() [15/73]

ostream & operator<<	(	ostream &	os,
		DeltaVolQuote::DeltaType	type
	)

Definition at line 205 of file strike.cpp.

                                                              {
    switch (type) {
    case DeltaVolQuote::Spot:
        return os << "Spot";
    case DeltaVolQuote::Fwd:
        return os << "Fwd";
    case DeltaVolQuote::PaSpot:
        return os << "PaSpot";
    case DeltaVolQuote::PaFwd:
        return os << "PaFwd";
    default:
        QL_FAIL("Unknown delta type");
    }
}

◆ operator<<() [16/73]

ostream & operator<<	(	ostream &	os,
		DeltaVolQuote::AtmType	type
	)

Definition at line 220 of file strike.cpp.

                                                            {
    switch (type) {
    case DeltaVolQuote::AtmNull:
        return os << "AtmNull";
    case DeltaVolQuote::AtmSpot:
        return os << "AtmSpot";
    case DeltaVolQuote::AtmFwd:
        return os << "AtmFwd";
    case DeltaVolQuote::AtmDeltaNeutral:
        return os << "AtmDeltaNeutral";
    case DeltaVolQuote::AtmVegaMax:
        return os << "AtmVegaMax";
    case DeltaVolQuote::AtmGammaMax:
        return os << "AtmGammaMax";
    case DeltaVolQuote::AtmPutCall50:
        return os << "AtmPutCall50";
    default:
        QL_FAIL("Unknown atm type");
    }
}

◆ operator<<() [17/73]

std::ostream & operator<<	(	ostream &	os,
		MoneynessStrike::Type	type
	)

Write MoneynessStrike::Type, type, to stream.

Definition at line 241 of file strike.cpp.

                                                           {
    switch (type) {
    case MoneynessStrike::Type::Spot:
        return os << "Spot";
    case MoneynessStrike::Type::Forward:
        return os << "Fwd";
    default:
        QL_FAIL("Unknown moneyness type");
    }
}

◆ parseMoneynessType()

MoneynessStrike::Type parseMoneynessType ( const string & type )

Parse MoneynessStrike::Type from type.

Definition at line 252 of file strike.cpp.

                                                           {
    if (type == "Spot") {
        return MoneynessStrike::Type::Spot;
    } else if (type == "Fwd") {
        return MoneynessStrike::Type::Forward;
    } else {
        QL_FAIL("Moneyness type '" << type << "' not recognized");
    }
}

Here is the caller graph for this function:

◆ parseBaseStrike()

QuantLib::ext::shared_ptr< BaseStrike > parseBaseStrike ( const string & strStrike )

Parse a Strike from its string representation, strStrike.

Definition at line 262 of file strike.cpp.

                                                                           {
 
    QuantLib::ext::shared_ptr<BaseStrike> strike;
 
    // Expect strStrike to either:
    // 1. have a single token which means that we have an absolute strike, or
    // 2. have multiple tokens beginning with one of DEL, ATM or MNY
    vector<string> tokens;
    boost::split(tokens, strStrike, boost::is_any_of("/"));
 
    if (tokens.size() == 1) {
        strike = QuantLib::ext::make_shared<AbsoluteStrike>();
    } else if (tokens[0] == "DEL") {
        strike = QuantLib::ext::make_shared<DeltaStrike>();
    } else if (tokens[0] == "ATM") {
        strike = QuantLib::ext::make_shared<AtmStrike>();
    } else if (tokens[0] == "MNY") {
        strike = QuantLib::ext::make_shared<MoneynessStrike>();
    } else {
        QL_FAIL("Could not parse strike string '" << strStrike << "'.");
    }
 
    strike->fromString(strStrike);
 
    return strike;
}

Here is the caller graph for this function:

◆ operator<<() [18/73]

std::ostream & operator<<	(	std::ostream &	os,
		QuantLib::DeltaVolQuote::DeltaType	type
	)

Write deltaType to stream. Not provided in QuantLib so add it here.

◆ operator<<() [19/73]

std::ostream & operator<<	(	std::ostream &	os,
		QuantLib::DeltaVolQuote::AtmType	type
	)

Write atmType to stream. Not provided in QuantLib so add it here.

◆ registerBaseStrike()

void registerBaseStrike ( Archive & ar )

Definition at line 273 of file strike.hpp.

                                                              {
    ar.template register_type<AbsoluteStrike>();
    ar.template register_type<DeltaStrike>();
    ar.template register_type<AtmStrike>();
    ar.template register_type<MoneynessStrike>();
}

◆ operator<<() [20/73]

std::ostream & operator<<	(	std::ostream &	o,
		const DependencyGraph::Node &	n
	)

Definition at line 949 of file todaysmarket.cpp.

                                                                    {
    return o << n.obj << "(" << n.name << "," << n.mapping << ")";
}

◆ getMarketObjectTypes()

std::set< MarketObject > getMarketObjectTypes ( )

Definition at line 84 of file todaysmarketparameters.cpp.

                                            {
    thread_local static std::set<MarketObject> result;
    if (result.empty()) {
        for (auto const& o : marketObjectData) {
            result.insert(o.obj);
        }
    }
    return result;
}

Here is the caller graph for this function:

◆ buildYieldCurve()

QuantLib::ext::shared_ptr< YieldTermStructure > buildYieldCurve	(	const vector< Date > &	dates,
		const vector< QuantLib::Real > &	rates,
		const DayCounter &	dayCounter,
		YieldCurve::InterpolationMethod	interpolationMethod,
		Size	n
	)

Templated function to build a YieldTermStructure and apply interpolation methods to it.

Definition at line 92 of file yieldcurve.cpp.

                                                                                                                 {
 
    QuantLib::ext::shared_ptr<YieldTermStructure> yieldts;
    switch (interpolationMethod) {
    case YieldCurve::InterpolationMethod::Linear:
        yieldts.reset(new CurveType<QuantLib::Linear>(dates, rates, dayCounter, QuantLib::Linear()));
        break;
    case YieldCurve::InterpolationMethod::LogLinear:
        yieldts.reset(new CurveType<QuantLib::LogLinear>(dates, rates, dayCounter, QuantLib::LogLinear()));
        break;
    case YieldCurve::InterpolationMethod::NaturalCubic:
        yieldts.reset(new CurveType<QuantLib::Cubic>(dates, rates, dayCounter,
                                                     QuantLib::Cubic(CubicInterpolation::Kruger, true)));
        break;
    case YieldCurve::InterpolationMethod::FinancialCubic:
        yieldts.reset(new CurveType<QuantLib::Cubic>(dates, rates, dayCounter,
                                                     QuantLib::Cubic(CubicInterpolation::Kruger, true,
                                                                     CubicInterpolation::SecondDerivative, 0.0,
                                                                     CubicInterpolation::FirstDerivative)));
        break;
    case YieldCurve::InterpolationMethod::ConvexMonotone:
        yieldts.reset(
            new CurveType<QuantLib::ConvexMonotone>(dates, rates, dayCounter, Calendar(), {}, {}, QuantLib::ConvexMonotone()));
        break;
    case YieldCurve::InterpolationMethod::Quadratic:
         yieldts.reset(new CurveType<QuantExt::Quadratic>(dates, rates, dayCounter, QuantExt::Quadratic(1, 0, 1, 0, 1)));
         break;
     case YieldCurve::InterpolationMethod::LogQuadratic:
         yieldts.reset(
             new CurveType<QuantExt::LogQuadratic>(dates, rates, dayCounter, QuantExt::LogQuadratic(1, 0, -1, 0, 1)));
         break;
     case YieldCurve::InterpolationMethod::Hermite:
         yieldts.reset(new CurveType<QuantLib::Cubic>(dates, rates, dayCounter, Cubic(CubicInterpolation::Parabolic)));
         break;
     case YieldCurve::InterpolationMethod::CubicSpline:
         yieldts.reset(new CurveType<QuantLib::Cubic>(dates, rates, dayCounter,
                                                      Cubic(CubicInterpolation::Spline, false,
                                                            CubicInterpolation::SecondDerivative, 0.0,
                                                            CubicInterpolation::SecondDerivative, 0.0)));
         break;
     case YieldCurve::InterpolationMethod::DefaultLogMixedLinearCubic:
         yieldts.reset(
             new CurveType<DefaultLogMixedLinearCubic>(dates, rates, dayCounter, DefaultLogMixedLinearCubic(n)));
         break;
     case YieldCurve::InterpolationMethod::MonotonicLogMixedLinearCubic:
         yieldts.reset(
             new CurveType<MonotonicLogMixedLinearCubic>(dates, rates, dayCounter, MonotonicLogMixedLinearCubic(n)));
         break;
     case YieldCurve::InterpolationMethod::KrugerLogMixedLinearCubic:
         yieldts.reset(
             new CurveType<KrugerLogMixedLinearCubic>(dates, rates, dayCounter, KrugerLogMixedLinearCubic(n)));
         break;
     case YieldCurve::InterpolationMethod::LogMixedLinearCubicNaturalSpline:
         yieldts.reset(new CurveType<LogMixedLinearCubic>(
             dates, rates, dayCounter,
             LogMixedLinearCubic(n, MixedInterpolation::ShareRanges, CubicInterpolation::Spline, false,
                                 CubicInterpolation::SecondDerivative, 0.0, CubicInterpolation::SecondDerivative,
                                 0.0)));
         break;
 
     default:
         QL_FAIL("Interpolation method '" << interpolationMethod << "' not recognised.");
    }
    return yieldts;
}

◆ zerocurve()

QuantLib::ext::shared_ptr< YieldTermStructure > zerocurve	(	const vector< Date > &	dates,
		const vector< Rate > &	yields,
		const DayCounter &	dayCounter,
		YieldCurve::InterpolationMethod	interpolationMethod,
		Size	n
	)

Create a Interpolated Zero Curve and apply interpolators.

Definition at line 160 of file yieldcurve.cpp.

                                                                                                           {
    return buildYieldCurve<InterpolatedZeroCurve>(dates, yields, dayCounter, interpolationMethod, n);
}

Here is the caller graph for this function:

◆ discountcurve()

QuantLib::ext::shared_ptr< YieldTermStructure > discountcurve	(	const vector< Date > &	dates,
		const vector< DiscountFactor > &	dfs,
		const DayCounter &	dayCounter,
		YieldCurve::InterpolationMethod	interpolationMethod,
		Size	n
	)

Create a Interpolated Discount Curve and apply interpolators.

Definition at line 166 of file yieldcurve.cpp.

                                                                                                               {
    return buildYieldCurve<InterpolatedDiscountCurve>(dates, dfs, dayCounter, interpolationMethod, n);
}

Here is the caller graph for this function:

◆ forwardcurve()

QuantLib::ext::shared_ptr< YieldTermStructure > forwardcurve	(	const vector< Date > &	dates,
		const vector< Rate > &	forwards,
		const DayCounter &	dayCounter,
		YieldCurve::InterpolationMethod	interpolationMethod,
		Size	n
	)

Create a Interpolated Forward Curve and apply interpolators.

Definition at line 172 of file yieldcurve.cpp.

                                                                                                              {
    return buildYieldCurve<InterpolatedForwardCurve>(dates, forwards, dayCounter, interpolationMethod, n);
}

Here is the caller graph for this function:

◆ parseYieldCurveInterpolationMethod()

YieldCurve::InterpolationMethod parseYieldCurveInterpolationMethod ( const string & s )

Helper function for parsing interpolation method.

Definition at line 180 of file yieldcurve.cpp.

                                                                                  {
    if (s == "Linear")
        return YieldCurve::InterpolationMethod::Linear;
    else if (s == "LogLinear")
        return YieldCurve::InterpolationMethod::LogLinear;
    else if (s == "NaturalCubic")
        return YieldCurve::InterpolationMethod::NaturalCubic;
    else if (s == "FinancialCubic")
        return YieldCurve::InterpolationMethod::FinancialCubic;
    else if (s == "ConvexMonotone")
        return YieldCurve::InterpolationMethod::ConvexMonotone;
    else if (s == "ExponentialSplines")
        return YieldCurve::InterpolationMethod::ExponentialSplines;
    else if (s == "Quadratic")
        return YieldCurve::InterpolationMethod::Quadratic;
    else if (s == "LogQuadratic")
        return YieldCurve::InterpolationMethod::LogQuadratic;
    else if (s == "LogNaturalCubic")
        return YieldCurve::InterpolationMethod::LogNaturalCubic;
    else if (s == "LogFinancialCubic")
        return YieldCurve::InterpolationMethod::LogFinancialCubic;
    else if (s == "LogCubicSpline")
        return YieldCurve::InterpolationMethod::LogCubicSpline;
    else if (s == "Hermite")
        return YieldCurve::InterpolationMethod::Hermite;
    else if (s == "CubicSpline")
        return YieldCurve::InterpolationMethod::CubicSpline;
    else if (s == "DefaultLogMixedLinearCubic")
        return YieldCurve::InterpolationMethod::DefaultLogMixedLinearCubic;
    else if (s == "MonotonicLogMixedLinearCubic")
        return YieldCurve::InterpolationMethod::MonotonicLogMixedLinearCubic;
    else if (s == "KrugerLogMixedLinearCubic")
        return YieldCurve::InterpolationMethod::KrugerLogMixedLinearCubic;
    else if (s == "LogMixedLinearCubicNaturalSpline")
        return YieldCurve::InterpolationMethod::LogMixedLinearCubicNaturalSpline;
    else if (s == "NelsonSiegel")
        return YieldCurve::InterpolationMethod::NelsonSiegel;
    else if (s == "Svensson")
        return YieldCurve::InterpolationMethod::Svensson;
    else
        QL_FAIL("Yield curve interpolation method " << s << " not recognized");
};

Here is the caller graph for this function:

◆ parseYieldCurveInterpolationVariable()

YieldCurve::InterpolationVariable parseYieldCurveInterpolationVariable ( const string & s )

Helper function for parsing interpolation variable.

Definition at line 223 of file yieldcurve.cpp.

                                                                                      {
    if (s == "Zero")
        return YieldCurve::InterpolationVariable::Zero;
    else if (s == "Discount")
        return YieldCurve::InterpolationVariable::Discount;
    else if (s == "Forward")
        return YieldCurve::InterpolationVariable::Forward;
    else
        QL_FAIL("Yield curve interpolation variable " << s << " not recognized");
};

Here is the caller graph for this function:

◆ operator<<() [21/73]

std::ostream & operator<<	(	std::ostream &	out,
		const YieldCurve::InterpolationMethod	m
	)

Output operator for interpolation method.

Definition at line 234 of file yieldcurve.cpp.

                                                                               {
    if (m == YieldCurve::InterpolationMethod::Linear)
        return out << "Linear";
    else if (m == YieldCurve::InterpolationMethod::LogLinear)
        return out << "LogLinear";
    else if (m == YieldCurve::InterpolationMethod::NaturalCubic)
        return out << "NaturalCubic";
    else if (m == YieldCurve::InterpolationMethod::FinancialCubic)
        return out << "FinancialCubic";
    else if (m == YieldCurve::InterpolationMethod::ConvexMonotone)
        return out << "ConvexMonotone";
    else if (m == YieldCurve::InterpolationMethod::ExponentialSplines)
        return out << "ExponentialSplines";
    else if (m == YieldCurve::InterpolationMethod::Quadratic)
        return out << "Quadratic";
    else if (m == YieldCurve::InterpolationMethod::LogQuadratic)
        return out << "LogQuadratic";
    else if (m == YieldCurve::InterpolationMethod::LogNaturalCubic)
        return out << "LogNaturalCubic";
    else if (m == YieldCurve::InterpolationMethod::LogFinancialCubic)
        return out << "LogFinancialCubic";
    else if (m == YieldCurve::InterpolationMethod::LogCubicSpline)
        return out << "LogCubicSpline";
    else if (m == YieldCurve::InterpolationMethod::Hermite)
        return out << "Hermite";
    else if (m == YieldCurve::InterpolationMethod::CubicSpline)
        return out << "CubicSpline";
    else if (m == YieldCurve::InterpolationMethod::DefaultLogMixedLinearCubic)
        return out << "DefaultLogMixedLinearCubic";
    else if (m == YieldCurve::InterpolationMethod::MonotonicLogMixedLinearCubic)
        return out << "MonotonicLogMixedLinearCubic";
    else if (m == YieldCurve::InterpolationMethod::KrugerLogMixedLinearCubic)
        return out << "KrugerLogMixedLinearCubic";
    else if (m == YieldCurve::InterpolationMethod::LogMixedLinearCubicNaturalSpline)
        return out << "LogMixedLinearCubicNaturalSpline";
    else if (m == YieldCurve::InterpolationMethod::NelsonSiegel)
        return out << "NelsonSiegel";
    else if (m == YieldCurve::InterpolationMethod::Svensson)
        return out << "Svensson";
    else
        QL_FAIL("Yield curve interpolation method " << static_cast<int>(m) << " not recognized");
}

◆ parseCirCalibrationStrategy()

CrCirData::CalibrationStrategy parseCirCalibrationStrategy ( const string & s )

Definition at line 42 of file crcirdata.cpp.

                                                                          {
    if (s == "None")
        return CrCirData::CalibrationStrategy::None;
    else if (s == "CurveAndFlatVol")
        return CrCirData::CalibrationStrategy::CurveAndFlatVol;
    else {
        QL_FAIL("CrCirData::CalibrationStrategy " << s << " not recognised.");
    }
}

Here is the caller graph for this function:

◆ operator<<() [22/73]

std::ostream & operator<<	(	std::ostream &	oss,
		const CrCirData::CalibrationStrategy &	s
	)

Definition at line 52 of file crcirdata.cpp.

                                                                               {
    if (s == CrCirData::CalibrationStrategy::None)
        oss << "None";
    else if (s == CrCirData::CalibrationStrategy::CurveAndFlatVol)
        oss << "CurveAndFlatVol";
    else
        QL_FAIL("CIR Calibration strategy(" << ((int)s) << ") not covered");
    return oss;
}

◆ pairToStrings()

std::vector< std::string > pairToStrings ( std::pair< std::string, std::string > p )

Definition at line 248 of file crossassetmodeldata.cpp.

                                                                    {
    std::vector<std::string> pair = {p.first, p.second};
    return pair;
}

◆ parseDiscretization()

CrossAssetModel::Discretization parseDiscretization ( const string & s )

Definition at line 840 of file crossassetmodeldata.cpp.

                                                                           {
    static std::map<string, QuantExt::CrossAssetModel::Discretization> m = {
        {"Exact", QuantExt::CrossAssetModel::Discretization::Exact},
        {"Euler", QuantExt::CrossAssetModel::Discretization::Euler}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Cannot convert \"" << s << "\" to QuantExt::CrossAssetStateProcess::discretization");
    }
}

Here is the caller graph for this function:

◆ operator<<() [23/73]

std::ostream & operator<<	(	std::ostream &	oss,
		const ParamType &	type
	)

Convert enumerated class value into a string.

Definition at line 28 of file irmodeldata.cpp.

                                                               {
    if (type == ParamType::Constant)
        oss << "CONSTANT";
    else if (type == ParamType::Piecewise)
        oss << "PIECEWISE";
    else
        QL_FAIL("Parameter type not covered by <<");
    return oss;
}

◆ parseParamType()

ParamType parseParamType ( const string & s )

Convert parameter type string into enumerated class value.

Definition at line 38 of file irmodeldata.cpp.

                                          {
    if (boost::algorithm::to_upper_copy(s) == "CONSTANT")
        return ParamType::Constant;
    else if (boost::algorithm::to_upper_copy(s) == "PIECEWISE")
        return ParamType::Piecewise;
    else
        QL_FAIL("Parameter type " << s << " not recognized");
}

Here is the caller graph for this function:

◆ parseCalibrationType()

CalibrationType parseCalibrationType ( const string & s )

Convert calibration type string into enumerated class value.

Definition at line 47 of file irmodeldata.cpp.

                                                      {
    if (boost::algorithm::to_upper_copy(s) == "BOOTSTRAP")
        return CalibrationType::Bootstrap;
    else if (boost::algorithm::to_upper_copy(s) == "BESTFIT")
        return CalibrationType::BestFit;
    else if (boost::algorithm::to_upper_copy(s) == "NONE")
        return CalibrationType::None;
    else
        QL_FAIL("Calibration type " << s << " not recognized");
}

Here is the caller graph for this function:

◆ operator<<() [24/73]

std::ostream & operator<<	(	std::ostream &	oss,
		const CalibrationType &	type
	)

Convert enumerated class value into a string.

Definition at line 58 of file irmodeldata.cpp.

                                                                     {
    if (type == CalibrationType::Bootstrap)
        oss << "BOOTSTRAP";
    else if (type == CalibrationType::BestFit)
        oss << "BESTFIT";
    else if (type == CalibrationType::None)
        oss << "NONE";
    else
        QL_FAIL("Calibration type not covered");
    return oss;
}

◆ parseCalibrationStrategy()

CalibrationStrategy parseCalibrationStrategy ( const string & s )

Convert calibration strategy string into enumerated class value.

Definition at line 70 of file irmodeldata.cpp.

                                                              {
    if (boost::algorithm::to_upper_copy(s) == "COTERMINALATM")
        return CalibrationStrategy::CoterminalATM;
    else if (boost::algorithm::to_upper_copy(s) == "COTERMINALDEALSTRIKE")
        return CalibrationStrategy::CoterminalDealStrike;
    else if (boost::algorithm::to_upper_copy(s) == "UNDERLYINGATM")
        return CalibrationStrategy::UnderlyingATM;
    else if (boost::algorithm::to_upper_copy(s) == "UNDERLYINGDEALSTRIKE")
        return CalibrationStrategy::UnderlyingDealStrike;
    else if (boost::algorithm::to_upper_copy(s) == "NONE")
        return CalibrationStrategy::None;
    else
        QL_FAIL("Calibration strategy " << s << " not recognized");
}

Here is the caller graph for this function:

◆ operator<<() [25/73]

std::ostream & operator<<	(	std::ostream &	oss,
		const CalibrationStrategy &	type
	)

Convert enumerated class value into a string.

Definition at line 85 of file irmodeldata.cpp.

                                                                         {
    if (type == CalibrationStrategy::CoterminalATM)
        oss << "COTERMINALATM";
    else if (type == CalibrationStrategy::CoterminalDealStrike)
        oss << "COTERMINALDEALSTRIKE";
    else if (type == CalibrationStrategy::UnderlyingATM)
        oss << "UNDERLYINGATM";
    else if (type == CalibrationStrategy::UnderlyingDealStrike)
        oss << "UNDERLYINGDEALSTRIKE";
    else if (type == CalibrationStrategy::None)
        oss << "NONE";
    else
        QL_FAIL("Calibration strategy not covered");
    return oss;
}

◆ parseReversionType()

LgmData::ReversionType parseReversionType ( const string & s )

Enum parsers.

Definition at line 62 of file lgmdata.cpp.

                                                         {
    if (boost::algorithm::to_upper_copy(s) == "HULLWHITE")
        return LgmData::ReversionType::HullWhite;
    else if (boost::algorithm::to_upper_copy(s) == "HAGAN")
        return LgmData::ReversionType::Hagan;
    else
        QL_FAIL("Reversion type " << s << " not recognized");
}

Here is the caller graph for this function:

◆ operator<<() [26/73]

std::ostream & operator<<	(	std::ostream &	oss,
		const LgmData::ReversionType &	type
	)

Enum to string.

Definition at line 71 of file lgmdata.cpp.

                                                                          {
    if (type == LgmData::ReversionType::HullWhite)
        oss << "HULLWHITE";
    else if (type == LgmData::ReversionType::Hagan)
        oss << "HAGAN";
    else
        QL_FAIL("Reversion type not covered");
    return oss;
}

◆ parseVolatilityType()

LgmData::VolatilityType parseVolatilityType ( const string & s )

Definition at line 81 of file lgmdata.cpp.

                                                           {
    if (boost::algorithm::to_upper_copy(s) == "HULLWHITE")
        return LgmData::VolatilityType::HullWhite;
    else if (boost::algorithm::to_upper_copy(s) == "HAGAN")
        return LgmData::VolatilityType::Hagan;
    else
        QL_FAIL("Volatility type " << s << " not recognized");
}

Here is the caller graph for this function:

◆ operator<<() [27/73]

std::ostream & operator<<	(	std::ostream &	oss,
		const LgmData::VolatilityType &	type
	)

Definition at line 90 of file lgmdata.cpp.

                                                                           {
    if (type == LgmData::VolatilityType::HullWhite)
        oss << "HULLWHITE";
    else if (type == LgmData::VolatilityType::Hagan)
        oss << "HAGAN";
    else
        QL_FAIL("Volatility type not covered");
    return oss;
}

◆ parseFloatSpreadMapping()

QuantExt::AnalyticLgmSwaptionEngine::FloatSpreadMapping parseFloatSpreadMapping ( const string & s )

Definition at line 100 of file lgmdata.cpp.

                                                                                             {
    if (boost::algorithm::to_upper_copy(s) == "NEXTCOUPON")
        return QuantExt::AnalyticLgmSwaptionEngine::nextCoupon;
    else if (boost::algorithm::to_upper_copy(s) == "PRORATA")
        return QuantExt::AnalyticLgmSwaptionEngine::proRata;
    else if (boost::algorithm::to_upper_copy(s) == "SIMPLE")
        return QuantExt::AnalyticLgmSwaptionEngine::simple;
    else
        QL_FAIL("FloatSpreadMapping '" << s << "' not recognized");
}

Here is the caller graph for this function:

◆ operator<<() [28/73]

std::ostream & operator<<	(	std::ostream &	oss,
		const QuantExt::AnalyticLgmSwaptionEngine::FloatSpreadMapping &	m
	)

Definition at line 111 of file lgmdata.cpp.

                                                                                                      {
    if (m == QuantExt::AnalyticLgmSwaptionEngine::nextCoupon)
        oss << "NEXTCOUPON";
    else if (m == QuantExt::AnalyticLgmSwaptionEngine::proRata)
        oss << "PRORATA";
    else if (m == QuantExt::AnalyticLgmSwaptionEngine::simple)
        oss << "SIMPLE";
    else
        QL_FAIL("FloatSpreadMapping type not covered");
    return oss;
}

◆ getCalibrationDetails() [1/9]

std::string getCalibrationDetails	(	LgmCalibrationInfo &	info,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	basket,
		const QuantLib::ext::shared_ptr< IrLgm1fParametrization > &	parametrization
	)

Definition at line 125 of file utilities.cpp.

                                                                                                           {
    std::ostringstream log;
    log << std::right << std::setw(3) << "#" << std::setw(14) << "time" << std::setw(14) << "modelVol" << std::setw(14)
        << "marketVol" << std::setw(14) << "(diff)" << std::setw(14) << "modelValue" << std::setw(14) << "marketValue"
        << std::setw(14) << "(diff)" << std::setw(14) << "irlgm1fAlpha" << std::setw(14) << "irlgm1fKappa"
        << std::setw(16) << "irlgm1fHwSigma\n";
    Real t = 0.0, modelAlpha = 0.0, modelKappa = 0.0, modelHwSigma = 0.0;
    info.lgmCalibrationData.clear();
    for (Size j = 0; j < basket.size(); j++) {
        Real modelValue = basket[j]->modelValue();
        Real marketValue = basket[j]->marketValue();
        Real valueDiff = modelValue - marketValue;
        Volatility modelVol = 0, marketVol = 0, volDiff = 0;
        QuantLib::ext::shared_ptr<SwaptionHelper> swaption = QuantLib::ext::dynamic_pointer_cast<SwaptionHelper>(basket[j]);
        if (swaption != nullptr && parametrization != nullptr) {
            // report alpha, kappa at t_expiry^-
            t = parametrization->termStructure()->timeFromReference(swaption->swaption()->exercise()->date(0));
            modelAlpha = parametrization->alpha(t - 1E-4);
            modelKappa = parametrization->kappa(t - 1E-4);
            modelHwSigma = parametrization->hullWhiteSigma(t - 1E-4);
        }
        // TODO handle other calibration helpers, too (capfloor)
        marketVol = basket[j]->volatility()->value();
        modelVol = impliedVolatility(basket[j]);
        volDiff = modelVol - marketVol;
        log << std::setw(3) << j << std::setprecision(6) << std::setw(14) << t << std::setw(14) << modelVol
            << std::setw(14) << marketVol << std::setw(14) << volDiff << std::setw(14) << modelValue << std::setw(14)
            << marketValue << std::setw(14) << valueDiff << std::setw(14) << modelAlpha << std::setw(14) << modelKappa
            << std::setw(16) << modelHwSigma << "\n";
        info.lgmCalibrationData.push_back(
            LgmCalibrationData{t, modelVol, marketVol, modelValue, marketValue, modelAlpha, modelKappa, modelHwSigma});
    }
    if (parametrization != nullptr) {
        // report alpha, kappa at t_expiry^+ for last expiry
        modelAlpha = parametrization->alpha(t + 1E-4);
        modelKappa = parametrization->kappa(t + 1E-4);
        modelHwSigma = parametrization->hullWhiteSigma(t + 1E-4);
    }
    log << "t >= " << t << ": irlgm1fAlpha = " << modelAlpha << " irlgm1fKappa = " << modelKappa
        << " irlgm1fHwSigma = " << modelHwSigma << "\n";
    return log.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCalibrationDetails() [2/9]

std::string getCalibrationDetails	(	const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	basket,
		const QuantLib::ext::shared_ptr< FxBsParametrization > &	parametrization,
		const QuantLib::ext::shared_ptr< Parametrization > &	domesticIrModel
	)

Definition at line 170 of file utilities.cpp.

                                                                                                 {
    auto lgmParametrization = QuantLib::ext::dynamic_pointer_cast<IrLgm1fParametrization>(domesticIrModel);
    if (lgmParametrization) {
        return getCalibrationDetails(basket, parametrization, lgmParametrization);
    } else {
        return std::string();
    }
}

Here is the call graph for this function:

◆ getCalibrationDetails() [3/9]

std::string getCalibrationDetails	(	const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	basket,
		const QuantLib::ext::shared_ptr< FxBsParametrization > &	parametrization,
		const QuantLib::ext::shared_ptr< IrLgm1fParametrization > &	domesticLgm
	)

Definition at line 181 of file utilities.cpp.

                                                                                                    {
    std::ostringstream log;
    log << std::right << std::setw(3) << "#" << std::setw(14) << "time" << std::setw(14) << "modelVol" << std::setw(14)
        << "marketVol" << std::setw(14) << "(diff)" << std::setw(14) << "modelValue" << std::setw(14) << "marketValue"
        << std::setw(14) << "(diff)" << std::setw(14) << "fxbsSigma\n";
    Real t = 0.0, modelSigma = 0.0;
    for (Size j = 0; j < basket.size(); j++) {
        Real modelValue = basket[j]->modelValue();
        Real marketValue = basket[j]->marketValue();
        Real valueDiff = modelValue - marketValue;
        Volatility modelVol = 0, marketVol = 0, volDiff = 0;
        QuantLib::ext::shared_ptr<FxEqOptionHelper> fxoption = QuantLib::ext::dynamic_pointer_cast<FxEqOptionHelper>(basket[j]);
        if (fxoption != nullptr && parametrization != nullptr && domesticLgm != nullptr) {
            // report alpha, kappa at t_expiry^-
            t = domesticLgm->termStructure()->timeFromReference(fxoption->option()->exercise()->date(0));
            modelSigma = parametrization->sigma(t - 1E-4);
        }
        marketVol = basket[j]->volatility()->value();
        modelVol = impliedVolatility(basket[j]);
        volDiff = modelVol - marketVol;
        log << std::setw(3) << j << std::setprecision(6) << std::setw(14) << t << std::setw(14) << modelVol
            << std::setw(14) << marketVol << std::setw(14) << volDiff << std::setw(14) << modelValue << std::setw(14)
            << marketValue << std::setw(14) << valueDiff << std::setw(14) << modelSigma << "\n";
    }
    if (parametrization != nullptr) {
        // report alpha, kappa at t_expiry^+ for last expiry
        modelSigma = parametrization->sigma(t + 1E-4);
    }
    log << "t >= " << t << ": fxbsSigma = " << modelSigma << "\n";
    return log.str();
}

Here is the call graph for this function:

◆ getCalibrationDetails() [4/9]

std::string getCalibrationDetails	(	const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	basket,
		const QuantLib::ext::shared_ptr< EqBsParametrization > &	parametrization,
		const QuantLib::ext::shared_ptr< Parametrization > &	domesticIrModel
	)

Definition at line 215 of file utilities.cpp.

                                                                                                 {
    auto lgmParametrization = QuantLib::ext::dynamic_pointer_cast<IrLgm1fParametrization>(parametrization);
    if (lgmParametrization) {
        return getCalibrationDetails(basket, parametrization, lgmParametrization);
    } else {
        return std::string();
    }
}

Here is the call graph for this function:

◆ getCalibrationDetails() [5/9]

std::string getCalibrationDetails	(	const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	basket,
		const QuantLib::ext::shared_ptr< EqBsParametrization > &	parametrization,
		const QuantLib::ext::shared_ptr< IrLgm1fParametrization > &	domesticLgm
	)

Definition at line 226 of file utilities.cpp.

                                                                                                    {
    std::ostringstream log;
    log << std::right << std::setw(3) << "#" << std::setw(14) << "time" << std::setw(14) << "modelVol" << std::setw(14)
        << "marketVol" << std::setw(14) << "(diff)" << std::setw(14) << "modelValue" << std::setw(14) << "marketValue"
        << std::setw(14) << "(diff)" << std::setw(14) << "eqbsSigma\n";
    Real t = 0.0, modelSigma = 0.0;
    for (Size j = 0; j < basket.size(); j++) {
        Real modelValue = basket[j]->modelValue();
        Real marketValue = basket[j]->marketValue();
        Real valueDiff = modelValue - marketValue;
        Volatility modelVol = 0, marketVol = 0, volDiff = 0;
        QuantLib::ext::shared_ptr<FxEqOptionHelper> eqoption = QuantLib::ext::dynamic_pointer_cast<FxEqOptionHelper>(basket[j]);
        if (eqoption != nullptr && parametrization != nullptr && domesticLgm != nullptr) {
            t = domesticLgm->termStructure()->timeFromReference(eqoption->option()->exercise()->date(0));
            modelSigma = parametrization->sigma(t - 1E-4);
        }
        marketVol = basket[j]->volatility()->value();
        modelVol = impliedVolatility(basket[j]);
        volDiff = modelVol - marketVol;
        log << std::setw(3) << j << std::setprecision(6) << std::setw(14) << t << std::setw(14) << modelVol
            << std::setw(14) << marketVol << std::setw(14) << volDiff << std::setw(14) << modelValue << std::setw(14)
            << marketValue << std::setw(14) << valueDiff << std::setw(14) << modelSigma << "\n";
    }
    if (parametrization != nullptr) {
        modelSigma = parametrization->sigma(t + 1E-4);
    }
    log << "t >= " << t << ": eqbsSigma = " << modelSigma << "\n";
    return log.str();
}

Here is the call graph for this function:

◆ getCalibrationDetails() [6/9]

std::string getCalibrationDetails	(	const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	basket,
		const QuantLib::ext::shared_ptr< CommoditySchwartzParametrization > &	parametrization
	)

Definition at line 258 of file utilities.cpp.

                                                                                                                  {
    std::ostringstream log;
    log << std::right << std::setw(3) << "#" << std::setw(14) << "time" << std::setw(14) << "modelVol" << std::setw(14)
        << "marketVol" << std::setw(14) << "(diff)" << std::setw(14) << "modelValue" << std::setw(14) << "marketValue"
        << std::setw(14) << "(diff)" << std::setw(14) << "Sigma" << setw(14) << "Kappa\n";
    Real t = 0.0;
    Real modelSigma = parametrization->sigmaParameter();
    Real modelKappa = parametrization->kappaParameter();
    for (Size j = 0; j < basket.size(); j++) {
        Real modelValue = basket[j]->modelValue();
        Real marketValue = basket[j]->marketValue();
        Real valueDiff = modelValue - marketValue;
        Volatility modelVol = 0, marketVol = 0, volDiff = 0;
        QuantLib::ext::shared_ptr<FutureOptionHelper> option = QuantLib::ext::dynamic_pointer_cast<FutureOptionHelper>(basket[j]);
        if (option != nullptr && parametrization != nullptr) {
            t = option->priceCurve()->timeFromReference(option->option()->exercise()->date(0));
            //modelSigma = parametrization->sigma(t - 1E-4);
        }
        marketVol = basket[j]->volatility()->value();
        modelVol = impliedVolatility(basket[j]);
        volDiff = modelVol - marketVol;
        log << std::setw(3) << j << std::setprecision(6) << std::setw(14) << t << std::setw(14) << modelVol
            << std::setw(14) << marketVol << std::setw(14) << volDiff << std::setw(14) << modelValue << std::setw(14)
            << marketValue << std::setw(14) << valueDiff << std::setw(14) << modelSigma << " " << modelKappa << "\n";
    }
    if (parametrization != nullptr) {
        modelSigma = parametrization->sigma(t + 1E-4);
    }
    log << "t >= " << t << ": Sigma = " << modelSigma << ", Kappa = " << modelKappa << "\n";
    return log.str();
}

Here is the call graph for this function:

◆ getCalibrationDetails() [7/9]

std::string getCalibrationDetails	(	const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	basket,
		const QuantLib::ext::shared_ptr< InfDkParametrization > &	parametrization,
		bool	indexIsInterpolated
	)

Definition at line 291 of file utilities.cpp.

                                                            {
    std::ostringstream log;
    log << std::right << std::setw(3) << "#" << std::setw(14) << "time" << std::setw(14) << "modelValue"
        << std::setw(14) << "marketValue" << std::setw(14) << "(diff)" << std::setw(14) << "infdkAlpha" << std::setw(14)
        << "infdkH\n";
    Real t = 0.0, modelAlpha = 0.0, modelH = 0.0;
    for (Size j = 0; j < basket.size(); j++) {
        Real modelValue = basket[j]->modelValue();
        Real marketValue = basket[j]->marketValue();
        Real valueDiff = (modelValue - marketValue);
        QuantLib::ext::shared_ptr<CpiCapFloorHelper> instr = QuantLib::ext::dynamic_pointer_cast<CpiCapFloorHelper>(basket[j]);
        if (instr != nullptr && parametrization != nullptr) {
            // report alpha, H at t_expiry^-
            t = inflationYearFraction(
                parametrization->termStructure()->frequency(), indexIsInterpolated,
                parametrization->termStructure()->dayCounter(), parametrization->termStructure()->baseDate(),
                instr->instrument()->payDate() - parametrization->termStructure()->observationLag());
            modelAlpha = parametrization->alpha(t - 1.0 / 250.0);
            modelH = parametrization->H(t - 1.0 / 250.0);
        }
        // TODO handle other calibration helpers, too (capfloor)
        log << std::setw(3) << j << std::setprecision(6) << std::setw(14) << t << std::setw(14) << modelValue
            << std::setw(14) << marketValue << std::setw(14) << valueDiff << std::setw(14) << modelAlpha
            << std::setw(14) << modelH << "\n";
    }
    if (parametrization != nullptr) {
        // report alpha, kappa at t_expiry^+ for last expiry
        modelAlpha = parametrization->alpha(t + 1.0 / 250.0);
        modelH = parametrization->H(t + 1.0 / 2500.0);
    }
    log << "t >= " << t << ": infDkAlpha = " << modelAlpha << " infDkH = " << modelH << "\n";
    return log.str();
}

Here is the call graph for this function:

◆ getCalibrationDetails() [8/9]

std::string getCalibrationDetails	(	const vector< QuantLib::ext::shared_ptr< CalibrationHelper > > &	rrBasket,
		const vector< QuantLib::ext::shared_ptr< CalibrationHelper > > &	idxBasket,
		const QuantLib::ext::shared_ptr< InfJyParameterization > &	p,
		bool	calibrateRealRateVol
	)

Definition at line 327 of file utilities.cpp.

                                                                                                               {
 
    ostringstream log;
    Real epsTime = 0.0001;
 
    // Real rate basket: if it has instruments, the real rate was calibrated.
    if (!rrBasket.empty()) {
 
        // Header rows
        log << "Real rate calibration:\n";
        log << right << setw(3) << "#" << setw(5) << "](-" << setw(12) << "inst_date" << setw(12) << "time" << setw(14)
            << "modelValue" << setw(14) << "marketValue" << setw(14) << "(diff)" << setw(14) << "infJyAlpha" << setw(14)
            << "infJyH\n";
 
        // Parameter values for corresponding to maturity of each instrument
        Array times = calibrateRealRateVol ? p->realRate()->parameterTimes(0) : p->realRate()->parameterTimes(1);
        auto helperValues = jyHelperValues(rrBasket, times);
        Size ctr = 0;
        Time t = 0.0;
        for (const auto& kv : helperValues) {
            auto hv = kv.second;
            t = hv.maturity - epsTime;
            string bound = "<=";
            if (helperValues.size() == 1) {
                bound = " -";
            } else if (ctr == helperValues.size() - 1) {
                t += 2 * epsTime;
                bound = " >";
            }
            auto alpha = p->realRate()->alpha(t);
            auto h = p->realRate()->H(t);
            log << setw(3) << ctr++ << setw(5) << bound << setw(6) << io::iso_date(kv.first) << setprecision(6)
                << setw(12) << hv.maturity << setw(14) << hv.modelValue << setw(14) << hv.marketValue << setw(14)
                << hv.error << setw(14) << alpha << setw(14) << h << "\n";
        }
    }
 
    // Inflation index basket: if it has instruments, the inflation index was calibrated.
    if (!idxBasket.empty()) {
 
        // Header rows
        log << "Inflation index calibration:\n";
        log << right << setw(3) << "#" << setw(5) << "](-" << setw(12) << "inst_date" << setw(12) << "time" << setw(14)
            << "modelValue" << setw(14) << "marketValue" << setw(14) << "(diff)" << setw(14) << "infJySigma\n";
 
        // Parameter values for corresponding to maturity of each instrument
        Array times = p->index()->parameterTimes(0);
        auto helperValues = jyHelperValues(idxBasket, times);
        Size ctr = 0;
        Time t = 0.0;
        for (const auto& kv : helperValues) {
            auto hv = kv.second;
            t = hv.maturity - epsTime;
            string bound = "<=";
            if (helperValues.size() == 1) {
                bound = " -";
            } else if (ctr == helperValues.size() - 1) {
                t += 2 * epsTime;
                bound = " >";
            }
            auto sigma = p->index()->sigma(t);
            log << setw(3) << ctr++ << setw(5) << bound << setw(6) << io::iso_date(kv.first) << setprecision(6)
                << setw(12) << hv.maturity << setw(14) << hv.modelValue << setw(14) << hv.marketValue << setw(14)
                << hv.error << setw(14) << sigma << "\n";
        }
    }
 
    return log.str();
}

Here is the call graph for this function:

◆ getCalibrationDetails() [9/9]

std::string getCalibrationDetails ( const QuantLib::ext::shared_ptr< IrLgm1fParametrization > & parametrization )

Definition at line 399 of file utilities.cpp.

                                                                                                   {
    std::ostringstream log;
 
    log << right << setw(3) << "#" << setw(14) << "time" << setw(14) << "irlgm1fAlpha" << setw(14)
        << "irlgm1fHwSigma\n";
    Real t = 0.0;
    Size j = 0;
    for (; j < parametrization->parameterTimes(0).size(); ++j) {
        t = parametrization->parameterTimes(0)[j];
        Real alpha = parametrization->alpha(t - 1E-4);
        Real sigma = parametrization->hullWhiteSigma(t - 1E-4);
        log << setw(3) << j << setprecision(6) << setw(14) << t << setw(14) << alpha << setw(14) << sigma << "\n";
    }
    log << setw(3) << j << setprecision(6) << setw(14) << (std::to_string(t) + "+") << setw(14)
        << parametrization->alpha(t + 1E-4) << setw(14) << parametrization->hullWhiteSigma(t + 1E-4) << "\n";
 
    log << right << setw(3) << "#" << setw(14) << "time" << setw(14) << "irlgm1fKappa" << setw(14) << "irlgm1fH\n";
    t = 0.0;
    j = 0;
    for (; j < parametrization->parameterTimes(1).size(); ++j) {
        t = parametrization->parameterTimes(0)[j];
        Real kappa = parametrization->kappa(t - 1E-4);
        Real H = parametrization->H(t - 1E-4);
        log << setw(3) << j << setprecision(6) << setw(14) << t << setw(14) << kappa << setw(14) << H << "\n";
    }
    log << setw(3) << j << setprecision(6) << setw(14) << (std::to_string(t) + "+") << setw(14)
        << parametrization->kappa(t + 1E-4) << setw(14) << parametrization->H(t + 1E-4) << "\n";
 
    return log.str();
}

Here is the call graph for this function:

◆ optionMaturity() [1/2]

Date optionMaturity	(	const boost::variant< Date, Period > &	maturity,
		const QuantLib::Calendar &	calendar,
		const QuantLib::Date &	referenceDate
	)

Definition at line 447 of file utilities.cpp.

                                                       {
 
    return boost::apply_visitor(MaturityGetter(calendar, referenceDate), maturity);
}

Here is the caller graph for this function:

◆ cpiCapFloorStrikeValue()

Real cpiCapFloorStrikeValue	(	const QuantLib::ext::shared_ptr< BaseStrike > &	strike,
		const QuantLib::ext::shared_ptr< ZeroInflationTermStructure > &	curve,
		const QuantLib::Date &	optionMaturityDate
	)

Return a cpi cap/floor strike value, the input strike can be of type absolute or atm forward.

Definition at line 453 of file utilities.cpp.

                                                                    {
    if (auto abs = QuantLib::ext::dynamic_pointer_cast<AbsoluteStrike>(strike)) {
        return abs->strike();
    } else if (auto atm = QuantLib::ext::dynamic_pointer_cast<AtmStrike>(strike)) {
        QL_REQUIRE(atm->atmType() == DeltaVolQuote::AtmFwd,
                   "only atm forward allowed as atm strike for cpi cap floors");
        return curve->zeroRate(optionMaturityDate);
    } else {
        QL_FAIL("cpi cap floor strike type not supported, expected absolute strike or atm fwd strike, got '"
                << strike->toString());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ yoyCapFloorStrikeValue()

Real yoyCapFloorStrikeValue	(	const QuantLib::ext::shared_ptr< BaseStrike > &	strike,
		const QuantLib::ext::shared_ptr< YoYInflationTermStructure > &	curve,
		const QuantLib::Date &	optionMaturityDate
	)

Return a yoy cap/floor strike value, the input strike can be of type absolute or atm forward.

Definition at line 468 of file utilities.cpp.

                                                                    {
    if (auto abs = QuantLib::ext::dynamic_pointer_cast<AbsoluteStrike>(strike)) {
        return abs->strike();
    } else if (auto atm = QuantLib::ext::dynamic_pointer_cast<AtmStrike>(strike)) {
        QL_REQUIRE(atm->atmType() == DeltaVolQuote::AtmFwd,
                   "only atm forward allowed as atm strike for cpi cap floors");
        return curve->yoyRate(optionMaturityDate);
    } else {
        QL_FAIL("yoy cap floor strike type not supported, expected absolute strike or atm fwd strike, got '"
                << strike->toString());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ atmForward()

Real atmForward	(	const Real	s0,
		const Handle< YieldTermStructure > &	r,
		const Handle< YieldTermStructure > &	q,
		const Real	t
	)

helper function that computes the atm forward

Definition at line 483 of file utilities.cpp.

                                                                                                                       {
    return s0 * q->discount(t) / r->discount(t);
}

Here is the caller graph for this function:

◆ getCalibrationError()

Real getCalibrationError ( const std::vector< QuantLib::ext::shared_ptr< Helper > > & basket )

Definition at line 47 of file utilities.hpp.

                                                                                                            {
    Real rmse = 0.0;
    for (auto const& h : basket) {
        Real tmp = h->calibrationError();
        rmse += tmp * tmp;
    }
    return std::sqrt(rmse / static_cast<Real>(basket.size()));
}

Here is the caller graph for this function:

◆ optionMaturity() [2/2]

QuantLib::Date optionMaturity	(	const boost::variant< QuantLib::Date, QuantLib::Period > &	maturity,
		const QuantLib::Calendar &	calendar,
		const QuantLib::Date &	referenceDate = `Settings::instance().evaluationDate()`
	)

Return an option's maturity date, given an explicit date or a period.

◆ operator<() [7/14]

bool operator<	(	const BasketConstituent &	lhs,
		const BasketConstituent &	rhs
	)

Compare BasketConstituent instances using their credit curve ID.

If credit curve ID is not enough here, we should construct a private key member variable in BasketConstituent and make this operator a friend that uses the key.

Definition at line 255 of file basketdata.cpp.

                                                                           {
    return lhs.creditCurveId() < rhs.creditCurveId();
}

Here is the call graph for this function:

◆ populateFromBondReferenceData()

void populateFromBondReferenceData	(	std::string &	subType,
		std::string &	issuerId,
		std::string &	settlementDays,
		std::string &	calendar,
		std::string &	issueDate,
		std::string &	priceQuoteMethod,
		std::string &	priceQuoteBaseValue,
		std::string &	creditCurveId,
		std::string &	creditGroup,
		std::string &	referenceCurveId,
		std::string &	incomeCurveId,
		std::string &	volatilityCurveId,
		std::vector< LegData > &	coupons,
		const std::string &	name,
		const QuantLib::ext::shared_ptr< BondReferenceDatum > &	bondRefData,
		const std::string &	startDate = `""`,
		const std::string &	endDate = `""`
	)

Populate bond data from name and ReferenceDataManager.

The following elements are references and updated, if empty: issuerId settlementDays calendar issueDate creditCurveId creditGroup referenceCurveId incomeCurveId volatilityCurveId coupons

Definition at line 26 of file bondutils.cpp.

                                                                                         {
    DLOG("populating data bond from reference data");
    QL_REQUIRE(bondRefData, "populateFromBondReferenceData(): empty bond reference datum given");
    if (subType.empty()) {
        subType = bondRefData->bondData().subType;
        TLOG("overwrite subType with '" << subType << "'");
    }
    if (issuerId.empty()) {
        issuerId = bondRefData->bondData().issuerId;
        TLOG("overwrite issuerId with '" << issuerId << "'");
    }
    if (settlementDays.empty()) {
        settlementDays = bondRefData->bondData().settlementDays;
        TLOG("overwrite settlementDays with '" << settlementDays << "'");
    }
    if (calendar.empty()) {
        calendar = bondRefData->bondData().calendar;
        TLOG("overwrite calendar with '" << calendar << "'");
    }
    if (issueDate.empty()) {
        issueDate = bondRefData->bondData().issueDate;
        TLOG("overwrite issueDate with '" << issueDate << "'");
    }
    if (priceQuoteMethod.empty()) {
        priceQuoteMethod = bondRefData->bondData().priceQuoteMethod;
        TLOG("overwrite priceQuoteMethod with '" << priceQuoteMethod << "'");
    }
    if (priceQuoteBaseValue.empty()) {
        priceQuoteBaseValue = bondRefData->bondData().priceQuoteBaseValue;
        TLOG("overwrite priceQuoteBaseValue with '" << priceQuoteBaseValue << "'");
    }
    if (creditCurveId.empty()) {
        creditCurveId = bondRefData->bondData().creditCurveId;
        TLOG("overwrite creditCurveId with '" << creditCurveId << "'");
    }
    if (creditGroup.empty()) {
        creditGroup = bondRefData->bondData().creditGroup;
        TLOG("overwrite creditGroup with '" << creditGroup << "'");
    }
    if (referenceCurveId.empty()) {
        referenceCurveId = bondRefData->bondData().referenceCurveId;
        TLOG("overwrite referenceCurveId with '" << referenceCurveId << "'");
    }
    if (incomeCurveId.empty()) {
        incomeCurveId = bondRefData->bondData().incomeCurveId;
        TLOG("overwrite incomeCurveId with '" << incomeCurveId << "'");
    }
    if (volatilityCurveId.empty()) {
        volatilityCurveId = bondRefData->bondData().volatilityCurveId;
        TLOG("overwrite volatilityCurveId with '" << volatilityCurveId << "'");
    }
    if (coupons.empty()) {
        coupons = bondRefData->bondData().legData;
        TLOG("overwrite coupons with " << coupons.size() << " LegData nodes");
    }
    if (!startDate.empty()) {
        if (coupons.size() == 1 && coupons.front().schedule().rules().size() == 1 && coupons.front().schedule().dates().size() == 0) {
        string oldStart = coupons.front().schedule().rules().front().startDate();
        coupons.front().schedule().modifyRules().front().modifyStartDate() = startDate;
        string newStart = coupons.front().schedule().rules().front().startDate();
        DLOG("Modified start date " << oldStart << " -> " << newStart);
    }
    else {
      StructuredTradeErrorMessage(bondRefData->bondData().issuerId, "Bond-linked", "update reference data",
                                        "modifified start date cannot be applied to multiple legs/schedules")
                .log();
    }
    }
    if (!endDate.empty()) {
        if (coupons.size() == 1 && coupons.front().schedule().rules().size() == 1 && coupons.front().schedule().dates().size() == 0) {
        string oldEnd = coupons.front().schedule().rules().front().endDate();
        coupons.front().schedule().modifyRules().front().modifyEndDate() = endDate;
        string newEnd = coupons.front().schedule().rules().front().endDate();
        DLOG("Modified end date " << oldEnd << " -> " << newEnd);
    }
    else {
      StructuredTradeErrorMessage(bondRefData->bondData().issuerId, "Bond-linked", "update reference data",
                                        "modifified end date cannot be applied to multiple legs/schedules")
                .log();
    }
    }
      
    DLOG("populating bond data from reference data done.");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getOpenEndDateReplacement()

Date getOpenEndDateReplacement	(	const std::string &	replacementPeriodStr,
		const Calendar &	calendar
	)

Definition at line 118 of file bondutils.cpp.

                                                                                                {
    if (replacementPeriodStr.empty())
        return QuantLib::Null<QuantLib::Date>();
    Date today = Settings::instance().evaluationDate();
    Date result = Date::maxDate() - 365;
    try {
        // might throw because we are beyond the last allowed date
        result = (calendar.empty() ? NullCalendar() : calendar).advance(today, parsePeriod(replacementPeriodStr));
    } catch (...) {
    }
    DLOG("Compute open end date replacement as "
         << QuantLib::io::iso_date(result) << " (today = " << QuantLib::io::iso_date(today)
         << ", OpenEndDateReplacement from pricing engine config = " << replacementPeriodStr << ")");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildPerformanceOptimizedDefaultCurves()

std::vector< Handle< DefaultProbabilityTermStructure > > buildPerformanceOptimizedDefaultCurves ( const std::vector< Handle< DefaultProbabilityTermStructure > > & curves )

Disable sensitivites for the all but the first default probability curve Shift all other curves parallel with the first curve, reduce the numbers of calculations

Definition at line 40 of file cdo.cpp.

                                                                                                                                                            {
    std::vector<Handle<DefaultProbabilityTermStructure>> dpts;
    Handle<DefaultProbabilityTermStructure> clientCurve;
    Handle<DefaultProbabilityTermStructure> baseCurve;
    vector<Time> baseCurveTimes;
    
    for (const auto& targetCurve : curves) {
        //For all but the first curve use a spreaded curve, with the first curve as reference and
        //the inital spread between the curve and the first curve, keep the spread constant
        //in case of a spreaded curve we need to use the underlying reference curve to retrieve the
        //correct pillar times, otherwise the interpolation grid is to coarse and we wouldnt match
        //today's market prices
        vector<Time> targetCurveTimes = ore::data::SyntheticCDO::extractTimeGridDefaultCurve(targetCurve);
        // Sort times we need to interpolate an all pillars of the base and target curve
        std::sort(targetCurveTimes.begin(), targetCurveTimes.end());
        // Use the first curve as basis curve and update times
        if (targetCurve == curves.front()) {
            baseCurve = targetCurve;
            clientCurve = baseCurve;
            baseCurveTimes = targetCurveTimes;
        } else {
            std::vector<Time> times;
            std::set_union(baseCurveTimes.begin(), baseCurveTimes.end(), targetCurveTimes.begin(),
                           targetCurveTimes.end(), std::back_inserter(times));
            vector<Handle<Quote>> spreads(times.size());
            std::transform(times.begin(), times.end(), spreads.begin(), [&baseCurve, &targetCurve](Time t) {
                Probability spread =
                    targetCurve->survivalProbability(t, true) / baseCurve->survivalProbability(t, true);
                if (close_enough(spread, 0.0)) {
                    spread = 1e-18;
                }
                return Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(spread));
            });
            clientCurve = Handle<DefaultProbabilityTermStructure>(
                QuantLib::ext::make_shared<SpreadedSurvivalProbabilityTermStructure>(baseCurve, times, spreads));
            if (baseCurve->allowsExtrapolation())
                clientCurve->enableExtrapolation();
        }
        dpts.push_back(clientCurve);
    }
    return dpts;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ycmFromString()

GFunctionFactory::YieldCurveModel ycmFromString ( const string & s )

Definition at line 30 of file cms.cpp.

                                                               {
    if (s == "Standard")
        return GFunctionFactory::Standard;
    else if (s == "ExactYield")
        return GFunctionFactory::ExactYield;
    else if (s == "ParallelShifts")
        return GFunctionFactory::ParallelShifts;
    else if (s == "NonParallelShifts")
        return GFunctionFactory::NonParallelShifts;
    else
        QL_FAIL("unknown string for YieldCurveModel");
}

Here is the caller graph for this function:

◆ operator==() [5/13]

bool operator==	(	const CDSEngineKey &	lhs,
		const CDSEngineKey &	rhs
	)

Definition at line 75 of file creditdefaultswap.hpp.

                                                                         {
 
    // Check the credit curve IDs first
    if (lhs.creditCurveId() != rhs.creditCurveId())
        return false;
 
    // Check the currencies
    if (lhs.currency() != rhs.currency())
        return false;
 
    // Now check recovery rates.
    if (lhs.recoveryRate() == QuantLib::Null<QuantLib::Real>() &&
        rhs.recoveryRate() == QuantLib::Null<QuantLib::Real>()) {
        // Most usual case is both are Null<Real> and using the recovery rate from the market.
        return true;
    } else if ((lhs.recoveryRate() != QuantLib::Null<QuantLib::Real>() &&
                rhs.recoveryRate() == QuantLib::Null<QuantLib::Real>()) ||
               (lhs.recoveryRate() == QuantLib::Null<QuantLib::Real>() &&
                rhs.recoveryRate() != QuantLib::Null<QuantLib::Real>())) {
        return false;
    } else {
        return QuantLib::close(lhs.recoveryRate(), rhs.recoveryRate());
    }
}

Here is the call graph for this function:

◆ operator<() [8/14]

bool operator<	(	const CDSEngineKey &	lhs,
		const CDSEngineKey &	rhs
	)

Definition at line 100 of file creditdefaultswap.hpp.

                                                                        {
 
    // Check equality first
    if (lhs == rhs)
        return false;
 
    // Now check credit curve Ids.
    if (lhs.creditCurveId() != rhs.creditCurveId())
        return lhs.creditCurveId() < rhs.creditCurveId();
 
    // Now check currencies.
    if (lhs.currency() != rhs.currency())
        return lhs.currency().name() < rhs.currency().name();
 
    // Now use the recovery rates
    return lhs.recoveryRate() < rhs.recoveryRate();
}

Here is the call graph for this function:

◆ operator!=() [1/4]

bool operator!=	(	const CDSEngineKey &	lhs,
		const CDSEngineKey &	rhs
	)

Definition at line 118 of file creditdefaultswap.hpp.

118{ return !(lhs == rhs); }

◆ operator>()

bool operator>	(	const CDSEngineKey &	lhs,
		const CDSEngineKey &	rhs
	)

Definition at line 119 of file creditdefaultswap.hpp.

119{ return rhs < lhs; }

◆ operator<=()

bool operator<=	(	const CDSEngineKey &	lhs,
		const CDSEngineKey &	rhs
	)

Definition at line 120 of file creditdefaultswap.hpp.

120{ return !(lhs > rhs); }

◆ operator>=()

bool operator>=	(	const CDSEngineKey &	lhs,
		const CDSEngineKey &	rhs
	)

Definition at line 121 of file creditdefaultswap.hpp.

121{ return !(lhs < rhs); }

◆ parseCommodityPayRelativeTo()

CommodityPayRelativeTo parseCommodityPayRelativeTo ( const string & s )

Definition at line 52 of file commoditylegdata.cpp.

                                                                    {
    if (iequals(s, "CalculationPeriodEndDate")) {
        return CommodityPayRelativeTo::CalculationPeriodEndDate;
    } else if (iequals(s, "CalculationPeriodStartDate")) {
        return CommodityPayRelativeTo::CalculationPeriodStartDate;
    } else if (iequals(s, "TerminationDate")) {
        return CommodityPayRelativeTo::TerminationDate;
    } else if (iequals(s, "FutureExpiryDate")) {
        return CommodityPayRelativeTo::FutureExpiryDate;
    } else {
        QL_FAIL("Could not parse " << s << " to CommodityPayRelativeTo");
    }
}

Here is the caller graph for this function:

◆ operator<<() [29/73]

std::ostream & operator<<	(	ostream &	out,
		const CommodityPayRelativeTo &	cprt
	)

Definition at line 66 of file commoditylegdata.cpp.

                                                                      {
    if (cprt == CommodityPayRelativeTo::CalculationPeriodEndDate) {
        return out << "CalculationPeriodEndDate";
    } else if (cprt == CommodityPayRelativeTo::CalculationPeriodStartDate) {
        return out << "CalculationPeriodStartDate";
    } else if (cprt == CommodityPayRelativeTo::TerminationDate) {
        return out << "TerminationDate";
    } else if (cprt == CommodityPayRelativeTo::FutureExpiryDate) {
        return out << "FutureExpiryDate";
    } else {
        QL_FAIL("Do not recognise CommodityPayRelativeTo " << static_cast<int>(cprt));
    }
}

◆ parseCommodityPriceType()

CommodityPriceType parseCommodityPriceType ( const string & s )

Definition at line 80 of file commoditylegdata.cpp.

                                                            {
    if (iequals(s, "Spot")) {
        return CommodityPriceType::Spot;
    } else if (iequals(s, "FutureSettlement")) {
        return CommodityPriceType::FutureSettlement;
    } else {
        QL_FAIL("Could not parse " << s << " to CommodityPriceType");
    }
}

Here is the caller graph for this function:

◆ operator<<() [30/73]

std::ostream & operator<<	(	ostream &	out,
		const CommodityPriceType &	cpt
	)

Definition at line 90 of file commoditylegdata.cpp.

                                                                 {
    if (cpt == CommodityPriceType::Spot) {
        return out << "Spot";
    } else if (cpt == CommodityPriceType::FutureSettlement) {
        return out << "FutureSettlement";
    } else {
        QL_FAIL("Do not recognise CommodityPriceType " << static_cast<int>(cpt));
    }
}

◆ parseCommodityPricingDateRule()

CommodityPricingDateRule parseCommodityPricingDateRule ( const string & s )

Definition at line 100 of file commoditylegdata.cpp.

                                                                        {
    if (iequals(s, "FutureExpiryDate")) {
        return CommodityPricingDateRule::FutureExpiryDate;
    } else if (iequals(s, "None")) {
        return CommodityPricingDateRule::None;
    } else {
        QL_FAIL("Could not parse " << s << " to CommodityPricingDateRule");
    }
}

Here is the caller graph for this function:

◆ operator<<() [31/73]

std::ostream & operator<<	(	std::ostream &	out,
		const CommodityPricingDateRule &	cpdr
	)

Definition at line 110 of file commoditylegdata.cpp.

                                                                           {
    if (cpdr == CommodityPricingDateRule::FutureExpiryDate) {
        return out << "FutureExpiryDate";
    } else if (cpdr == CommodityPricingDateRule::None) {
        return out << "None";
    } else {
        QL_FAIL("Do not recognise CommodityPricingDateRule " << static_cast<int>(cpdr));
    }
}

◆ makeOptionPaymentDateAdjuster()

QuantLib::ext::shared_ptr< OptionPaymentDateAdjuster > makeOptionPaymentDateAdjuster	(	CommoditySpreadOptionData &	optionData,
		const std::vector< Date > &	expiryDates
	)

Definition at line 112 of file commodityspreadoption.cpp.

                                                                                                               {
 
    if (optionData.optionStrip().has_value()) {
        return QuantLib::ext::make_shared<OptionStripPaymentDateAdjuster>(expiryDates, optionData.optionStrip().get());
    } else if (optionData.optionData().paymentData().has_value()) {
        return QuantLib::ext::make_shared<OptionPaymentDataAdjuster>(optionData.optionData().paymentData().get());
    } else {
        return QuantLib::ext::make_shared<OptionPaymentDateAdjuster>();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parseCdsTier()

CdsTier parseCdsTier ( const string & s )

Definition at line 33 of file creditdefaultswapdata.cpp.

                                      {
    if (s == "SNRFOR") {
        return CdsTier::SNRFOR;
    } else if (s == "SUBLT2") {
        return CdsTier::SUBLT2;
    } else if (s == "SNRLAC") {
        return CdsTier::SNRLAC;
    } else if (s == "SECDOM") {
        return CdsTier::SECDOM;
    } else if (s == "JRSUBUT2") {
        return CdsTier::JRSUBUT2;
    } else if (s == "PREFT1") {
        return CdsTier::PREFT1;
    } else if (s == "LIEN1") {
        return CdsTier::LIEN1;
    } else if (s == "LIEN2") {
        return CdsTier::LIEN2;
    } else if (s == "LIEN3") {
        return CdsTier::LIEN3;
    }
    QL_FAIL("Could not parse \"" << s << "\" to CdsTier");
}

Here is the caller graph for this function:

◆ operator<<() [32/73]

std::ostream & operator<<	(	ostream &	out,
		const CdsTier &	cdsTier
	)

Definition at line 56 of file creditdefaultswapdata.cpp.

                                                          {
    switch (cdsTier) {
    case CdsTier::SNRFOR:
        return out << "SNRFOR";
    case CdsTier::SUBLT2:
        return out << "SUBLT2";
    case CdsTier::SNRLAC:
        return out << "SNRLAC";
    case CdsTier::SECDOM:
        return out << "SECDOM";
    case CdsTier::JRSUBUT2:
        return out << "JRSUBUT2";
    case CdsTier::PREFT1:
        return out << "PREFT1";
    case CdsTier::LIEN1:
        return out << "LIEN1";
    case CdsTier::LIEN2:
        return out << "LIEN2";
    case CdsTier::LIEN3:
        return out << "LIEN3";
    default:
        QL_FAIL("Do not recognise CdsTier " << static_cast<int>(cdsTier));
    }
}

◆ parseCdsDocClause()

CdsDocClause parseCdsDocClause ( const string & s )

Definition at line 81 of file creditdefaultswapdata.cpp.

                                                {
    if (s == "CR") {
        return CdsDocClause::CR;
    } else if (s == "MM") {
        return CdsDocClause::MM;
    } else if (s == "MR") {
        return CdsDocClause::MR;
    } else if (s == "XR") {
        return CdsDocClause::XR;
    } else if (s == "CR14") {
        return CdsDocClause::CR14;
    } else if (s == "MM14") {
        return CdsDocClause::MM14;
    } else if (s == "MR14") {
        return CdsDocClause::MR14;
    } else if (s == "XR14") {
        return CdsDocClause::XR14;
    } else {
        QL_FAIL("Could not parse \"" << s << "\" to CdsDocClause");
    }
}

Here is the caller graph for this function:

◆ operator<<() [33/73]

std::ostream & operator<<	(	ostream &	out,
		const CdsDocClause &	cdsDocClause
	)

Definition at line 103 of file creditdefaultswapdata.cpp.

                                                                    {
    switch (cdsDocClause) {
    case CdsDocClause::CR:
        return out << "CR";
    case CdsDocClause::MM:
        return out << "MM";
    case CdsDocClause::MR:
        return out << "MR";
    case CdsDocClause::XR:
        return out << "XR";
    case CdsDocClause::CR14:
        return out << "CR14";
    case CdsDocClause::MM14:
        return out << "MM14";
    case CdsDocClause::MR14:
        return out << "MR14";
    case CdsDocClause::XR14:
        return out << "XR14";
    default:
        QL_FAIL("Do not recognise CdsDocClause " << static_cast<int>(cdsDocClause));
    }
}

◆ parseIsdaRulesDefinitions()

IsdaRulesDefinitions parseIsdaRulesDefinitions ( const string & s )

Definition at line 127 of file creditdefaultswapdata.cpp.

                                                                {
    if (s == "2003") {
        return IsdaRulesDefinitions::y2003;
    } else if (s == "2014") {
        return IsdaRulesDefinitions::y2014;
    } else {
        QL_FAIL("Could not parse \"" << s << "\" to isdaRulesDefinitions");
    }
}

◆ operator<<() [34/73]

ostream & operator<<	(	ostream &	out,
		const IsdaRulesDefinitions &	isdaRulesDefinitions
	)

Definition at line 137 of file creditdefaultswapdata.cpp.

                                                                                    {
    switch (isdaRulesDefinitions) {
    case IsdaRulesDefinitions::y2003:
        return out << "2003";
    case IsdaRulesDefinitions::y2014:
        return out << "2014";
    default:
        QL_FAIL("Do not recognise IsdaRulesDefinitions " << static_cast<int>(isdaRulesDefinitions));
    }
}

◆ isdaRulesDefinitionsFromDocClause()

IsdaRulesDefinitions isdaRulesDefinitionsFromDocClause ( const CdsDocClause & cdsDocClause )

Definition at line 148 of file creditdefaultswapdata.cpp.

                                                                                         {
    switch (cdsDocClause) {
    case CdsDocClause::CR:
    case CdsDocClause::MR:
    case CdsDocClause::XR:
    case CdsDocClause::MM:
        return IsdaRulesDefinitions::y2003;
    case CdsDocClause::CR14:
    case CdsDocClause::MR14:
    case CdsDocClause::XR14:
    case CdsDocClause::MM14:
    default:
        return IsdaRulesDefinitions::y2014;
    }
}

◆ parseCreditEventType()

CreditEventType parseCreditEventType ( const string & s )

Definition at line 164 of file creditdefaultswapdata.cpp.

                                                      {
    if (s == "BANKRUPTCY") {
        return CreditEventType::BANKRUPTCY;
    } else if (s == "FAILURE TO PAY") {
        return CreditEventType::FAILURE_TO_PAY;
    } else if (s == "RESTRUCTURING") {
        return CreditEventType::RESTRUCTURING;
    } else if (s == "OBLIGATION ACCELERATION") {
        return CreditEventType::OBLIGATION_ACCELERATION;
    } else if (s == "OBLIGATION DEFAULT") {
        return CreditEventType::OBLIGATION_DEFAULT;
    } else if (s == "REPUDIATION/MORATORIUM") {
        return CreditEventType::REPUDIATION_MORATORIUM;
    } else if (s == "GOVERNMENTAL INTERVENTION") {
        return CreditEventType::GOVERNMENTAL_INTERVENTION;
    } else {
        QL_FAIL("Could not parse \"" << s << "\" to a credit event.");
    }
}

◆ operator<<() [35/73]

std::ostream & operator<<	(	ostream &	out,
		const CreditEventType &	creditEventType
	)

Definition at line 184 of file creditdefaultswapdata.cpp.

                                                                          {
    switch (creditEventType) {
    case CreditEventType::BANKRUPTCY:
        return out << "BANKRUPTCY";
    case CreditEventType::FAILURE_TO_PAY:
        return out << "FAILURE TO PAY";
    case CreditEventType::RESTRUCTURING:
        return out << "RESTRUCTURING";
    case CreditEventType::OBLIGATION_ACCELERATION:
        return out << "OBLIGATION ACCELERATION";
    case CreditEventType::OBLIGATION_DEFAULT:
        return out << "OBLIGATION DEFAULT";
    case CreditEventType::REPUDIATION_MORATORIUM:
        return out << "REPUDIATION/MORATORIUM";
    case CreditEventType::GOVERNMENTAL_INTERVENTION:
        return out << "GOVERNMENTAL INTERVENTION";
    default:
        QL_FAIL("Do not recognise CreditEventType " << static_cast<int>(creditEventType));
    }
}

◆ isTriggeredDocClause()

bool isTriggeredDocClause	(	CdsDocClause	contractDocClause,
		CreditEventType	creditEventType
	)

Definition at line 205 of file creditdefaultswapdata.cpp.

                                                                                           {
    switch (creditEventType) {
    case ore::data::CreditEventType::BANKRUPTCY:
    case ore::data::CreditEventType::FAILURE_TO_PAY:
    case ore::data::CreditEventType::REPUDIATION_MORATORIUM:
        // all of the above include a failure to pay
        switch (contractDocClause) {
        case ore::data::CdsDocClause::CR:
        case ore::data::CdsDocClause::CR14:
        case ore::data::CdsDocClause::MM:
        case ore::data::CdsDocClause::MM14:
        case ore::data::CdsDocClause::MR:
        case ore::data::CdsDocClause::MR14:
        case ore::data::CdsDocClause::XR:
        case ore::data::CdsDocClause::XR14:
            return true;
        default:
            break;
        }
        break;
    case ore::data::CreditEventType::GOVERNMENTAL_INTERVENTION:
        // typically includes a conversion to shares with a write down
    case ore::data::CreditEventType::RESTRUCTURING:
        // it depends on the type of restructure!
        switch (contractDocClause) {
        case ore::data::CdsDocClause::CR:
        case ore::data::CdsDocClause::CR14:
        case ore::data::CdsDocClause::MM:
        case ore::data::CdsDocClause::MM14:
        case ore::data::CdsDocClause::MR:
        case ore::data::CdsDocClause::MR14:
            return true;
        case ore::data::CdsDocClause::XR:
        case ore::data::CdsDocClause::XR14:
            return false;
        default:
            break;
        }
    case ore::data::CreditEventType::OBLIGATION_ACCELERATION:
    case ore::data::CreditEventType::OBLIGATION_DEFAULT:
        // not necessarily a default itself, no examples in record.
        return false;
        break;
    default:
        break;
    }
    QL_FAIL("Could not recognize CreditEventType "
            << static_cast<int>(creditEventType) << " or CdsDocClause " << static_cast<int>(contractDocClause)
            << " when identifying whether a doc clause is triggrered for a given credit event type.");
    return false;
}

◆ parseCreditEventTiers()

CreditEventTiers parseCreditEventTiers ( const string & s )

Definition at line 257 of file creditdefaultswapdata.cpp.

                                                        {
    if (s == "SNR") {
        return CreditEventTiers::SNR;
    } else if (s == "SUB") {
        return CreditEventTiers::SUB;
    } else if (s == "SNRLAC") {
        return CreditEventTiers::SNRLAC;
    } else if (s == "SNR/SUB") {
        return CreditEventTiers::SNR_SUB;
    } else if (s == "SNR/SNRLAC") {
        return CreditEventTiers::SNR_SNRLAC;
    } else if (s == "SUB/SNRLAC") {
        return CreditEventTiers::SUB_SNRLAC;
    } else if (s == "SNR/SUB/SNRLAC") {
        return CreditEventTiers::SNR_SUB_SNRLAC;
    } else {
        QL_FAIL("Could not parse \"" << s << "\" to a credit event tiers set.");
    }
}

◆ operator<<() [36/73]

std::ostream & operator<<	(	ostream &	out,
		const CreditEventTiers &	creditEventTiers
	)

Definition at line 277 of file creditdefaultswapdata.cpp.

                                                                            {
    switch (creditEventTiers) {
    case CreditEventTiers::SNR:
        return out << "SNR";
    case CreditEventTiers::SUB:
        return out << "SUB";
    case CreditEventTiers::SNRLAC:
        return out << "SNRLAC";
    case CreditEventTiers::SNR_SUB:
        return out << "SNR/SUB";
    case CreditEventTiers::SNR_SNRLAC:
        return out << "SNR/SNRLAC";
    case CreditEventTiers::SUB_SNRLAC:
        return out << "SUB/SNRLAC";
    case CreditEventTiers::SNR_SUB_SNRLAC:
        return out << "SNR/SUB/SNRLAC";
    default:
        QL_FAIL("Do not recognise CreditEventTiers " << static_cast<int>(creditEventTiers));
    }
}

◆ isAuctionedSeniority()

bool isAuctionedSeniority	(	CdsTier	contractTier,
		CreditEventTiers	creditEventTiers
	)

Definition at line 298 of file creditdefaultswapdata.cpp.

                                                                                   {
    switch (creditEventTiers) {
    case ore::data::CreditEventTiers::SNR:
        switch (contractTier) {
        case ore::data::CdsTier::SNRFOR:
        case ore::data::CdsTier::SECDOM:
        case ore::data::CdsTier::PREFT1:
            return true;
        case ore::data::CdsTier::SUBLT2:
        case ore::data::CdsTier::JRSUBUT2:
        case ore::data::CdsTier::SNRLAC:
            return false;
        default:
            break;
        }
        break;
    case ore::data::CreditEventTiers::SUB:
        switch (contractTier) {
        case ore::data::CdsTier::SUBLT2:
        case ore::data::CdsTier::JRSUBUT2:
            return true;
        case ore::data::CdsTier::SNRFOR:
        case ore::data::CdsTier::SECDOM:
        case ore::data::CdsTier::PREFT1:
        case ore::data::CdsTier::SNRLAC:
            return false;
        default:
            break;
        }
        break;
    case ore::data::CreditEventTiers::SNRLAC:
        switch (contractTier) {
        case ore::data::CdsTier::SNRLAC:
            return true;
        case ore::data::CdsTier::SNRFOR:
        case ore::data::CdsTier::SECDOM:
        case ore::data::CdsTier::PREFT1:
        case ore::data::CdsTier::SUBLT2:
        case ore::data::CdsTier::JRSUBUT2:
            return false;
        default:
            break;
        }
        break;
    case ore::data::CreditEventTiers::SNR_SUB:
        switch (contractTier) {
        case ore::data::CdsTier::SNRFOR:
        case ore::data::CdsTier::SECDOM:
        case ore::data::CdsTier::PREFT1:
        case ore::data::CdsTier::SUBLT2:
        case ore::data::CdsTier::JRSUBUT2:
            return true;
        case ore::data::CdsTier::SNRLAC:
            return false;
        default:
            break;
        }
        break;
    case ore::data::CreditEventTiers::SNR_SNRLAC:
        switch (contractTier) {
        case ore::data::CdsTier::SNRFOR:
        case ore::data::CdsTier::SECDOM:
        case ore::data::CdsTier::PREFT1:
        case ore::data::CdsTier::SNRLAC:
            return true;
        case ore::data::CdsTier::SUBLT2:
        case ore::data::CdsTier::JRSUBUT2:
            return false;
        default:
            break;
        }
        break;
    case ore::data::CreditEventTiers::SUB_SNRLAC:
        switch (contractTier) {
        case ore::data::CdsTier::SUBLT2:
        case ore::data::CdsTier::JRSUBUT2:
        case ore::data::CdsTier::SNRLAC:
            return true;
        case ore::data::CdsTier::SNRFOR:
        case ore::data::CdsTier::SECDOM:
        case ore::data::CdsTier::PREFT1:
            return false;
        default:
            break;
        }
        break;
    case ore::data::CreditEventTiers::SNR_SUB_SNRLAC:
        switch (contractTier) {
        case ore::data::CdsTier::SUBLT2:
        case ore::data::CdsTier::JRSUBUT2:
        case ore::data::CdsTier::SNRLAC:
        case ore::data::CdsTier::SNRFOR:
        case ore::data::CdsTier::SECDOM:
        case ore::data::CdsTier::PREFT1:
            return true;
        default:
            break;
        }
        break;
    default:
        break;
    }
    QL_FAIL("Could not recognize CreditEventTiers "
            << static_cast<int>(creditEventTiers) << " or CdsTier " << static_cast<int>(contractTier)
            << " when identifying the applicability if an event for a given contract tier.");
    return false;
}

◆ getLowerAndUpperBound()

std::pair< std::string, std::string > getLowerAndUpperBound	(	const std::string &	type,
		const std::string &	binaryLevelA,
		const std::string &	binaryLevelB
	)

Definition at line 26 of file doubledigitaloption.cpp.

                                                                                         {
    if (type == "Call") {
        return {binaryLevelA, ore::data::to_string(QL_MAX_REAL)};
    } else if (type == "Put") {
        return {ore::data::to_string(QL_MIN_REAL), binaryLevelA};
    } else if (type == "Collar") {
        return {binaryLevelA, binaryLevelB};
    } else {
        QL_FAIL("DoubleDigitalOption got unexpected option type '"
                << type << "'. Valid values are 'Call', 'Put' and 'Collar'.");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator==() [6/13]

bool operator==	(	const EngineData &	lhs,
		const EngineData &	rhs
	)

Definition at line 127 of file enginedata.cpp.

                                                              {
    vector<string> products = lhs.products();
    // this assumes they are both sorted the same
    if (products != rhs.products())
        return false;
    // now loop over the products and check everything
    for (auto product : products) {
        if (lhs.model(product) != rhs.model(product) || lhs.modelParameters(product) != rhs.modelParameters(product) ||
            lhs.engine(product) != rhs.engine(product) ||
            lhs.engineParameters(product) != rhs.engineParameters(product))
            return false;
    }
    return true;
}

Here is the call graph for this function:

◆ operator!=() [2/4]

bool operator!=	(	const EngineData &	lhs,
		const EngineData &	rhs
	)

Definition at line 142 of file enginedata.cpp.

142{ return !(lhs == rhs); }

◆ makeEquityMarginLeg() [1/2]

QuantExt::Leg makeEquityMarginLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< EquityIndex2 > &	equityCurve,
		const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &	fxIndex,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 79 of file equityfxlegdata.cpp.

                                                                              {
    QuantLib::ext::shared_ptr<EquityMarginLegData> eqMarginLegData = QuantLib::ext::dynamic_pointer_cast<EquityMarginLegData>(data.concreteLegData());
    QL_REQUIRE(eqMarginLegData, "Wrong LegType, expected EquityMargin, got " << data.legType());
    QuantLib::ext::shared_ptr<ore::data::EquityLegData> eqLegData = eqMarginLegData->equityLegData();
    QL_REQUIRE(eqLegData, "expected equityLegData");
    QuantExt::Schedule schedule = makeSchedule(data.schedule(), openEndDateReplacement);
    DayCounter dc = parseDayCounter(data.dayCounter());
    BusinessDayConvention bdc = ore::data::parseBusinessDayConvention(data.paymentConvention());
    bool isTotalReturn = eqLegData->returnType() == EquityReturnType::Total;
    Real dividendFactor = eqLegData->dividendFactor();
    Real initialPrice = eqLegData->initialPrice();
    bool initialPriceIsInTargetCcy = false;
 
    if (!eqLegData->initialPriceCurrency().empty()) {
        // parse currencies to handle minor currencies
        Currency initialPriceCurrency = parseCurrencyWithMinors(eqLegData->initialPriceCurrency());
        Currency dataCurrency = parseCurrencyWithMinors(data.currency());
        Currency eqCurrency;
        // set equity currency
        if (!equityCurve->currency().empty())
            eqCurrency = equityCurve->currency();
        else
            TLOG("Cannot find currency for equity " << equityCurve->name());
 
        // initial price currency must match leg or equity currency
        QL_REQUIRE(initialPriceCurrency == dataCurrency ||
            initialPriceCurrency == eqCurrency || eqCurrency.empty(),
                   "initial price ccy (" << initialPriceCurrency << ") must match either leg ccy ("
                                         << dataCurrency << ") or equity ccy (if given, got '"
                                         << eqCurrency << "')");
        initialPriceIsInTargetCcy = initialPriceCurrency == dataCurrency;
        // adjust for minor currency
        initialPrice = convertMinorToMajorCurrency(eqLegData->initialPriceCurrency(), initialPrice);
    }
    bool notionalReset = eqLegData->notionalReset();
    Natural fixingDays = eqLegData->fixingDays();
    PaymentLag paymentLag = parsePaymentLag(data.paymentLag());
    ScheduleData valuationData = eqLegData->valuationSchedule();
    Schedule valuationSchedule;
    if (valuationData.hasData())
        valuationSchedule = makeSchedule(valuationData, openEndDateReplacement);
    vector<double> notionals = buildScheduledVector(data.notionals(), data.notionalDates(), schedule);
    vector<double> rates = buildScheduledVector(eqMarginLegData->rates(), eqMarginLegData->rateDates(), schedule);
 
    applyAmortization(notionals, data, schedule, false);
    Leg leg = EquityMarginLeg(schedule, equityCurve, fxIndex)
                  .withCouponRates(rates, dc)
                  .withInitialMarginFactor(eqMarginLegData->initialMarginFactor())
                  .withNotionals(notionals)
                  .withQuantity(eqLegData->quantity())
                  .withPaymentDayCounter(dc)
                  .withPaymentAdjustment(bdc)
                  .withPaymentLag(boost::apply_visitor(PaymentLagInteger(), paymentLag))
                  .withTotalReturn(isTotalReturn)
                  .withDividendFactor(dividendFactor)
                  .withInitialPrice(initialPrice)
                  .withInitialPriceIsInTargetCcy(initialPriceIsInTargetCcy)
                  .withNotionalReset(notionalReset)
                  .withFixingDays(fixingDays)
                  .withValuationSchedule(valuationSchedule)
                  .withMultiplier(eqMarginLegData->multiplier());
 
    QL_REQUIRE(leg.size() > 0, "Empty Equity Margin Leg");
 
    return leg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeEquityMarginLeg() [2/2]

QuantExt::Leg makeEquityMarginLeg	(	const ore::data::LegData &	data,
		const QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 > &	equityCurve,
		const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &	fxIndex = `nullptr`,
		const QuantLib::Date &	openEndDateReplacement = `QuantLib::Null< QuantLib::Date >()`
	)

◆ operator<() [9/14]

bool operator<	(	const RequiredFixings::FixingEntry &	lhs,
		const RequiredFixings::FixingEntry &	rhs
	)

Definition at line 150 of file fixingdates.cpp.

                                                                                             {
    return std::tie(lhs.indexName, lhs.fixingDate, lhs.payDate, lhs.alwaysAddIfPaysOnSettlement, lhs.mandatory) <
           std::tie(rhs.indexName, rhs.fixingDate, rhs.payDate, rhs.alwaysAddIfPaysOnSettlement, rhs.mandatory);
}

◆ operator<() [10/14]

bool operator<	(	const RequiredFixings::InflationFixingEntry &	lhs,
		const RequiredFixings::InflationFixingEntry &	rhs
	)

Definition at line 155 of file fixingdates.cpp.

                                                                                                               {
    return std::tie(lhs.indexName, lhs.fixingDate, lhs.payDate, lhs.alwaysAddIfPaysOnSettlement, lhs.mandatory,
                    lhs.indexInterpolated, lhs.availabilityLeg, lhs.indexFreq) <
           std::tie(rhs.indexName, rhs.fixingDate, rhs.payDate, rhs.alwaysAddIfPaysOnSettlement, rhs.mandatory,
                    rhs.indexInterpolated, rhs.availabilityLeg, rhs.indexFreq);
}

◆ operator<() [11/14]

bool operator<	(	const RequiredFixings::ZeroInflationFixingEntry &	lhs,
		const RequiredFixings::ZeroInflationFixingEntry &	rhs
	)

Definition at line 162 of file fixingdates.cpp.

                                                                   {
    return std::tie(lhs.indexName, lhs.fixingDate, lhs.payDate, lhs.alwaysAddIfPaysOnSettlement, lhs.mandatory,
                    lhs.indexInterpolated, lhs.availabilityLeg, lhs.indexFreq, lhs.couponFrequency,
                    lhs.couponInterpolation) < std::tie(rhs.indexName, rhs.fixingDate, rhs.payDate,
                                                        rhs.alwaysAddIfPaysOnSettlement, rhs.mandatory,
                                                        rhs.indexInterpolated, rhs.availabilityLeg, rhs.indexFreq,
                                                        rhs.couponFrequency, rhs.couponInterpolation);
}

◆ operator<<() [37/73]

std::ostream & operator<<	(	std::ostream &	out,
		const ore::data::RequiredFixings::FixingEntry &	f
	)

Definition at line 433 of file fixingdates.cpp.

                                                                                    {
 
    std::string indexName = f.indexName;
    Date fixingDate = f.fixingDate;
    Date payDate = f.payDate;
    bool alwaysAddIfPaysOnSettlement = f.alwaysAddIfPaysOnSettlement;
    bool mandatory = f.mandatory;
    out << indexName << " " << QuantLib::io::iso_date(fixingDate) << " " << QuantLib::io::iso_date(payDate) << " "
        << std::boolalpha << alwaysAddIfPaysOnSettlement << " " << std::boolalpha << mandatory << "\n";
    return out;
}

Here is the call graph for this function:

◆ operator<<() [38/73]

std::ostream & operator<<	(	std::ostream &	out,
		const std::set< ore::data::RequiredFixings::FixingEntry > &	entries
	)

Definition at line 445 of file fixingdates.cpp.

                                                                                                  {
    for (auto const& f : entries) {
        out << f;
    }
    return out;
}

◆ operator<<() [39/73]

std::ostream & operator<<	(	std::ostream &	out,
		const std::set< ore::data::RequiredFixings::InflationFixingEntry > &	entries
	)

Definition at line 452 of file fixingdates.cpp.

                                                                                                           {
    for (auto const& f : entries) {
        out << f;
    }
    return out;
}

◆ operator<<() [40/73]

std::ostream & operator<<	(	std::ostream &	out,
		const std::set< ore::data::RequiredFixings::ZeroInflationFixingEntry > &	entries
	)

Definition at line 459 of file fixingdates.cpp.

                                                                                                {
    for (auto const& f : entries) {
        out << f;
    }
    return out;
}

◆ operator<<() [41/73]

std::ostream & operator<<	(	std::ostream &	out,
		const RequiredFixings &	f
	)

allow output of required fixings data via streams

Definition at line 467 of file fixingdates.cpp.

                                                                                {
    out << "IndexName FixingDate PayDate AlwaysAddIfPaysOnSettlement\n";
    out << requiredFixings.fixingDates_;
    out << requiredFixings.zeroInflationFixingDates_;
    out << requiredFixings.yoyInflationFixingDates_;
    return out;
}

◆ addToRequiredFixings()

void addToRequiredFixings	(	const QuantLib::Leg &	leg,
		const QuantLib::ext::shared_ptr< FixingDateGetter > &	fixingDateGetter
	)

Populates a RequiredFixings instance based on a given QuantLib::Leg

Definition at line 789 of file fixingdates.cpp.

                                                                                                                   {
    for (auto const& c : leg) {
        QL_REQUIRE(c, "addToRequiredFixings(), got null cashflow, this is unexpected");
        c->accept(*fixingDateGetter);
    }
}

Here is the caller graph for this function:

◆ amendInflationFixingDates()

void amendInflationFixingDates ( std::map< std::string, RequiredFixings::FixingDates > & fixings )

Inflation fixings are generally available on a monthly, or coarser, frequency. When a portfolio is asked for its fixings, and it contains inflation fixings, ORE will by convention put the fixing date as the 1st day of the applicable inflation period. Some market data providers by convention supply the inflation fixings with the date as the last date of the applicable inflation period. This function scans the fixings map, and moves any inflation fixing dates from the 1st day of the inflation period to the last day of the inflation period. The key in the fixings map is the index name and the value is the set of dates for which we require the fixings.

If inflation indices have been set up via ZeroInflationIndex entries in the Conventions, the conventions should be passed here. If not, the default nullptr parameter will be sufficient.

Definition at line 796 of file fixingdates.cpp.

                                                                                       {
    // Loop over indices and amend any that are of type InflationIndex
    for (auto& [indexName, fixingDates] : fixings) {
        auto [isInfIndex, infIndex] = isInflationIndex(indexName);
        if (isInfIndex) {
            // We have an inflation index
            RequiredFixings::FixingDates amendedFixingDates;
            Frequency f = infIndex->frequency();
            for (const auto& [d, mandatory] : fixingDates) {
                auto period = inflationPeriod(d, f);
                if (d == period.first) {
                    // If the fixing date is the start of the inflation period, move it to the end.
                    amendedFixingDates.addDate(period.second, mandatory);
                } else {
                    // If the fixing date is not the start of the inflation period, leave it as it is.
                    amendedFixingDates.addDate(d, mandatory);
                }
            }
            // Update the fixings map that was passed in with the new set of dates
            fixings[indexName] = amendedFixingDates;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addMarketFixingDates() [1/2]

void addMarketFixingDates	(	const Date &	asof,
		map< string, RequiredFixings::FixingDates > &	fixings,
		const TodaysMarketParameters &	mktParams,
		const Period &	iborLookback,
		const Period &	oisLookback,
		const Period &	bmaLookback,
		const Period &	inflationLookback
	)

Definition at line 820 of file fixingdates.cpp.

                                                           {
 
    for (auto const& [configuration, _] : mktParams.configurations()) {
 
        LOG("Start adding market fixing dates for configuration '" << configuration << "'");
 
        QuantLib::ext::shared_ptr<Conventions> conventions = InstrumentConventions::instance().conventions();
 
        // If there are ibor indices in the market parameters, add the lookback fixings
        // IF there are SIFMA / BMA indices, add lookback fixings for the Libor basis index
        if (mktParams.hasMarketObject(MarketObject::IndexCurve)) {
 
            QL_REQUIRE(iborLookback >= 0 * Days, "Ibor lookback period must be non-negative");
 
            DLOG("Start adding market fixing dates for interest rate indices.");
 
            set<Date> iborDates;
            set<Date> oisDates;
            set<Date> bmaDates;
            WeekendsOnly calendar;
 
            std::set<std::string> indices;
            for (auto const& [i, _] : mktParams.mapping(MarketObject::IndexCurve, configuration)) {
                indices.insert(i);
            }
            for (auto const& [i, _] : mktParams.mapping(MarketObject::YieldCurve, configuration)) {
                QuantLib::ext::shared_ptr<IborIndex> dummy;
                if (tryParseIborIndex(i, dummy))
                    indices.insert(i);
            }
            for (auto const& [_, s] : mktParams.mapping(MarketObject::DiscountCurve, configuration)) {
                auto spec = parseCurveSpec(s);
                QuantLib::ext::shared_ptr<IborIndex> dummy;
                if (tryParseIborIndex(spec->curveConfigID(), dummy))
                    indices.insert(spec->curveConfigID());
            }
 
            // For each of the IR indices in market parameters, insert the dates
            for (const auto& i : indices) {
                if (isOvernightIndex(i)) {
                    if (oisDates.empty()) {
                        TLOG("Generating fixing dates for overnight indices.");
                        oisDates = generateLookbackDates(asof, oisLookback, calendar);
                    }
                    TLOG("Adding extra fixing dates for overnight index " << i);
                    fixings[i].addDates(oisDates, false);
                    
                } else if (isBmaIndex(i)) {
                    if (bmaDates.empty()) {
                        TLOG("Generating fixing dates for bma/sifma indices.");
                        bmaDates = generateLookbackDates(asof, bmaLookback, calendar);
                    }
                    fixings[i].addDates(bmaDates, false);
                    if (iborDates.empty()) {
                        TLOG("Generating fixing dates for ibor indices.");
                        iborDates = generateLookbackDates(asof, iborLookback, calendar);
                    }
                    std::set<string> liborNames;
                    for (auto const& c : conventions->get(Convention::Type::BMABasisSwap)) {
                        auto bma = QuantLib::ext::dynamic_pointer_cast<BMABasisSwapConvention>(c);
                        QL_REQUIRE(
                            bma, "internal error, could not cast to BMABasisSwapConvention in addMarketFixingDates()");
                        if (bma->bmaIndexName() == i) {
                            liborNames.insert(bma->liborIndexName());
                        }
                    }
                    for (auto const& l : liborNames) {
                        TLOG("Adding extra fixing dates for libor index " << l << " from bma/sifma index " << i);
                        fixings[l].addDates(iborDates, false);
                    }
                } else {
                    if (iborDates.empty()) {
                        TLOG("Generating fixing dates for ibor indices.");
                        iborDates = generateLookbackDates(asof, iborLookback, calendar);
                    }
                    TLOG("Adding extra fixing dates for ibor index " << i);
                    fixings[i].addDates(iborDates, false);
                }
            }
 
            DLOG("Finished adding market fixing dates for interest rate indices.");
        }
 
        // If there are inflation indices in the market parameters, add the lookback fixings
        if (mktParams.hasMarketObject(MarketObject::ZeroInflationCurve) ||
            mktParams.hasMarketObject(MarketObject::YoYInflationCurve)) {
 
            QL_REQUIRE(inflationLookback >= 0 * Days, "Inflation lookback period must be non-negative");
 
            // Dates that will be used for each of the inflation indices
            Date lookback = NullCalendar().advance(asof, -inflationLookback);
            lookback = Date(1, lookback.month(), lookback.year());
            set<Date> dates;
            do {
                TLOG("Adding date " << io::iso_date(lookback) << " to fixings for inflation indices");
                dates.insert(lookback);
                lookback = NullCalendar().advance(lookback, 1 * Months);
            } while (lookback <= asof);
 
            // For each of the inflation indices in market parameters, insert the dates
            if (mktParams.hasMarketObject(MarketObject::ZeroInflationCurve)) {
                for (const auto& kv : mktParams.mapping(MarketObject::ZeroInflationCurve, configuration)) {
                    TLOG("Adding extra fixing dates for (zero) inflation index " << kv.first);
                    fixings[kv.first].addDates(dates, false);
                }
            }
 
            if (mktParams.hasMarketObject(MarketObject::YoYInflationCurve)) {
                for (const auto& kv : mktParams.mapping(MarketObject::YoYInflationCurve, configuration)) {
                    TLOG("Adding extra fixing dates for (yoy) inflation index " << kv.first);
                    fixings[kv.first].addDates(dates, false);
                }
            }
        }
 
        // If there are commodity curves, add "fixings" for this month and two previous months. We add "fixings" for
        // future contracts with expiry from two months hence to two months prior.
        if (mktParams.hasMarketObject(MarketObject::CommodityCurve)) {
 
            // "Fixing" dates for commodities.
            Period commodityLookback = 2 * Months;
            Date lookback = asof - commodityLookback;
            lookback = Date(1, lookback.month(), lookback.year());
            set<Date> dates;
            do {
                TLOG("Adding date " << io::iso_date(lookback) << " to fixings for commodities");
                dates.insert(lookback++);
            } while (lookback <= asof);
 
            // Expiry months and years for which we require future contract fixings. For our purposes here, using the
            // 1st of the month does not matter. We will just use the date to get the appropriate commodity future
            // index name below when adding the dates and the "-01" will be removed (for non-daily contracts).
            Size numberMonths = 2;
            vector<Date> contractExpiries;
            Date startContract = asof - numberMonths * Months;
            Date endContract = asof + numberMonths * Months;
            do {
                Month m = startContract.month();
                Year y = startContract.year();
                TLOG("Adding contract month and year (" << m << "," << y << ")");
                contractExpiries.push_back(Date(1, m, y));
                startContract += 1 * Months;
            } while (startContract <= endContract);
 
            // For each of the commodity names, create the future contract name with the relevant expiry and insert
            // the dates. Skip commodity names that do not have future conventions.
            for (const auto& kv : mktParams.mapping(MarketObject::CommodityCurve, configuration)) {
 
                QuantLib::ext::shared_ptr<CommodityFutureConvention> cfc;
                if (conventions->has(kv.first)) {
                    cfc = QuantLib::ext::dynamic_pointer_cast<CommodityFutureConvention>(conventions->get(kv.first));
                }
 
                auto commIdx = parseCommodityIndex(kv.first, false);
                if (cfc) {
                    if (auto oppIdx = QuantLib::ext::dynamic_pointer_cast<OffPeakPowerIndex>(commIdx)) {
                        DLOG("Commodity " << kv.first << " is off-peak power so adding underlying daily contracts.");
                        const auto& opIndex = oppIdx->offPeakIndex();
                        const auto& pIndex = oppIdx->peakIndex();
                        for (const Date& expiry : dates) {
                            auto tmpIdx = oppIdx->clone(expiry);
                            auto opName = opIndex->clone(expiry)->name();
                            TLOG("Adding (date, id) = (" << io::iso_date(expiry) << "," << opName << ")");
                            fixings[opName].addDate(expiry, false);
                            auto pName = pIndex->clone(expiry)->name();
                            TLOG("Adding (date, id) = (" << io::iso_date(expiry) << "," << pName << ")");
                            fixings[pName].addDate(expiry, false);
                        }
                    } else if (cfc->contractFrequency() == Daily) {
                        DLOG("Commodity " << kv.first << " has daily frequency so adding daily contracts.");
                        for (const Date& expiry : dates) {
                            auto indexName = commIdx->clone(expiry)->name();
                            TLOG("Adding (date, id) = (" << io::iso_date(expiry) << "," << indexName << ")");
                            fixings[indexName].addDate(expiry, false);
                        }
                    } else {
                        DLOG("Commodity " << kv.first << " is not daily so adding the monthly contracts.");
                        for (const Date& expiry : contractExpiries) {
                            auto indexName = commIdx->clone(expiry)->name();
                            TLOG("Adding extra fixing dates for commodity future " << indexName);
                            fixings[indexName].addDates(dates, false);
                        }
                    }
                } else {
                    // Assumption here is that we have a spot index.
                    DLOG("Commodity " << kv.first << " does not have future conventions so adding daily fixings.");
                    auto indexName = commIdx->name();
                    TLOG("Adding extra fixing dates for commodity spot " << indexName);
                    fixings[indexName].addDates(dates, false);
                }
            }
        }
 
        LOG("Finished adding market fixing dates for configuration '" << configuration << "'");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addMarketFixingDates() [2/2]

void addMarketFixingDates	(	const QuantLib::Date &	asof,
		std::map< std::string, RequiredFixings::FixingDates > &	fixings,
		const TodaysMarketParameters &	mktParams,
		const QuantLib::Period &	iborLookback = `5 *QuantLib::Days`,
		const QuantLib::Period &	oisLookback = `4 *QuantLib::Months`,
		const QuantLib::Period &	bmaLookback = `2 *QuantLib::Weeks`,
		const QuantLib::Period &	inflationLookback = `1 *QuantLib::Years`
	)

Add index and fixing date pairs to fixings that will be potentially needed to build a TodaysMarket.

These additional index and fixing date pairs are found by scanning the mktParams and:

for MarketObject::IndexCurve, take the ibor index name and add the dates for each weekday between settlement date minus iborLookback period or oisLookback period and settlement date. The distinction between Ibor and OIS is made here to cover the fixings necessary for OIS futures. The default value of 4 months covers OIS futures with a contract period of up to 3 months. It would need to be configured differently if OIS futures with a longer contract period are possible.
for MarketObject::ZeroInflationCurve, take the inflation index and add the first of each month between settlement date minus inflationLookback period and settlement date
for MarketObject::YoYInflationCurve, take the inflation index and add the first of each month between settlement date minus inflationLookback period and settlement date
for MarketObject::CommodityCurve, add fixings for future contracts expiring 2 months either side of the settlement date. The fixing dates are added for each weekday going back to the first day of the month that precedes the settlement date by 2 months. The approach here will give rise to some spot commodities being given a future contract name and dates added against them - this should not be a problem as there will be no fixings found for them in any case.

The original fixings map may be empty.

◆ makeFormulaBasedIndex()

QuantLib::ext::shared_ptr< QuantExt::FormulaBasedIndex > makeFormulaBasedIndex	(	const std::string &	formula,
		const QuantLib::ext::shared_ptr< ore::data::Market >	market,
		const std::string &	configuration,
		std::map< std::string, QuantLib::ext::shared_ptr< QuantLib::InterestRateIndex > > &	indexMaps,
		const Calendar &	fixingCalendar = `Calendar()`
	)

builds a formula based index using the ibor and swap indices in the given market, the fixing calendar is the joint holiday calendar of all constituents of the resulting index

Definition at line 33 of file formulabasedindexbuilder.cpp.

                                                      {
 
    indexMaps.clear();
    std::vector<QuantLib::ext::shared_ptr<QuantLib::InterestRateIndex>> indices;
    std::vector<std::string> variables;
    QuantExt::CompiledFormula compiledFormula = parseFormula(formula, variables);
    Calendar fixCal = NullCalendar();
    for (auto const& v : variables) {
        QuantLib::ext::shared_ptr<InterestRateIndex> index;
        QuantLib::ext::shared_ptr<IborIndex> dummyIborIndex;
        if (ore::data::tryParseIborIndex(v, dummyIborIndex)) {
            index = *market->iborIndex(v, configuration);
        } else {
            // if it is not an ibor index, we know it must be a swap index
            index = *market->swapIndex(v, configuration);
        }
        QL_REQUIRE(index != nullptr, "makeFormulaBasedIndex("
                                         << formula << "): variable \"" << v
                                         << "\" could not resolved as an ibor or swap index in the given market");
        indices.push_back(index);
        fixCal = JointCalendar(fixCal, index->fixingCalendar());
        indexMaps[v] = index;
    }
 
    QuantLib::ext::shared_ptr<QuantExt::FormulaBasedIndex> fbi = QuantLib::ext::make_shared<QuantExt::FormulaBasedIndex>(
        "FormulaBasedIndex", indices, compiledFormula, fixingCalendar == Calendar() ? fixCal : fixingCalendar);
    return fbi;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeFormulaBasedLeg()

Leg makeFormulaBasedLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< QuantExt::FormulaBasedIndex > &	formulaBasedIndex,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const std::map< std::string, QuantLib::ext::shared_ptr< QuantLib::InterestRateIndex > > &	indexMaps,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 117 of file formulabasedlegdata.cpp.

                                                                    {
    auto formulaBasedData = QuantLib::ext::dynamic_pointer_cast<FormulaBasedLegData>(data.concreteLegData());
    QL_REQUIRE(formulaBasedData, "Wrong LegType, expected FormulaBased, got " << data.legType());
    Currency paymentCurrency = parseCurrency(data.currency());
    Schedule schedule = makeSchedule(data.schedule(), openEndDateReplacement);
    if (schedule.size() < 2)
        return Leg();
    Calendar paymentCalendar;
    if (data.paymentCalendar().empty())
        paymentCalendar = schedule.calendar();
    else
        paymentCalendar = parseCalendar(data.paymentCalendar());
    PaymentLag paymentLag = parsePaymentLag(data.paymentLag());
    // day counter is optional in leg data in general, but here we need it
    QL_REQUIRE(data.dayCounter() != "", "makeFormulaBasedLeg(): day counter must be given");
    DayCounter dc = parseDayCounter(data.dayCounter());
    // bdc is optional too, but all the other legs just do this, too ?!
    // FIXME, to be solved for all leg types, here we do as in the other legs
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
    auto formulaBasedLegData = QuantLib::ext::dynamic_pointer_cast<FormulaBasedLegData>(data.concreteLegData());
    vector<double> notionals = buildScheduledVector(data.notionals(), data.notionalDates(), schedule);
 
    ore::data::applyAmortization(notionals, data, schedule);
    // amortization type annuity is not allowed, check this
    for (auto const& amort : data.amortizationData()) {
        if (!amort.initialized())
            continue;
        AmortizationType amortizationType = parseAmortizationType(amort.type());
        QL_REQUIRE(amortizationType != AmortizationType::Annuity,
                   "AmortizationType " << amort.type() << " not supported for Formula based legs");
    }
 
    QuantExt::FormulaBasedLeg formulaBasedLeg =
        QuantExt::FormulaBasedLeg(paymentCurrency, schedule, formulaBasedIndex)
            .withNotionals(notionals)
            .withPaymentCalendar(paymentCalendar)
            .withPaymentLag(boost::apply_visitor(PaymentLagInteger(), paymentLag))
            .withPaymentDayCounter(dc)
            .withPaymentAdjustment(bdc)
            .withFixingDays(formulaBasedData->fixingDays())
            .inArrears(formulaBasedData->isInArrears());
 
    auto couponPricer = getFormulaBasedCouponPricer(formulaBasedIndex, paymentCurrency, engineFactory, indexMaps);
 
    // make sure leg is built before pricers are set...
    Leg tmp = formulaBasedLeg;
    QuantExt::setCouponPricer(tmp, couponPricer);
    return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkBarrier()

bool checkBarrier	(	Real	spot,
		Barrier::Type	type,
		Real	barrier
	)

Definition at line 182 of file fxdigitalbarrieroption.cpp.

                                                             {
    switch (type) {
    case Barrier::DownIn:
    case Barrier::DownOut:
        return spot <= barrier;
    case Barrier::UpIn:
    case Barrier::UpOut:
        return spot >= barrier;
    default:
        QL_FAIL("unknown barrier type " << type);
    }
}

◆ lessThan()

bool lessThan	(	const string &	s1,
		const string &	s2
	)

Definition at line 92 of file legdata.cpp.

92{ return s1 < s2; }

Here is the caller graph for this function:

◆ makeSimpleLeg()

Leg makeSimpleLeg ( const LegData & data )

Definition at line 934 of file legdata.cpp.

                                       {
    QuantLib::ext::shared_ptr<CashflowData> cashflowData = QuantLib::ext::dynamic_pointer_cast<CashflowData>(data.concreteLegData());
    QL_REQUIRE(cashflowData, "Wrong LegType, expected CashFlow, got " << data.legType());
 
    const vector<double>& amounts = cashflowData->amounts();
    const vector<string>& dates = cashflowData->dates();
    QL_REQUIRE(amounts.size() == dates.size(), "Amounts / Date size mismatch in makeSimpleLeg."
                                                   << "Amounts:" << amounts.size() << ", Dates:" << dates.size());
    Leg leg;
    for (Size i = 0; i < dates.size(); i++) {
        Date d = parseDate(dates[i]);
        leg.push_back(QuantLib::ext::shared_ptr<CashFlow>(new SimpleCashFlow(amounts[i], d)));
    }
    return leg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeFixedLeg()

Leg makeFixedLeg	(	const LegData &	data,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 950 of file legdata.cpp.

                                                                                  {
 
    QuantLib::ext::shared_ptr<FixedLegData> fixedLegData = QuantLib::ext::dynamic_pointer_cast<FixedLegData>(data.concreteLegData());
    QL_REQUIRE(fixedLegData, "Wrong LegType, expected Fixed, got " << data.legType());
 
    // build schedules
 
    Schedule schedule;
    Schedule paymentSchedule;
    ScheduleBuilder scheduleBuilder;
    scheduleBuilder.add(schedule, data.schedule());
    scheduleBuilder.add(paymentSchedule, data.paymentSchedule());
    scheduleBuilder.makeSchedules(openEndDateReplacement);
 
    // Get explicit payment dates, if given
 
    vector<Date> paymentDates;
 
    if (!paymentSchedule.empty()) {
        paymentDates = paymentSchedule.dates();
    } else if (!data.paymentDates().empty()) {
        BusinessDayConvention paymentDatesConvention =
            data.paymentConvention().empty() ? Unadjusted : parseBusinessDayConvention(data.paymentConvention());
        Calendar paymentDatesCalendar =
            data.paymentCalendar().empty() ? NullCalendar() : parseCalendar(data.paymentCalendar());
        paymentDates = parseVectorOfValues<Date>(data.paymentDates(), &parseDate);
        for (Size i = 0; i < paymentDates.size(); i++)
            paymentDates[i] = paymentDatesCalendar.adjust(paymentDates[i], paymentDatesConvention);
    }
 
    // set payment calendar
 
    Calendar paymentCalendar;
    if (!data.paymentCalendar().empty())
        paymentCalendar = parseCalendar(data.paymentCalendar());
    else if (!paymentSchedule.calendar().empty())
        paymentCalendar = paymentSchedule.calendar();
    else if (!schedule.calendar().empty())
        paymentCalendar = schedule.calendar();
 
    // set day counter and bdc
 
    DayCounter dc = parseDayCounter(data.dayCounter());
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
 
    // build standard schedules (for non-strict notional dates)
 
    vector<double> rates = buildScheduledVector(fixedLegData->rates(), fixedLegData->rateDates(), schedule);
    vector<double> notionals = buildScheduledVectorNormalised(data.notionals(), data.notionalDates(), schedule, 0.0);
 
    // parse payment lag
 
    PaymentLag paymentLag = parsePaymentLag(data.paymentLag());
 
    // apply amortization
 
    applyAmortization(notionals, data, schedule, true, rates);
 
    // build leg
 
    if (!data.strictNotionalDates()) {
 
        // no strict notional dates
 
        Leg leg = FixedRateLeg(schedule)
                      .withNotionals(notionals)
                      .withCouponRates(rates, dc)
                      .withPaymentAdjustment(bdc)
                      .withPaymentLag(boost::apply_visitor(PaymentLagInteger(), paymentLag))
                      .withPaymentCalendar(paymentCalendar)
                      .withLastPeriodDayCounter(data.lastPeriodDayCounter().empty()
                                                    ? DayCounter()
                                                    : parseDayCounter(data.lastPeriodDayCounter()))
                      .withPaymentDates(paymentDates);
        return leg;
 
    } else {
 
        // strict notional dates
 
        std::vector<Date> notionalDatesAsDates;
        std::vector<Date> rateDatesAsDates;
 
        for (auto const& d : data.notionalDates()) {
            if (!d.empty())
                notionalDatesAsDates.push_back(parseDate(d));
        }
 
        for (auto const& d : fixedLegData->rateDates()) {
            if (!d.empty())
                rateDatesAsDates.push_back(parseDate(d));
        }
 
        return makeNonStandardFixedLeg(schedule.dates(), paymentDates, data.notionals(), notionalDatesAsDates,
                                       fixedLegData->rates(), rateDatesAsDates, data.strictNotionalDates(), dc,
                                       paymentCalendar, bdc, boost::apply_visitor(PaymentLagPeriod(), paymentLag));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeZCFixedLeg()

Leg makeZCFixedLeg	(	const LegData &	data,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 1049 of file legdata.cpp.

                                                                                    {
    QuantLib::ext::shared_ptr<ZeroCouponFixedLegData> zcFixedLegData =
        QuantLib::ext::dynamic_pointer_cast<ZeroCouponFixedLegData>(data.concreteLegData());
    QL_REQUIRE(zcFixedLegData, "Wrong LegType, expected Zero Coupon Fixed, got " << data.legType());
 
    Schedule schedule = makeSchedule(data.schedule(), openEndDateReplacement);
 
    Calendar paymentCalendar;
    if (data.paymentCalendar().empty())
        paymentCalendar = schedule.calendar();
    else
        paymentCalendar = parseCalendar(data.paymentCalendar());
 
    BusinessDayConvention payConvention = parseBusinessDayConvention(data.paymentConvention());
    PaymentLag paymentLag = parsePaymentLag(data.paymentLag());
    Natural paymentLagDays = boost::apply_visitor(PaymentLagInteger(), paymentLag);
 
    DayCounter dc = parseDayCounter(data.dayCounter());
 
    Size numNotionals = data.notionals().size();
    Size numRates = zcFixedLegData->rates().size();
    Size numDates = schedule.size();
 
    QL_REQUIRE(numDates >= 2, "Incorrect number of schedule dates entered, expected at least 2, got " << numDates);
    QL_REQUIRE(numNotionals >= 1,
               "Incorrect number of notional values entered, expected at least1, got " << numNotionals);
    QL_REQUIRE(numRates >= 1, "Incorrect number of rate values entered, expected at least 1, got " << numRates);
 
    vector<Date> dates = schedule.dates();
 
    vector<double> rates = buildScheduledVector(zcFixedLegData->rates(), zcFixedLegData->rateDates(), schedule);
    vector<double> notionals = buildScheduledVectorNormalised(data.notionals(), data.notionalDates(), schedule, 0.0);
 
    Compounding comp = parseCompounding(zcFixedLegData->compounding());
    QL_REQUIRE(comp == QuantLib::Compounded || comp == QuantLib::Simple,
               "Compounding method " << zcFixedLegData->compounding() << " not supported");
 
    Leg leg;
    vector<Date> cpnDates;
    cpnDates.push_back(dates.front());
 
    for (Size i = 0; i < numDates - 1; i++) {
 
        double currentNotional = i < notionals.size() ? notionals[i] : notionals.back();
        double currentRate = i < rates.size() ? rates[i] : rates.back();
        cpnDates.push_back(dates[i + 1]);
        Date paymentDate = paymentCalendar.advance(dates[i + 1], paymentLagDays, Days, payConvention);
        leg.push_back(QuantLib::ext::make_shared<ZeroFixedCoupon>(paymentDate, currentNotional, currentRate, dc, cpnDates, comp,
                                                          zcFixedLegData->subtractNotional()));
    }
    return leg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeIborLeg()

Leg makeIborLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< IborIndex > &	index,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const bool	attachPricer,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 1102 of file legdata.cpp.

                                                            {
 
    QuantLib::ext::shared_ptr<FloatingLegData> floatData = QuantLib::ext::dynamic_pointer_cast<FloatingLegData>(data.concreteLegData());
    QL_REQUIRE(floatData, "Wrong LegType, expected Floating, got " << data.legType());
 
    // build schedules
 
    Schedule schedule;
    Schedule fixingSchedule;
    Schedule resetSchedule;
    Schedule paymentSchedule;
    ScheduleBuilder scheduleBuilder;
    scheduleBuilder.add(schedule, data.schedule());
    scheduleBuilder.add(fixingSchedule, floatData->fixingSchedule());
    scheduleBuilder.add(resetSchedule, floatData->resetSchedule());
    scheduleBuilder.add(paymentSchedule, data.paymentSchedule());
    scheduleBuilder.makeSchedules(openEndDateReplacement);
 
    // Get explicit payment dates, if given
 
    vector<Date> paymentDates;
 
    if (!paymentSchedule.empty()) {
        paymentDates = paymentSchedule.dates();
    } else if (!data.paymentDates().empty()) {
        BusinessDayConvention paymentDatesConvention =
            data.paymentConvention().empty() ? Unadjusted : parseBusinessDayConvention(data.paymentConvention());
        Calendar paymentDatesCalendar =
            data.paymentCalendar().empty() ? NullCalendar() : parseCalendar(data.paymentCalendar());
        paymentDates = parseVectorOfValues<Date>(data.paymentDates(), &parseDate);
        for (Size i = 0; i < paymentDates.size(); i++)
            paymentDates[i] = paymentDatesCalendar.adjust(paymentDates[i], paymentDatesConvention);
    }
 
    // set payment calendar
 
    Calendar paymentCalendar;
    if (!data.paymentCalendar().empty())
        paymentCalendar = parseCalendar(data.paymentCalendar());
    else if (!paymentSchedule.calendar().empty())
        paymentCalendar = paymentSchedule.calendar();
    else if (!schedule.calendar().empty())
        paymentCalendar = schedule.calendar();
 
    // set day counter and bdc
 
    DayCounter dc = parseDayCounter(data.dayCounter());
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
 
    // flag whether caps / floors are present
 
    bool hasCapsFloors = floatData->caps().size() > 0 || floatData->floors().size() > 0;
 
    // build standard schedules (for non-strict notional dates)
 
    vector<double> notionals = buildScheduledVectorNormalised(data.notionals(), data.notionalDates(), schedule, 0.0);
    vector<double> spreads =
        buildScheduledVectorNormalised(floatData->spreads(), floatData->spreadDates(), schedule, 0.0);
    vector<double> gearings =
        buildScheduledVectorNormalised(floatData->gearings(), floatData->gearingDates(), schedule, 1.0);
 
    // set fixing days and in arrears flag
 
    Size fixingDays = floatData->fixingDays() == Null<Size>() ? index->fixingDays() : floatData->fixingDays();
    bool isInArrears = floatData->isInArrears() ? *floatData->isInArrears() : false;
 
    // apply amortization
 
    applyAmortization(notionals, data, schedule, true);
 
    // handle float annuity, which is not done in applyAmortization, for this we can only have one block
 
    if (!data.amortizationData().empty()) {
        AmortizationType amortizationType = parseAmortizationType(data.amortizationData().front().type());
        if (amortizationType == AmortizationType::Annuity) {
            LOG("Build floating annuity notional schedule");
            QL_REQUIRE(data.amortizationData().size() == 1,
                       "Can have one AmortizationData block only for floating leg annuities");
            QL_REQUIRE(!hasCapsFloors, "Caps/Floors not supported in floating annuity coupons");
            QL_REQUIRE(floatData->gearings().size() == 0, "Gearings not supported in floating annuity coupons");
            DayCounter dc = index->dayCounter();
            Date startDate = data.amortizationData().front().startDate().empty()
                                 ? Date::minDate()
                                 : parseDate(data.amortizationData().front().startDate());
            double annuity = data.amortizationData().front().value();
            bool underflow = data.amortizationData().front().underflow();
            vector<QuantLib::ext::shared_ptr<Coupon>> coupons;
            for (Size i = 0; i < schedule.size() - 1; i++) {
                Date paymentDate = paymentCalendar.adjust(schedule[i + 1], bdc);
                if (schedule[i] < startDate || i == 0) {
                    QuantLib::ext::shared_ptr<FloatingRateCoupon> coupon;
                    if (!floatData->hasSubPeriods()) {
                        coupon = QuantLib::ext::make_shared<IborCoupon>(paymentDate, notionals[i], schedule[i], schedule[i + 1],
                                                                fixingDays, index, gearings[i], spreads[i], Date(),
                                                                Date(), dc, isInArrears);
                        coupon->setPricer(QuantLib::ext::make_shared<BlackIborCouponPricer>());
                    } else {
                        coupon = QuantLib::ext::make_shared<QuantExt::SubPeriodsCoupon1>(
                            paymentDate, notionals[i], schedule[i], schedule[i + 1], index,
                            floatData->isAveraged() ? QuantExt::SubPeriodsCoupon1::Averaging
                                                    : QuantExt::SubPeriodsCoupon1::Compounding,
                            index->businessDayConvention(), spreads[i], dc, floatData->includeSpread(), gearings[i]);
                        coupon->setPricer(QuantLib::ext::make_shared<QuantExt::SubPeriodsCouponPricer1>());
                    }
                    coupons.push_back(coupon);
                    LOG("FloatingAnnuityCoupon: " << i << " " << coupon->nominal() << " " << coupon->amount());
                } else {
                    QL_REQUIRE(coupons.size() > 0,
                               "FloatingAnnuityCoupon needs at least one predecessor, e.g. a plain IborCoupon");
                    LOG("FloatingAnnuityCoupon, previous nominal/coupon: " << i << " " << coupons.back()->nominal()
                                                                           << " " << coupons.back()->amount());
                    QuantLib::ext::shared_ptr<QuantExt::FloatingAnnuityCoupon> coupon =
                        QuantLib::ext::make_shared<QuantExt::FloatingAnnuityCoupon>(
                            annuity, underflow, coupons.back(), paymentDate, schedule[i], schedule[i + 1], fixingDays,
                            index, gearings[i], spreads[i], Date(), Date(), dc, isInArrears);
                    coupons.push_back(coupon);
                    LOG("FloatingAnnuityCoupon: " << i << " " << coupon->nominal() << " " << coupon->amount());
                }
            }
            Leg leg;
            for (Size i = 0; i < coupons.size(); i++)
                leg.push_back(coupons[i]);
            LOG("Floating annuity notional schedule done");
            return leg;
        }
    }
 
    // handle sub periods leg
 
    if (floatData->hasSubPeriods()) {
        QL_REQUIRE(floatData->caps().empty() && floatData->floors().empty(),
                   "SubPeriodsLegs does not support caps or floors");
        QL_REQUIRE(!isInArrears, "SubPeriodLegs do not support in arrears fixings");
        Leg leg = QuantExt::SubPeriodsLeg1(schedule, index)
                      .withNotionals(notionals)
                      .withPaymentDayCounter(dc)
                      .withPaymentAdjustment(bdc)
                      .withGearings(gearings)
                      .withSpreads(spreads)
                      .withType(floatData->isAveraged() ? QuantExt::SubPeriodsCoupon1::Averaging
                                                        : QuantExt::SubPeriodsCoupon1::Compounding)
                      .includeSpread(floatData->includeSpread());
        QuantExt::setCouponPricer(leg, QuantLib::ext::make_shared<QuantExt::SubPeriodsCouponPricer1>());
        return leg;
    }
 
    // parse payment lag
 
    PaymentLag paymentLag = parsePaymentLag(data.paymentLag());
 
    // handle ibor leg
 
    Leg tmpLeg;
    bool isNonStandard;
 
    if (!data.strictNotionalDates() && fixingSchedule.empty() && resetSchedule.empty()) {
 
        // no strict notional dates, no fixing or reset schedule
 
        IborLeg iborLeg = IborLeg(schedule, index)
                              .withNotionals(notionals)
                              .withSpreads(spreads)
                              .withPaymentCalendar(paymentCalendar)
                              .withPaymentDayCounter(dc)
                              .withPaymentAdjustment(bdc)
                              .withFixingDays(fixingDays)
                              .inArrears(isInArrears)
                              .withGearings(gearings)
                              .withPaymentLag(boost::apply_visitor(PaymentLagInteger(), paymentLag))
                              .withPaymentDates(paymentDates);
        if (floatData->caps().size() > 0)
            iborLeg.withCaps(buildScheduledVector(floatData->caps(), floatData->capDates(), schedule));
        if (floatData->floors().size() > 0)
            iborLeg.withFloors(buildScheduledVector(floatData->floors(), floatData->floorDates(), schedule));
 
        tmpLeg = iborLeg;
        isNonStandard = false;
 
    } else {
 
        // strict notional dates, fixing or reset schedule present
 
        QL_REQUIRE(!hasCapsFloors, "Ibor leg with strict notional or reset dates, explicit fixing or reset schedule "
                                   "does not support cap / floors");
 
        std::vector<Date> notionalDatesAsDates;
        std::vector<Date> spreadDatesAsDates;
        std::vector<Date> gearingDatesAsDates;
 
        for (auto const& d : data.notionalDates()) {
            if (!d.empty())
                notionalDatesAsDates.push_back(parseDate(d));
        }
 
        for (auto const& d : floatData->spreadDates()) {
            if (!d.empty())
                spreadDatesAsDates.push_back(parseDate(d));
        }
 
        for (auto const& d : floatData->gearingDates()) {
            if (!d.empty())
                gearingDatesAsDates.push_back(parseDate(d));
        }
 
        tmpLeg = makeNonStandardIborLeg(index, schedule.dates(), paymentDates, fixingSchedule.dates(),
                                        resetSchedule.dates(), fixingDays, data.notionals(), notionalDatesAsDates,
                                        floatData->spreads(), spreadDatesAsDates, floatData->gearings(),
                                        gearingDatesAsDates, data.strictNotionalDates(), dc, paymentCalendar, bdc,
                                        boost::apply_visitor(PaymentLagPeriod(), paymentLag), isInArrears);
 
        isNonStandard = true;
    }
 
    if (attachPricer && (hasCapsFloors || isInArrears || isNonStandard)) {
        auto builder = engineFactory->builder("CapFlooredIborLeg");
        QL_REQUIRE(builder, "No builder found for CapFlooredIborLeg");
        auto cappedFlooredIborBuilder = QuantLib::ext::dynamic_pointer_cast<CapFlooredIborLegEngineBuilder>(builder);
        auto couponPricer = cappedFlooredIborBuilder->engine(IndexNameTranslator::instance().oreName(index->name()));
        QuantLib::setCouponPricer(tmpLeg, couponPricer);
    }
 
    // build naked option leg if required
 
    if (floatData->nakedOption()) {
        tmpLeg = StrippedCappedFlooredCouponLeg(tmpLeg);
    }
 
    // return the leg
 
    return tmpLeg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeOISLeg()

Leg makeOISLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< OvernightIndex > &	index,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const bool	attachPricer,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 1336 of file legdata.cpp.

                                                           {
    QuantLib::ext::shared_ptr<FloatingLegData> floatData = QuantLib::ext::dynamic_pointer_cast<FloatingLegData>(data.concreteLegData());
    QL_REQUIRE(floatData, "Wrong LegType, expected Floating, got " << data.legType());
 
    auto tmp = data.schedule();
 
    /* For schedules with 1D tenor, this ensures that the index calendar supersedes the calendar provided
     in the trade XML and using "following" rolling conventions to avoid differing calendars and subsequent
     "degenerate schedule" errors in the building of the overnight coupon value date schedules.
     Generally, "1D" is an unusual tenor to use (and often just an error in the input data), but we want to
     make sure that this edge case works technically. */
    for (auto& r : tmp.modifyRules()) {
        if (r.tenor() == "1D") {
            r.modifyCalendar() = to_string(index->fixingCalendar());
            r.modifyConvention() = "F";
            r.modifyTermConvention() = "F";
        }
    }
 
    Schedule schedule = makeSchedule(tmp, openEndDateReplacement);
    DayCounter dc = parseDayCounter(data.dayCounter());
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
    PaymentLag paymentLag = parsePaymentLag(data.paymentLag());
 
    // Get explicit payment dates which in most cases should be empty
    vector<Date> paymentDates;
    if (!data.paymentDates().empty()) {
        BusinessDayConvention paymentDatesConvention =
            data.paymentConvention().empty() ? Unadjusted : parseBusinessDayConvention(data.paymentConvention());
        Calendar paymentDatesCalendar =
            data.paymentCalendar().empty() ? NullCalendar() : parseCalendar(data.paymentCalendar());
        paymentDates = parseVectorOfValues<Date>(data.paymentDates(), &parseDate);
        for (Size i = 0; i < paymentDates.size(); i++)
            paymentDates[i] = paymentDatesCalendar.adjust(paymentDates[i], paymentDatesConvention);
    }
 
    // try to set the rate computation period based on the schedule tenor
    Period rateComputationPeriod = 0 * Days;
    if (!tmp.rules().empty() && !tmp.rules().front().tenor().empty())
        rateComputationPeriod = parsePeriod(tmp.rules().front().tenor());
    else if (!tmp.dates().empty() && !tmp.dates().front().tenor().empty())
        rateComputationPeriod = parsePeriod(tmp.dates().front().tenor());
 
    Calendar paymentCalendar;
    if (data.paymentCalendar().empty())
        paymentCalendar = index->fixingCalendar();
    else
        paymentCalendar = parseCalendar(data.paymentCalendar());
 
    vector<double> notionals = buildScheduledVectorNormalised(data.notionals(), data.notionalDates(), schedule, 0.0);
    vector<double> spreads =
        buildScheduledVectorNormalised(floatData->spreads(), floatData->spreadDates(), schedule, 0.0);
    vector<double> gearings =
        buildScheduledVectorNormalised(floatData->gearings(), floatData->gearingDates(), schedule, 1.0);
    bool isInArrears = floatData->isInArrears() ? *floatData->isInArrears() : true;
 
    applyAmortization(notionals, data, schedule, false);
 
    if (floatData->isAveraged()) {
 
        QuantLib::ext::shared_ptr<QuantExt::AverageONIndexedCouponPricer> couponPricer =
            QuantLib::ext::make_shared<QuantExt::AverageONIndexedCouponPricer>();
 
        QuantLib::ext::shared_ptr<QuantExt::CapFlooredAverageONIndexedCouponPricer> cfCouponPricer;
        if (attachPricer && (floatData->caps().size() > 0 || floatData->floors().size() > 0)) {
            auto builder = QuantLib::ext::dynamic_pointer_cast<CapFlooredAverageONIndexedCouponLegEngineBuilder>(
                engineFactory->builder("CapFlooredAverageONIndexedCouponLeg"));
            QL_REQUIRE(builder, "No builder found for CapFlooredAverageONIndexedCouponLeg");
            cfCouponPricer = QuantLib::ext::dynamic_pointer_cast<CapFlooredAverageONIndexedCouponPricer>(
                builder->engine(IndexNameTranslator::instance().oreName(index->name()), rateComputationPeriod));
            QL_REQUIRE(cfCouponPricer, "internal error, could not cast to CapFlooredAverageONIndexedCouponPricer");
        }
 
        QuantExt::AverageONLeg leg =
            QuantExt::AverageONLeg(schedule, index)
                .withNotionals(notionals)
                .withSpreads(spreads)
                .withPaymentCalendar(paymentCalendar)
                .withGearings(gearings)
                .withPaymentDayCounter(dc)
                .withPaymentAdjustment(bdc)
                .withPaymentLag(boost::apply_visitor(PaymentLagInteger(), paymentLag))
                .withInArrears(isInArrears)
                .withLastRecentPeriod(floatData->lastRecentPeriod())
                .withLastRecentPeriodCalendar(floatData->lastRecentPeriodCalendar().empty()
                                                  ? Calendar()
                                                  : parseCalendar(floatData->lastRecentPeriodCalendar()))
                .withLookback(floatData->lookback())
                .withRateCutoff(floatData->rateCutoff() == Null<Size>() ? 0 : floatData->rateCutoff())
                .withFixingDays(floatData->fixingDays())
                .withCaps(buildScheduledVectorNormalised<Real>(floatData->caps(), floatData->capDates(), schedule,
                                                               Null<Real>()))
                .withFloors(buildScheduledVectorNormalised<Real>(floatData->floors(), floatData->capDates(), schedule,
                                                                 Null<Real>()))
                .withNakedOption(floatData->nakedOption())
                .includeSpreadInCapFloors(floatData->includeSpread())
                .withLocalCapFloor(floatData->localCapFloor())
                .withAverageONIndexedCouponPricer(couponPricer)
                .withCapFlooredAverageONIndexedCouponPricer(cfCouponPricer)
                .withTelescopicValueDates(floatData->telescopicValueDates())
                .withPaymentDates(paymentDates);
        return leg;
 
    } else {
 
        QuantLib::ext::shared_ptr<QuantExt::OvernightIndexedCouponPricer> couponPricer =
            QuantLib::ext::make_shared<QuantExt::OvernightIndexedCouponPricer>();
 
        QuantLib::ext::shared_ptr<QuantExt::CappedFlooredOvernightIndexedCouponPricer> cfCouponPricer;
        if (attachPricer && (floatData->caps().size() > 0 || floatData->floors().size() > 0)) {
            auto builder = QuantLib::ext::dynamic_pointer_cast<CapFlooredOvernightIndexedCouponLegEngineBuilder>(
                engineFactory->builder("CapFlooredOvernightIndexedCouponLeg"));
            QL_REQUIRE(builder, "No builder found for CapFlooredOvernightIndexedCouponLeg");
            cfCouponPricer = QuantLib::ext::dynamic_pointer_cast<QuantExt::CappedFlooredOvernightIndexedCouponPricer>(
                builder->engine(IndexNameTranslator::instance().oreName(index->name()), rateComputationPeriod));
            QL_REQUIRE(cfCouponPricer, "internal error, could not cast to CapFlooredAverageONIndexedCouponPricer");
        }
 
        Leg leg = QuantExt::OvernightLeg(schedule, index)
                      .withNotionals(notionals)
                      .withSpreads(spreads)
                      .withPaymentDayCounter(dc)
                      .withPaymentAdjustment(bdc)
                      .withPaymentCalendar(paymentCalendar)
                      .withPaymentLag(boost::apply_visitor(PaymentLagInteger(), paymentLag))
                      .withGearings(gearings)
                      .withInArrears(isInArrears)
                      .withLastRecentPeriod(floatData->lastRecentPeriod())
                      .withLastRecentPeriodCalendar(floatData->lastRecentPeriodCalendar().empty()
                                                        ? Calendar()
                                                        : parseCalendar(floatData->lastRecentPeriodCalendar()))
                      .includeSpread(floatData->includeSpread())
                      .withLookback(floatData->lookback())
                      .withFixingDays(floatData->fixingDays())
                      .withRateCutoff(floatData->rateCutoff() == Null<Size>() ? 0 : floatData->rateCutoff())
                      .withCaps(buildScheduledVectorNormalised<Real>(floatData->caps(), floatData->capDates(), schedule,
                                                                     Null<Real>()))
                      .withFloors(buildScheduledVectorNormalised<Real>(floatData->floors(), floatData->capDates(),
                                                                       schedule, Null<Real>()))
                      .withNakedOption(floatData->nakedOption())
                      .withLocalCapFloor(floatData->localCapFloor())
                      .withOvernightIndexedCouponPricer(couponPricer)
                      .withCapFlooredOvernightIndexedCouponPricer(cfCouponPricer)
                      .withTelescopicValueDates(floatData->telescopicValueDates())
                      .withPaymentDates(paymentDates);
 
        // If the overnight index is BRL CDI, we need a special coupon pricer
        QuantLib::ext::shared_ptr<BRLCdi> brlCdiIndex = QuantLib::ext::dynamic_pointer_cast<BRLCdi>(index);
        if (brlCdiIndex)
            QuantExt::setCouponPricer(leg, QuantLib::ext::make_shared<BRLCdiCouponPricer>());
 
        return leg;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeBMALeg()

Leg makeBMALeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< QuantExt::BMAIndexWrapper > &	indexWrapper,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 1493 of file legdata.cpp.

                                                                                                                      {
    QuantLib::ext::shared_ptr<FloatingLegData> floatData = QuantLib::ext::dynamic_pointer_cast<FloatingLegData>(data.concreteLegData());
    QL_REQUIRE(floatData, "Wrong LegType, expected Floating, got " << data.legType());
    QuantLib::ext::shared_ptr<BMAIndex> index = indexWrapper->bma();
 
    Schedule schedule = makeSchedule(data.schedule(), openEndDateReplacement);
    DayCounter dc = parseDayCounter(data.dayCounter());
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
    Calendar paymentCalendar;
 
    if (data.paymentCalendar().empty())
        paymentCalendar = schedule.calendar();
    else
        paymentCalendar = parseCalendar(data.paymentCalendar());
 
    vector<Real> notionals = buildScheduledVectorNormalised(data.notionals(), data.notionalDates(), schedule, 0.0);
    vector<Real> spreads =
        buildScheduledVectorNormalised(floatData->spreads(), floatData->spreadDates(), schedule, 0.0);
    vector<Real> gearings =
        buildScheduledVectorNormalised(floatData->gearings(), floatData->gearingDates(), schedule, 1.0);
    vector<Real> caps =
        buildScheduledVectorNormalised(floatData->caps(), floatData->capDates(), schedule, (Real)Null<Real>());
    vector<Real> floors =
        buildScheduledVectorNormalised(floatData->floors(), floatData->floorDates(), schedule, (Real)Null<Real>());
 
    applyAmortization(notionals, data, schedule, false);
 
    Leg leg = AverageBMALeg(schedule, index)
                  .withNotionals(notionals)
                  .withSpreads(spreads)
                  .withPaymentDayCounter(dc)
                  .withPaymentCalendar(paymentCalendar)
                  .withPaymentAdjustment(bdc)
                  .withGearings(gearings);
 
    // try to set the rate computation period based on the schedule tenor
 
    Period rateComputationPeriod = 0 * Days;
    if (!data.schedule().rules().empty() && !data.schedule().rules().front().tenor().empty())
        rateComputationPeriod = parsePeriod(data.schedule().rules().front().tenor());
    else if (!data.schedule().dates().empty() && !data.schedule().dates().front().tenor().empty())
        rateComputationPeriod = parsePeriod(data.schedule().dates().front().tenor());
 
    // handle caps / floors
 
    if (floatData->caps().size() > 0 || floatData->floors().size() > 0) {
 
        QuantLib::ext::shared_ptr<QuantExt::CapFlooredAverageBMACouponPricer> cfCouponPricer;
        auto builder = QuantLib::ext::dynamic_pointer_cast<CapFlooredAverageBMACouponLegEngineBuilder>(
            engineFactory->builder("CapFlooredAverageBMACouponLeg"));
        QL_REQUIRE(builder, "No builder found for CapFlooredAverageBMACouponLeg");
        cfCouponPricer = QuantLib::ext::dynamic_pointer_cast<CapFlooredAverageBMACouponPricer>(
            builder->engine(IndexNameTranslator::instance().oreName(index->name()), rateComputationPeriod));
        QL_REQUIRE(cfCouponPricer, "internal error, could not cast to CapFlooredAverageBMACouponPricer");
 
        for (Size i = 0; i < leg.size(); ++i) {
            auto bmaCpn = QuantLib::ext::dynamic_pointer_cast<AverageBMACoupon>(leg[i]);
            QL_REQUIRE(bmaCpn, "makeBMALeg(): internal error, exepcted AverageBMACoupon. Contact dev.");
            if (caps[i] != Null<Real>() || floors[i] != Null<Real>()) {
                auto cpn = QuantLib::ext::make_shared<CappedFlooredAverageBMACoupon>(
                    bmaCpn, caps[i], floors[i], floatData->nakedOption(), floatData->includeSpread());
                cpn->setPricer(cfCouponPricer);
                leg[i] = cpn;
            }
        }
    }
 
    // return the leg
 
    return leg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeNotionalLeg() [1/2]

Leg makeNotionalLeg	(	const Leg &	refLeg,
		const bool	initNomFlow,
		const bool	finalNomFlow,
		const bool	amortNomFlow,
		const Natural	notionalPaymentLag,
		const BusinessDayConvention	paymentConvention,
		const Calendar	paymentCalendar,
		const bool	excludeIndexing
	)

Definition at line 1566 of file legdata.cpp.

                                                                                {
 
    // Assumption - Cashflows on Input Leg are all coupons
    // This is the Leg to be populated
    Leg leg;
 
    // Initial Flow Amount
    if (initNomFlow) {
        auto coupon = QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(refLeg[0]);
        QL_REQUIRE(coupon, "makeNotionalLeg does not support non-coupon legs");
        double initFlowAmt = (excludeIndexing ? unpackIndexedCoupon(coupon) : coupon)->nominal();
        Date initDate = coupon->accrualStartDate();
        initDate = paymentCalendar.advance(initDate, notionalPaymentLag, Days, paymentConvention);
        if (initFlowAmt != 0)
            leg.push_back(QuantLib::ext::shared_ptr<CashFlow>(new SimpleCashFlow(-initFlowAmt, initDate)));
    }
 
    // Amortization Flows
    if (amortNomFlow) {
        for (Size i = 1; i < refLeg.size(); i++) {
            auto coupon = QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(refLeg[i]);
            QL_REQUIRE(coupon, "makeNotionalLeg does not support non-coupon legs");
            auto coupon2 = QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(refLeg[i - 1]);
            QL_REQUIRE(coupon, "makeNotionalLeg does not support non-coupon legs");
            Date flowDate = coupon->accrualStartDate();
            flowDate = paymentCalendar.advance(flowDate, notionalPaymentLag, Days, paymentConvention);
            Real initNom = (excludeIndexing ? unpackIndexedCoupon(coupon2) : coupon2)->nominal();
            Real newNom = (excludeIndexing ? unpackIndexedCoupon(coupon) : coupon)->nominal();
            Real flow = initNom - newNom;
            if (flow != 0)
                leg.push_back(QuantLib::ext::shared_ptr<CashFlow>(new SimpleCashFlow(flow, flowDate)));
        }
    }
 
    // Final Nominal Return at Maturity
    if (finalNomFlow) {
        auto coupon = QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(refLeg.back());
        QL_REQUIRE(coupon, "makeNotionalLeg does not support non-coupon legs");
        double finalNomFlow = (excludeIndexing ? unpackIndexedCoupon(coupon) : coupon)->nominal();
        Date finalDate = coupon->accrualEndDate();
        finalDate = paymentCalendar.advance(finalDate, notionalPaymentLag, Days, paymentConvention);
        if (finalNomFlow != 0)
            leg.push_back(QuantLib::ext::shared_ptr<CashFlow>(new SimpleCashFlow(finalNomFlow, finalDate)));
    }
 
    return leg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeCPILeg()

Leg makeCPILeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< ZeroInflationIndex > &	index,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 1616 of file legdata.cpp.

                                                                                                                      {
 
    QuantLib::ext::shared_ptr<CPILegData> cpiLegData = QuantLib::ext::dynamic_pointer_cast<CPILegData>(data.concreteLegData());
    QL_REQUIRE(cpiLegData, "Wrong LegType, expected CPI, got " << data.legType());
 
    Schedule schedule = makeSchedule(data.schedule(), openEndDateReplacement);
    DayCounter dc = parseDayCounter(data.dayCounter());
    Calendar paymentCalendar;
 
    if (data.paymentCalendar().empty())
        paymentCalendar = schedule.calendar();
    else
        paymentCalendar = parseCalendar(data.paymentCalendar());
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
 
    QuantLib::ext::shared_ptr<InflationSwapConvention> cpiSwapConvention = nullptr;
 
    auto inflationConventions = InstrumentConventions::instance().conventions()->get(
        cpiLegData->index() + "_INFLATIONSWAP", Convention::Type::InflationSwap);
 
    if (inflationConventions.first)
        cpiSwapConvention = QuantLib::ext::dynamic_pointer_cast<InflationSwapConvention>(inflationConventions.second);
 
    Period observationLag;
    if (cpiLegData->observationLag().empty()) {
        QL_REQUIRE(cpiSwapConvention,
                   "observationLag is not specified in legData and couldn't find convention for "
                       << cpiLegData->index() << ". Please add field to trade xml or add convention");
        DLOG("Build CPI Leg and use observation lag from standard inflationswap convention");
        observationLag = cpiSwapConvention->observationLag();
    } else {
        observationLag = parsePeriod(cpiLegData->observationLag());
    }
    
    CPI::InterpolationType interpolationMethod;
    if (cpiLegData->interpolation().empty()) {
        QL_REQUIRE(cpiSwapConvention,
                   "Interpolation is not specified in legData and couldn't find convention for "
                       << cpiLegData->index() << ". Please add field to trade xml or add convention");
        DLOG("Build CPI Leg and use observation lag from standard inflationswap convention");
        interpolationMethod = cpiSwapConvention->interpolated() ? CPI::Linear : CPI::Flat;
    } else {
        interpolationMethod = parseObservationInterpolation(cpiLegData->interpolation());
    }
 
    vector<double> rates = buildScheduledVector(cpiLegData->rates(), cpiLegData->rateDates(), schedule);
    vector<double> notionals = buildScheduledVector(data.notionals(), data.notionalDates(), schedule);
    bool couponCap = cpiLegData->caps().size() > 0;
    bool couponFloor = cpiLegData->floors().size() > 0;
    bool couponCapFloor = cpiLegData->caps().size() > 0 || cpiLegData->floors().size() > 0;
    bool finalFlowCapFloor = cpiLegData->finalFlowCap() != Null<Real>() || cpiLegData->finalFlowFloor() != Null<Real>();
 
    applyAmortization(notionals, data, schedule, false);
    PaymentLag paymentLag = parsePaymentLag(data.paymentLag());
 
    QuantExt::CPILeg cpiLeg =
        QuantExt::CPILeg(schedule, index,
                         engineFactory->market()->discountCurve(data.currency(),
                                                                engineFactory->configuration(MarketContext::pricing)),
                         cpiLegData->baseCPI(), observationLag)
            .withNotionals(notionals)
            .withPaymentDayCounter(dc)
            .withPaymentAdjustment(bdc)
            .withPaymentCalendar(paymentCalendar)
            .withPaymentLag(boost::apply_visitor(PaymentLagInteger(), paymentLag))
            .withFixedRates(rates)
            .withObservationInterpolation(interpolationMethod)
            .withSubtractInflationNominal(cpiLegData->subtractInflationNominal())
            .withSubtractInflationNominalAllCoupons(cpiLegData->subtractInflationNominalCoupons());
 
    // the cpi leg uses the first schedule date as the start date, which only makes sense if there are at least
    // two dates in the schedule, otherwise the only date in the schedule is the pay date of the cf and a separate
    // start date is expected; if both the separate start date and a schedule with more than one date is given
    const string& start = cpiLegData->startDate();
    if (schedule.size() < 2) {
        QL_REQUIRE(!start.empty(), "makeCPILeg(): only one schedule date, a 'StartDate' must be given.");
        cpiLeg.withStartDate(parseDate(start));
    } else if (!start.empty()) {
        DLOG("Schedule with more than 2 dates was provided. The first schedule date "
 
             << io::iso_date(schedule.dates().front()) << " is used as the start date. The 'StartDate' of " << start
             << " is not used.");
    }
    if (couponCap)
        cpiLeg.withCaps(buildScheduledVector(cpiLegData->caps(), cpiLegData->capDates(), schedule));
 
    if (couponFloor)
        cpiLeg.withFloors(buildScheduledVector(cpiLegData->floors(), cpiLegData->floorDates(), schedule));
 
    if (cpiLegData->finalFlowCap() != Null<Real>())
        cpiLeg.withFinalFlowCap(cpiLegData->finalFlowCap());
 
    if (cpiLegData->finalFlowFloor() != Null<Real>())
        cpiLeg.withFinalFlowFloor(cpiLegData->finalFlowFloor());
 
    Leg leg = cpiLeg.operator Leg();
    Size n = leg.size();
    QL_REQUIRE(n > 0, "Empty CPI Leg");
 
    if (couponCapFloor || finalFlowCapFloor) {
        
        string indexName = cpiLegData->index();
        
        // get a coupon pricer for the leg
        QuantLib::ext::shared_ptr<EngineBuilder> cpBuilder = engineFactory->builder("CappedFlooredCpiLegCoupons");
        QL_REQUIRE(cpBuilder, "No builder found for CappedFlooredCpiLegCoupons");
        QuantLib::ext::shared_ptr<CapFlooredCpiLegCouponEngineBuilder> cappedFlooredCpiCouponBuilder =
            QuantLib::ext::dynamic_pointer_cast<CapFlooredCpiLegCouponEngineBuilder>(cpBuilder);
        QuantLib::ext::shared_ptr<InflationCouponPricer> couponPricer = cappedFlooredCpiCouponBuilder->engine(indexName);
 
        // get a cash flow pricer for the leg
        QuantLib::ext::shared_ptr<EngineBuilder> cfBuilder = engineFactory->builder("CappedFlooredCpiLegCashFlows");
        QL_REQUIRE(cfBuilder, "No builder found for CappedFlooredCpiLegCashFLows");
        QuantLib::ext::shared_ptr<CapFlooredCpiLegCashFlowEngineBuilder> cappedFlooredCpiCashFlowBuilder =
            QuantLib::ext::dynamic_pointer_cast<CapFlooredCpiLegCashFlowEngineBuilder>(cfBuilder);
        QuantLib::ext::shared_ptr<InflationCashFlowPricer> cashFlowPricer = cappedFlooredCpiCashFlowBuilder->engine(indexName);
 
        // set coupon pricer for the leg
        for (Size i = 0; i < leg.size(); i++) {
            // nothing to do for the plain CPI Coupon, because the pricer is already set when the leg builder is called
            // nothing to do for the plain CPI CashFlow either, because it does not require a pricer
 
            QuantLib::ext::shared_ptr<CappedFlooredCPICoupon> cfCpiCoupon =
                QuantLib::ext::dynamic_pointer_cast<CappedFlooredCPICoupon>(leg[i]);
            if (cfCpiCoupon && couponCapFloor) {
                cfCpiCoupon->setPricer(couponPricer);
            }
 
            QuantLib::ext::shared_ptr<CappedFlooredCPICashFlow> cfCpiCashFlow =
                QuantLib::ext::dynamic_pointer_cast<CappedFlooredCPICashFlow>(leg[i]);
            if (cfCpiCashFlow && finalFlowCapFloor && i == (leg.size() - 1)) {
                cfCpiCashFlow->setPricer(cashFlowPricer);
            }
        }
    }
 
    // QuantLib CPILeg automatically adds a Notional Cashflow at maturity date on a CPI swap
    if (!data.notionalFinalExchange()) {
        leg.pop_back();
    }
 
    // build naked option leg if required and we have at least one cap/floor present in the coupon or the final flow
    if ((couponCapFloor || finalFlowCapFloor) && cpiLegData->nakedOption()) {
        leg = StrippedCappedFlooredCPICouponLeg(leg);
    }
 
    return leg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeYoYLeg()

Leg makeYoYLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< InflationIndex > &	index,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 1766 of file legdata.cpp.

                                                                                                                      {
    QuantLib::ext::shared_ptr<YoYLegData> yoyLegData = QuantLib::ext::dynamic_pointer_cast<YoYLegData>(data.concreteLegData());
    QL_REQUIRE(yoyLegData, "Wrong LegType, expected YoY, got " << data.legType());
 
    Schedule schedule = makeSchedule(data.schedule(), openEndDateReplacement);
    DayCounter dc = parseDayCounter(data.dayCounter());
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
    Calendar paymentCalendar;
 
    QuantLib::ext::shared_ptr<InflationSwapConvention> cpiSwapConvention = nullptr;
 
    auto inflationConventions = InstrumentConventions::instance().conventions()->get(
        yoyLegData->index() + "_INFLATIONSWAP", Convention::Type::InflationSwap);
 
    if (inflationConventions.first)
        cpiSwapConvention = QuantLib::ext::dynamic_pointer_cast<InflationSwapConvention>(inflationConventions.second);
 
    Period observationLag;
    if (yoyLegData->observationLag().empty()) {
        QL_REQUIRE(cpiSwapConvention,
                   "observationLag is not specified in legData and couldn't find convention for "
                       << yoyLegData->index() << ". Please add field to trade xml or add convention");
        DLOG("Build CPI Leg and use observation lag from standard inflationswap convention");
        observationLag = cpiSwapConvention->observationLag();
    } else {
        observationLag = parsePeriod(yoyLegData->observationLag());
    }
 
    if (data.paymentCalendar().empty())
        paymentCalendar = schedule.calendar();
    else
        paymentCalendar = parseCalendar(data.paymentCalendar());
 
    vector<double> gearings =
        buildScheduledVectorNormalised(yoyLegData->gearings(), yoyLegData->gearingDates(), schedule, 1.0);
    vector<double> spreads =
        buildScheduledVectorNormalised(yoyLegData->spreads(), yoyLegData->spreadDates(), schedule, 0.0);
    vector<double> notionals = buildScheduledVectorNormalised(data.notionals(), data.notionalDates(), schedule, 0.0);
 
    bool irregularYoY = yoyLegData->irregularYoY();
    bool couponCap = yoyLegData->caps().size() > 0;
    bool couponFloor = yoyLegData->floors().size() > 0;
    bool couponCapFloor = yoyLegData->caps().size() > 0 || yoyLegData->floors().size() > 0;
    bool addInflationNotional = yoyLegData->addInflationNotional();
 
    applyAmortization(notionals, data, schedule, false);
    Leg leg;
    if (!irregularYoY) {
        auto yoyIndex = QuantLib::ext::dynamic_pointer_cast<YoYInflationIndex>(index);
        QL_REQUIRE(yoyIndex, "Need a YoY Inflation Index");
        QuantExt::yoyInflationLeg yoyLeg =
            QuantExt::yoyInflationLeg(schedule, paymentCalendar, yoyIndex, observationLag)
                .withNotionals(notionals)
                .withPaymentDayCounter(dc)
                .withPaymentAdjustment(bdc)
                .withFixingDays(yoyLegData->fixingDays())
                .withGearings(gearings)
                .withSpreads(spreads)
                .withInflationNotional(addInflationNotional)
                .withRateCurve(engineFactory->market()->discountCurve(
                    data.currency(), engineFactory->configuration(MarketContext::pricing)));
 
        if (couponCap)
            yoyLeg.withCaps(buildScheduledVector(yoyLegData->caps(), yoyLegData->capDates(), schedule));
 
        if (couponFloor)
            yoyLeg.withFloors(buildScheduledVector(yoyLegData->floors(), yoyLegData->floorDates(), schedule));
 
        leg = yoyLeg.operator Leg();
 
        if (couponCapFloor) {
            // get a coupon pricer for the leg
            QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder("CapFlooredYYLeg");
            QL_REQUIRE(builder, "No builder found for CapFlooredYYLeg");
            QuantLib::ext::shared_ptr<CapFlooredYoYLegEngineBuilder> cappedFlooredYoYBuilder =
                QuantLib::ext::dynamic_pointer_cast<CapFlooredYoYLegEngineBuilder>(builder);
            string indexname = yoyLegData->index();
            QuantLib::ext::shared_ptr<InflationCouponPricer> couponPricer =
                cappedFlooredYoYBuilder->engine(IndexNameTranslator::instance().oreName(indexname));
 
            // set coupon pricer for the leg
 
            for (Size i = 0; i < leg.size(); i++) {
                QuantLib::ext::dynamic_pointer_cast<QuantExt::CappedFlooredYoYInflationCoupon>(leg[i])->setPricer(
                    QuantLib::ext::dynamic_pointer_cast<QuantLib::YoYInflationCouponPricer>(couponPricer));
            }
 
            // build naked option leg if required
            if (yoyLegData->nakedOption()) {
                leg = StrippedCappedFlooredYoYInflationCouponLeg(leg);
                for (auto const& t : leg) {
                    auto s = QuantLib::ext::dynamic_pointer_cast<StrippedCappedFlooredYoYInflationCoupon>(t);
                }
            }
        }
    } else {
        QuantLib::CPI::InterpolationType interpolation = QuantLib::CPI::Flat;
        if (cpiSwapConvention && cpiSwapConvention->interpolated()) {
            interpolation = QuantLib::CPI::Linear;
        }
        auto zcIndex = QuantLib::ext::dynamic_pointer_cast<ZeroInflationIndex>(index);
        QL_REQUIRE(zcIndex, "Need a Zero Coupon Inflation Index");
        QuantExt::NonStandardYoYInflationLeg yoyLeg =
            QuantExt::NonStandardYoYInflationLeg(schedule, schedule.calendar(), zcIndex, observationLag)
                .withNotionals(notionals)
                .withPaymentDayCounter(dc)
                .withPaymentAdjustment(bdc)
                .withFixingDays(yoyLegData->fixingDays())
                .withGearings(gearings)
                .withSpreads(spreads)
                .withRateCurve(engineFactory->market()->discountCurve(
                    data.currency(), engineFactory->configuration(MarketContext::pricing)))
                .withInflationNotional(addInflationNotional)
                .withObservationInterpolation(interpolation);
 
        if (couponCap)
            yoyLeg.withCaps(buildScheduledVector(yoyLegData->caps(), yoyLegData->capDates(), schedule));
 
        if (couponFloor)
            yoyLeg.withFloors(buildScheduledVector(yoyLegData->floors(), yoyLegData->floorDates(), schedule));
 
        leg = yoyLeg.operator Leg();
 
        if (couponCapFloor) {
            // get a coupon pricer for the leg
            QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder("CapFlooredNonStdYYLeg");
            QL_REQUIRE(builder, "No builder found for CapFlooredNonStdYYLeg");
            QuantLib::ext::shared_ptr<CapFlooredNonStandardYoYLegEngineBuilder> cappedFlooredYoYBuilder =
                QuantLib::ext::dynamic_pointer_cast<CapFlooredNonStandardYoYLegEngineBuilder>(builder);
            string indexname = zcIndex->name();
            QuantLib::ext::shared_ptr<InflationCouponPricer> couponPricer =
                cappedFlooredYoYBuilder->engine(IndexNameTranslator::instance().oreName(indexname));
 
            // set coupon pricer for the leg
 
            for (Size i = 0; i < leg.size(); i++) {
                QuantLib::ext::dynamic_pointer_cast<QuantExt::NonStandardCappedFlooredYoYInflationCoupon>(leg[i])->setPricer(
                    QuantLib::ext::dynamic_pointer_cast<QuantExt::NonStandardYoYInflationCouponPricer>(couponPricer));
            }
 
            // build naked option leg if required
            if (yoyLegData->nakedOption()) {
                leg = StrippedCappedFlooredYoYInflationCouponLeg(leg);
                for (auto const& t : leg) {
                    auto s = QuantLib::ext::dynamic_pointer_cast<StrippedCappedFlooredYoYInflationCoupon>(t);
                }
            }
        }
    }
    return leg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeCMSLeg()

Leg makeCMSLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< QuantLib::SwapIndex > &	swapIndex,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const bool	attachPricer,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 1919 of file legdata.cpp.

                                                           {
    QuantLib::ext::shared_ptr<CMSLegData> cmsData = QuantLib::ext::dynamic_pointer_cast<CMSLegData>(data.concreteLegData());
    QL_REQUIRE(cmsData, "Wrong LegType, expected CMS, got " << data.legType());
 
    Schedule schedule = makeSchedule(data.schedule(), openEndDateReplacement);
    DayCounter dc = parseDayCounter(data.dayCounter());
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
    Calendar paymentCalendar;
    PaymentLag paymentLag = parsePaymentLag(data.paymentLag());
 
    if (data.paymentCalendar().empty())
        paymentCalendar = schedule.calendar();
    else
        paymentCalendar = parseCalendar(data.paymentCalendar());
 
    vector<double> spreads =
        ore::data::buildScheduledVectorNormalised(cmsData->spreads(), cmsData->spreadDates(), schedule, 0.0);
    vector<double> gearings =
        ore::data::buildScheduledVectorNormalised(cmsData->gearings(), cmsData->gearingDates(), schedule, 1.0);
    vector<double> notionals = buildScheduledVectorNormalised(data.notionals(), data.notionalDates(), schedule, 0.0);
    Size fixingDays = cmsData->fixingDays() == Null<Size>() ? swapIndex->fixingDays() : cmsData->fixingDays();
 
    applyAmortization(notionals, data, schedule, false);
 
    CmsLeg cmsLeg = CmsLeg(schedule, swapIndex)
                        .withNotionals(notionals)
                        .withSpreads(spreads)
                        .withGearings(gearings)
                        .withPaymentCalendar(paymentCalendar)
                        .withPaymentDayCounter(dc)
                        .withPaymentAdjustment(bdc)
                        .withPaymentLag(boost::apply_visitor(PaymentLagInteger(), paymentLag))
                        .withFixingDays(fixingDays)
                        .inArrears(cmsData->isInArrears());
 
    if (cmsData->caps().size() > 0)
        cmsLeg.withCaps(buildScheduledVector(cmsData->caps(), cmsData->capDates(), schedule));
 
    if (cmsData->floors().size() > 0)
        cmsLeg.withFloors(buildScheduledVector(cmsData->floors(), cmsData->floorDates(), schedule));
 
    if (!attachPricer)
        return cmsLeg;
 
    // Get a coupon pricer for the leg
    QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder("CMS");
    QL_REQUIRE(builder, "No builder found for CmsLeg");
    QuantLib::ext::shared_ptr<CmsCouponPricerBuilder> cmsSwapBuilder =
        QuantLib::ext::dynamic_pointer_cast<CmsCouponPricerBuilder>(builder);
    QuantLib::ext::shared_ptr<FloatingRateCouponPricer> couponPricer =
        cmsSwapBuilder->engine(IndexNameTranslator::instance().oreName(swapIndex->iborIndex()->name()));
 
    // Loop over the coupons in the leg and set pricer
    Leg tmpLeg = cmsLeg;
    QuantLib::setCouponPricer(tmpLeg, couponPricer);
 
    // build naked option leg if required
    if (cmsData->nakedOption()) {
        tmpLeg = StrippedCappedFlooredCouponLeg(tmpLeg);
    }
    return tmpLeg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeCMBLeg()

Leg makeCMBLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const bool	attachPricer,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 1984 of file legdata.cpp.

                                                           {
    QuantLib::ext::shared_ptr<CMBLegData> cmbData = QuantLib::ext::dynamic_pointer_cast<CMBLegData>(data.concreteLegData());
    QL_REQUIRE(cmbData, "Wrong LegType, expected CMB, got " << data.legType());
 
    std::string bondIndexName = cmbData->genericBond();
    // Expected bondIndexName structure with at least two tokens, separated by "-", of the form FAMILY-TERM or
    // FAMILY-MUN, for example: US-CMT-5Y, US-TIPS-10Y, UK-GILT-5Y, DE-BUND-10Y
    std::vector<string> tokens;
    split(tokens, bondIndexName, boost::is_any_of("-"));
    QL_REQUIRE(tokens.size() >= 2,
               "Generic Bond Index with at least two tokens separated by - expected, found " << bondIndexName);
    std::string securityFamily = tokens[0];
    for (Size i = 1; i < tokens.size() - 1; ++i)
        securityFamily = securityFamily + "-" + tokens[i];
    string underlyingTerm = tokens.back();
    Period underlyingPeriod = parsePeriod(underlyingTerm);
    LOG("Generic bond id " << bondIndexName << " has family " << securityFamily << " and term " << underlyingPeriod);
 
    Schedule schedule = makeSchedule(data.schedule());
    Calendar calendar = schedule.calendar();
    int fixingDays = cmbData->fixingDays();
    BusinessDayConvention convention = schedule.businessDayConvention();
    bool creditRisk = cmbData->hasCreditRisk();
 
    // Get the generic bond reference data, notional 1, credit risk as specified in the leg data 
    BondData bondData(securityFamily, 1.0, creditRisk);
    bondData.populateFromBondReferenceData(engineFactory->referenceData());
    DLOG("Bond data for security id " << securityFamily << " loaded");
    QL_REQUIRE(bondData.coupons().size() == 1,
           "multiple reference bond legs not covered by the CMB leg");
    QL_REQUIRE(bondData.coupons().front().schedule().rules().size() == 1,
           "multiple bond schedule rules not covered by the CMB leg");
    QL_REQUIRE(bondData.coupons().front().schedule().dates().size() == 0,
           "dates based bond schedules not covered by the CMB leg");
 
    // Get bond yield conventions
    auto ret = InstrumentConventions::instance().conventions()->get(securityFamily, Convention::Type::BondYield);
    QuantLib::ext::shared_ptr<BondYieldConvention> conv;
    if (ret.first)
        conv = QuantLib::ext::dynamic_pointer_cast<BondYieldConvention>(ret.second);
    else {
    conv = QuantLib::ext::make_shared<BondYieldConvention>();
        ALOG("BondYield conventions not found for security " << securityFamily << ", falling back on defaults:"
         << " compounding=" << conv->compoundingName()
         << ", priceType=" << conv->priceTypeName()
         << ", accuracy=" << conv->accuracy() 
         << ", maxEvaluations=" << conv->maxEvaluations() 
         << ", guess=" << conv->guess());
    } 
 
    Schedule bondSchedule = makeSchedule(bondData.coupons().front().schedule());
    DayCounter bondDayCounter = parseDayCounter(bondData.coupons().front().dayCounter());
    Currency bondCurrency = parseCurrency(bondData.currency());
    Calendar bondCalendar = parseCalendar(bondData.calendar());
    Size bondSettlementDays = parseInteger(bondData.settlementDays());
    BusinessDayConvention bondConvention = bondSchedule.businessDayConvention();
    bool bondEndOfMonth = bondSchedule.endOfMonth();
    Frequency bondFrequency = bondSchedule.tenor().frequency();
    
    DayCounter dayCounter = parseDayCounter(data.dayCounter());
 
    // Create a ConstantMaturityBondIndex for each schedule start date
    DLOG("Create Constant Maturity Bond Indices for each period");
    std::vector<QuantLib::ext::shared_ptr<QuantExt::ConstantMaturityBondIndex>> bondIndices;
    for (Size i = 0; i < schedule.dates().size() - 1; ++i) {
        // Construct bond with start date = accrual start date and maturity = accrual start date + term
        // or start = accrual end if in arrears. Adjusted for fixing lag, ignoring bond settlement lags for now.
        Date refDate = cmbData->isInArrears() ? schedule[i+1] : schedule[i];
    Date start = calendar.advance(refDate, -fixingDays, Days, Preceding); 
    std::string startDate = to_string(start);
    std::string endDate = to_string(start + underlyingPeriod);
    bondData.populateFromBondReferenceData(engineFactory->referenceData(), startDate, endDate);
    Bond bondTrade(Envelope(), bondData);
    bondTrade.build(engineFactory);
    auto bond = QuantLib::ext::dynamic_pointer_cast<QuantLib::Bond>(bondTrade.instrument()->qlInstrument());
    QuantLib::ext::shared_ptr<QuantExt::ConstantMaturityBondIndex> bondIndex
        = QuantLib::ext::make_shared<QuantExt::ConstantMaturityBondIndex>(securityFamily, underlyingPeriod,
            // from bond reference data
        bondSettlementDays, bondCurrency, bondCalendar, bondDayCounter, bondConvention, bondEndOfMonth,
        // underlying forward starting bond
        bond,
        // yield calculation parameters from conventions, except frequency which is from bond reference data
        conv->compounding(), bondFrequency, conv->accuracy(), conv->maxEvaluations(), conv->guess(), conv->priceType());
    bondIndices.push_back(bondIndex);
    }
    
    // Create a sequence of floating rate coupons linked to those indexes and concatenate them to a leg
    DLOG("Create CMB leg");
    vector<double> spreads = buildScheduledVectorNormalised(cmbData->spreads(), cmbData->spreadDates(), schedule, 0.0);
    vector<double> gearings = buildScheduledVectorNormalised(cmbData->gearings(), cmbData->gearingDates(), schedule, 1.0);
    vector<double> notionals = buildScheduledVectorNormalised(data.notionals(), data.notionalDates(), schedule, 0.0);
 
    // FIXME: Move the following into CmbLeg in cmbcoupon.xpp
    QL_REQUIRE(bondIndices.size() == schedule.size() - 1,
           "vector size mismatch between schedule (" << schedule.size() << ") "
           << "and bond indices (" << bondIndices.size() << ")");
    Leg leg;
    for (Size i = 0; i < schedule.size() - 1; i++) {
        Date paymentDate = calendar.adjust(schedule[i + 1], convention);
    DLOG("Coupon " << i << ": "
         << io::iso_date(paymentDate) << " "
         << notionals[i] << " "
         << io::iso_date(schedule[i]) << " "
         << io::iso_date(schedule[i+1]) << " "
         << cmbData->fixingDays() << " "
         << gearings[i] << " "
         << spreads[i] << " "
         << dayCounter.name());
    QuantLib::ext::shared_ptr<CmbCoupon> coupon
        = QuantLib::ext::make_shared<CmbCoupon>(paymentDate, notionals[i], schedule[i], schedule[i + 1],
                        cmbData->fixingDays(), bondIndices[i], gearings[i], spreads[i], Date(), Date(),
                        dayCounter, cmbData->isInArrears());    
    auto pricer = QuantLib::ext::make_shared<CmbCouponPricer>();
    coupon->setPricer(pricer);
    leg.push_back(coupon);
    }
 
    return leg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeDigitalCMSLeg()

Leg makeDigitalCMSLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< QuantLib::SwapIndex > &	swapIndex,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const bool	attachPricer,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 2105 of file legdata.cpp.

                                                                  {
    auto digitalCmsData = QuantLib::ext::dynamic_pointer_cast<DigitalCMSLegData>(data.concreteLegData());
    QL_REQUIRE(digitalCmsData, "Wrong LegType, expected DigitalCMS");
 
    auto cmsData = QuantLib::ext::dynamic_pointer_cast<CMSLegData>(digitalCmsData->underlying());
    QL_REQUIRE(cmsData, "Incomplete DigitalCms Leg, expected CMS data");
 
    Schedule schedule = makeSchedule(data.schedule(), openEndDateReplacement);
 
    DayCounter dc = parseDayCounter(data.dayCounter());
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
    vector<double> spreads =
        ore::data::buildScheduledVectorNormalised(cmsData->spreads(), cmsData->spreadDates(), schedule, 0.0);
    vector<double> gearings =
        ore::data::buildScheduledVectorNormalised(cmsData->gearings(), cmsData->gearingDates(), schedule, 1.0);
    vector<double> notionals = buildScheduledVectorNormalised(data.notionals(), data.notionalDates(), schedule, 0.0);
 
    double eps = 1e-4;
    vector<double> callStrikes =
        ore::data::buildScheduledVector(digitalCmsData->callStrikes(), digitalCmsData->callStrikeDates(), schedule);
 
    for (Size i = 0; i < callStrikes.size(); i++) {
        if (std::fabs(callStrikes[i]) < eps / 2) {
            callStrikes[i] = eps / 2;
        }
    }
 
    vector<double> callPayoffs =
        ore::data::buildScheduledVector(digitalCmsData->callPayoffs(), digitalCmsData->callPayoffDates(), schedule);
 
    vector<double> putStrikes =
        ore::data::buildScheduledVector(digitalCmsData->putStrikes(), digitalCmsData->putStrikeDates(), schedule);
    vector<double> putPayoffs =
        ore::data::buildScheduledVector(digitalCmsData->putPayoffs(), digitalCmsData->putPayoffDates(), schedule);
 
    Size fixingDays = cmsData->fixingDays() == Null<Size>() ? swapIndex->fixingDays() : cmsData->fixingDays();
 
    applyAmortization(notionals, data, schedule, false);
 
    DigitalCmsLeg digitalCmsLeg = DigitalCmsLeg(schedule, swapIndex)
                                      .withNotionals(notionals)
                                      .withSpreads(spreads)
                                      .withGearings(gearings)
                                      // .withPaymentCalendar(paymentCalendar)
                                      .withPaymentDayCounter(dc)
                                      .withPaymentAdjustment(bdc)
                                      .withFixingDays(fixingDays)
                                      .inArrears(cmsData->isInArrears())
                                      .withCallStrikes(callStrikes)
                                      .withLongCallOption(digitalCmsData->callPosition())
                                      .withCallATM(digitalCmsData->isCallATMIncluded())
                                      .withCallPayoffs(callPayoffs)
                                      .withPutStrikes(putStrikes)
                                      .withLongPutOption(digitalCmsData->putPosition())
                                      .withPutATM(digitalCmsData->isPutATMIncluded())
                                      .withPutPayoffs(putPayoffs)
                                      .withReplication(QuantLib::ext::make_shared<DigitalReplication>())
                                      .withNakedOption(cmsData->nakedOption());
 
    if (cmsData->caps().size() > 0 || cmsData->floors().size() > 0)
        QL_FAIL("caps/floors not supported in DigitalCMSOptions");
 
    if (!attachPricer)
        return digitalCmsLeg;
 
    // Get a coupon pricer for the leg
    QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder("CMS");
    QL_REQUIRE(builder, "No CMS builder found for CmsLeg");
    QuantLib::ext::shared_ptr<CmsCouponPricerBuilder> cmsBuilder = QuantLib::ext::dynamic_pointer_cast<CmsCouponPricerBuilder>(builder);
    auto cmsPricer = QuantLib::ext::dynamic_pointer_cast<CmsCouponPricer>(
        cmsBuilder->engine(IndexNameTranslator::instance().oreName(swapIndex->iborIndex()->name())));
    QL_REQUIRE(cmsPricer, "Expected CMS Pricer");
 
    // Loop over the coupons in the leg and set pricer
    Leg tmpLeg = digitalCmsLeg;
    QuantLib::setCouponPricer(tmpLeg, cmsPricer);
 
    return tmpLeg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeCMSSpreadLeg()

Leg makeCMSSpreadLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< QuantLib::SwapSpreadIndex > &	swapSpreadIndex,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const bool	attachPricer,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 2187 of file legdata.cpp.

                                                                 {
    QuantLib::ext::shared_ptr<CMSSpreadLegData> cmsSpreadData =
        QuantLib::ext::dynamic_pointer_cast<CMSSpreadLegData>(data.concreteLegData());
    QL_REQUIRE(cmsSpreadData, "Wrong LegType, expected CMSSpread, got " << data.legType());
 
    Schedule schedule = makeSchedule(data.schedule(), openEndDateReplacement);
    DayCounter dc = parseDayCounter(data.dayCounter());
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
    Calendar paymentCalendar;
    if (data.paymentCalendar().empty())
        paymentCalendar = schedule.calendar();
    else
        paymentCalendar = parseCalendar(data.paymentCalendar());
 
    PaymentLag paymentLag = parsePaymentLag(data.paymentLag());
 
    vector<double> spreads = ore::data::buildScheduledVectorNormalised(cmsSpreadData->spreads(),
                                                                       cmsSpreadData->spreadDates(), schedule, 0.0);
    vector<double> gearings = ore::data::buildScheduledVectorNormalised(cmsSpreadData->gearings(),
                                                                        cmsSpreadData->gearingDates(), schedule, 1.0);
    vector<double> notionals = buildScheduledVectorNormalised(data.notionals(), data.notionalDates(), schedule, 0.0);
    Size fixingDays =
        cmsSpreadData->fixingDays() == Null<Size>() ? swapSpreadIndex->fixingDays() : cmsSpreadData->fixingDays();
 
    applyAmortization(notionals, data, schedule, false);
 
    CmsSpreadLeg cmsSpreadLeg = CmsSpreadLeg(schedule, swapSpreadIndex)
                                    .withNotionals(notionals)
                                    .withSpreads(spreads)
                                    .withGearings(gearings)
                                    .withPaymentCalendar(paymentCalendar)
                                    .withPaymentDayCounter(dc)
                                    .withPaymentAdjustment(bdc)
                                    .withPaymentLag(boost::apply_visitor(PaymentLagInteger(), paymentLag))
                                    .withFixingDays(fixingDays)
                                    .inArrears(cmsSpreadData->isInArrears());
 
    if (cmsSpreadData->caps().size() > 0)
        cmsSpreadLeg.withCaps(buildScheduledVector(cmsSpreadData->caps(), cmsSpreadData->capDates(), schedule));
 
    if (cmsSpreadData->floors().size() > 0)
        cmsSpreadLeg.withFloors(buildScheduledVector(cmsSpreadData->floors(), cmsSpreadData->floorDates(), schedule));
 
    if (!attachPricer)
        return cmsSpreadLeg;
 
    // Get a coupon pricer for the leg
    auto builder1 = engineFactory->builder("CMS");
    QL_REQUIRE(builder1, "No CMS builder found for CmsSpreadLeg");
    auto cmsBuilder = QuantLib::ext::dynamic_pointer_cast<CmsCouponPricerBuilder>(builder1);
    auto cmsPricer = QuantLib::ext::dynamic_pointer_cast<CmsCouponPricer>(cmsBuilder->engine(
        IndexNameTranslator::instance().oreName(swapSpreadIndex->swapIndex1()->iborIndex()->name())));
    QL_REQUIRE(cmsPricer, "Expected CMS Pricer");
    auto builder2 = engineFactory->builder("CMSSpread");
    QL_REQUIRE(builder2, "No CMS Spread builder found for CmsSpreadLeg");
    auto cmsSpreadBuilder = QuantLib::ext::dynamic_pointer_cast<CmsSpreadCouponPricerBuilder>(builder2);
    auto cmsSpreadPricer = cmsSpreadBuilder->engine(swapSpreadIndex->currency(), cmsSpreadData->swapIndex1(),
                                                    cmsSpreadData->swapIndex2(), cmsPricer);
    QL_REQUIRE(cmsSpreadPricer, "Expected CMS Spread Pricer");
 
    // Loop over the coupons in the leg and set pricer
    Leg tmpLeg = cmsSpreadLeg;
    QuantLib::setCouponPricer(tmpLeg, cmsSpreadPricer);
 
    // build naked option leg if required
    if (cmsSpreadData->nakedOption()) {
        tmpLeg = StrippedCappedFlooredCouponLeg(tmpLeg);
    }
    return tmpLeg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeDigitalCMSSpreadLeg()

Leg makeDigitalCMSSpreadLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< QuantLib::SwapSpreadIndex > &	swapSpreadIndex,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 2260 of file legdata.cpp.

                                                                        {
    auto digitalCmsSpreadData = QuantLib::ext::dynamic_pointer_cast<DigitalCMSSpreadLegData>(data.concreteLegData());
    QL_REQUIRE(digitalCmsSpreadData, "Wrong LegType, expected DigitalCMSSpread");
 
    auto cmsSpreadData = QuantLib::ext::dynamic_pointer_cast<CMSSpreadLegData>(digitalCmsSpreadData->underlying());
    QL_REQUIRE(cmsSpreadData, "Incomplete DigitalCmsSpread Leg, expected CMSSpread data");
 
    Schedule schedule = makeSchedule(data.schedule(), openEndDateReplacement);
    DayCounter dc = parseDayCounter(data.dayCounter());
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
 
    Calendar paymentCalendar;
    if (data.paymentCalendar().empty())
        paymentCalendar = schedule.calendar();
    else
        paymentCalendar = parseCalendar(data.paymentCalendar());
 
    vector<double> spreads = ore::data::buildScheduledVectorNormalised(cmsSpreadData->spreads(),
                                                                       cmsSpreadData->spreadDates(), schedule, 0.0);
    vector<double> gearings = ore::data::buildScheduledVectorNormalised(cmsSpreadData->gearings(),
                                                                        cmsSpreadData->gearingDates(), schedule, 1.0);
    vector<double> notionals = buildScheduledVectorNormalised(data.notionals(), data.notionalDates(), schedule, 0.0);
 
    double eps = 1e-4;
    vector<double> callStrikes = ore::data::buildScheduledVector(digitalCmsSpreadData->callStrikes(),
                                                                 digitalCmsSpreadData->callStrikeDates(), schedule);
 
    for (Size i = 0; i < callStrikes.size(); i++) {
        if (std::fabs(callStrikes[i]) < eps / 2) {
            callStrikes[i] = eps / 2;
        }
    }
 
    vector<double> callPayoffs = ore::data::buildScheduledVector(digitalCmsSpreadData->callPayoffs(),
                                                                 digitalCmsSpreadData->callPayoffDates(), schedule);
 
    vector<double> putStrikes = ore::data::buildScheduledVector(digitalCmsSpreadData->putStrikes(),
                                                                digitalCmsSpreadData->putStrikeDates(), schedule);
    vector<double> putPayoffs = ore::data::buildScheduledVector(digitalCmsSpreadData->putPayoffs(),
                                                                digitalCmsSpreadData->putPayoffDates(), schedule);
 
    Size fixingDays =
        cmsSpreadData->fixingDays() == Null<Size>() ? swapSpreadIndex->fixingDays() : cmsSpreadData->fixingDays();
 
    applyAmortization(notionals, data, schedule, false);
 
    DigitalCmsSpreadLeg digitalCmsSpreadLeg = DigitalCmsSpreadLeg(schedule, swapSpreadIndex)
                                                  .withNotionals(notionals)
                                                  .withSpreads(spreads)
                                                  .withGearings(gearings)
                                                  .withPaymentDayCounter(dc)
                                                  .withPaymentCalendar(paymentCalendar)
                                                  .withPaymentAdjustment(bdc)
                                                  .withFixingDays(fixingDays)
                                                  .inArrears(cmsSpreadData->isInArrears())
                                                  .withCallStrikes(callStrikes)
                                                  .withLongCallOption(digitalCmsSpreadData->callPosition())
                                                  .withCallATM(digitalCmsSpreadData->isCallATMIncluded())
                                                  .withCallPayoffs(callPayoffs)
                                                  .withPutStrikes(putStrikes)
                                                  .withLongPutOption(digitalCmsSpreadData->putPosition())
                                                  .withPutATM(digitalCmsSpreadData->isPutATMIncluded())
                                                  .withPutPayoffs(putPayoffs)
                                                  .withReplication(QuantLib::ext::make_shared<DigitalReplication>())
                                                  .withNakedOption(cmsSpreadData->nakedOption());
 
    if (cmsSpreadData->caps().size() > 0 || cmsSpreadData->floors().size() > 0)
        QL_FAIL("caps/floors not supported in DigitalCMSSpreadOptions");
 
    // Get a coupon pricer for the leg
    auto builder1 = engineFactory->builder("CMS");
    QL_REQUIRE(builder1, "No CMS builder found for CmsSpreadLeg");
    auto cmsBuilder = QuantLib::ext::dynamic_pointer_cast<CmsCouponPricerBuilder>(builder1);
    auto cmsPricer = QuantLib::ext::dynamic_pointer_cast<CmsCouponPricer>(cmsBuilder->engine(
        IndexNameTranslator::instance().oreName(swapSpreadIndex->swapIndex1()->iborIndex()->name())));
    QL_REQUIRE(cmsPricer, "Expected CMS Pricer");
    auto builder2 = engineFactory->builder("CMSSpread");
    QL_REQUIRE(builder2, "No CMS Spread builder found for CmsSpreadLeg");
    auto cmsSpreadBuilder = QuantLib::ext::dynamic_pointer_cast<CmsSpreadCouponPricerBuilder>(builder2);
    auto cmsSpreadPricer = cmsSpreadBuilder->engine(swapSpreadIndex->currency(), cmsSpreadData->swapIndex1(),
                                                    cmsSpreadData->swapIndex2(), cmsPricer);
    QL_REQUIRE(cmsSpreadPricer, "Expected CMS Spread Pricer");
 
    // Loop over the coupons in the leg and set pricer
    Leg tmpLeg = digitalCmsSpreadLeg;
    QuantLib::setCouponPricer(tmpLeg, cmsSpreadPricer);
 
    return tmpLeg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeEquityLeg() [1/2]

Leg makeEquityLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< EquityIndex2 > &	equityCurve,
		const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &	fxIndex,
		const QuantLib::Date &	openEndDateReplacement
	)

Definition at line 2352 of file legdata.cpp.

                                                                                                                     {
    QuantLib::ext::shared_ptr<EquityLegData> eqLegData = QuantLib::ext::dynamic_pointer_cast<EquityLegData>(data.concreteLegData());
    QL_REQUIRE(eqLegData, "Wrong LegType, expected Equity, got " << data.legType());
 
    DayCounter dc;
    if (data.dayCounter().empty())
        dc = Actual365Fixed();
    else
        dc = parseDayCounter(data.dayCounter());
    BusinessDayConvention bdc = parseBusinessDayConvention(data.paymentConvention());
 
    Real dividendFactor = eqLegData->dividendFactor();
    Real initialPrice = eqLegData->initialPrice();
    bool initialPriceIsInTargetCcy = false;
 
    if (!eqLegData->initialPriceCurrency().empty()) {
        // parse currencies to handle minor currencies
        Currency initialPriceCurrency = parseCurrencyWithMinors(eqLegData->initialPriceCurrency());
        Currency dataCurrency = parseCurrencyWithMinors(data.currency());
        Currency eqCurrency;
        // set equity currency
        if (!eqLegData->eqCurrency().empty())
            eqCurrency = parseCurrencyWithMinors(eqLegData->eqCurrency());
        else if (!equityCurve->currency().empty())
            eqCurrency = equityCurve->currency();
        else
            TLOG("Cannot find currency for equity " << equityCurve->name());
 
        // initial price currency must match leg or equity currency
        QL_REQUIRE(initialPriceCurrency == dataCurrency || initialPriceCurrency == eqCurrency || eqCurrency.empty(),
                   "initial price ccy (" << initialPriceCurrency << ") must match either leg ccy (" << dataCurrency
                                         << ") or equity ccy (if given, got '" << eqCurrency << "')");
        initialPriceIsInTargetCcy = initialPriceCurrency == dataCurrency;
        // adjust for minor currency
        initialPrice = convertMinorToMajorCurrency(eqLegData->initialPriceCurrency(), initialPrice);
    }
    bool notionalReset = eqLegData->notionalReset();
    Natural fixingDays = eqLegData->fixingDays();
    PaymentLag paymentLag = parsePaymentLag(data.paymentLag());
 
    ScheduleBuilder scheduleBuilder;
 
    ScheduleData scheduleData = data.schedule();
    Schedule schedule;
    scheduleBuilder.add(schedule, scheduleData);
 
    ScheduleData valuationData = eqLegData->valuationSchedule();
    Schedule valuationSchedule;
    if (valuationData.hasData())
        scheduleBuilder.add(valuationSchedule, valuationData);
 
    scheduleBuilder.makeSchedules(openEndDateReplacement);
 
    vector<double> notionals = buildScheduledVector(data.notionals(), data.notionalDates(), schedule);
 
    Calendar paymentCalendar;
    if (data.paymentCalendar().empty())
        paymentCalendar = schedule.calendar();
    else
        paymentCalendar = parseCalendar(data.paymentCalendar());
 
    applyAmortization(notionals, data, schedule, false);
    Leg leg = EquityLeg(schedule, equityCurve, fxIndex)
                  .withNotionals(notionals)
                  .withQuantity(eqLegData->quantity())
                  .withPaymentDayCounter(dc)
                  .withPaymentAdjustment(bdc)
                  .withPaymentCalendar(paymentCalendar)
                  .withPaymentLag(boost::apply_visitor(PaymentLagInteger(), paymentLag))
                  .withReturnType(eqLegData->returnType())
                  .withDividendFactor(dividendFactor)
                  .withInitialPrice(initialPrice)
                  .withInitialPriceIsInTargetCcy(initialPriceIsInTargetCcy)
                  .withNotionalReset(notionalReset)
                  .withFixingDays(fixingDays)
                  .withValuationSchedule(valuationSchedule);
 
    QL_REQUIRE(leg.size() > 0, "Empty Equity Leg");
 
    return leg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ currentNotional()

Real currentNotional ( const Leg & leg )

Definition at line 2435 of file legdata.cpp.

                                     {
    Date today = Settings::instance().evaluationDate();
    // assume the leg is sorted
    // We just take the first coupon::nominal we find, otherwise return 0
    for (auto cf : leg) {
        if (cf->date() > today) {
            QuantLib::ext::shared_ptr<Coupon> coupon = QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(cf);
            if (coupon)
                return coupon->nominal();
        }
    }
    return 0;
}

Here is the caller graph for this function:

◆ originalNotional()

Real originalNotional ( const Leg & leg )

Definition at line 2449 of file legdata.cpp.

                                      {
    // assume the leg is sorted
    // We just take the first coupon::nominal we find, otherwise return 0
    if (leg.size() > 0) {
        QuantLib::ext::shared_ptr<Coupon> coupon = QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(leg.front());
        if (coupon)
            return coupon->nominal();
    }
    return 0;
}

Here is the caller graph for this function:

◆ buildAmortizationScheduleFixedAmount()

vector< double > buildAmortizationScheduleFixedAmount	(	const vector< double > &	notionals,
		const Schedule &	schedule,
		const AmortizationData &	data
	)

Definition at line 2460 of file legdata.cpp.

                                                                                  {
    DLOG("Build fixed amortization notional schedule");
    vector<double> nominals = normaliseToSchedule(notionals, schedule, (Real)Null<Real>());
    Date startDate = data.startDate().empty() ? Date::minDate() : parseDate(data.startDate());
    Date endDate = data.endDate().empty() ? Date::maxDate() : parseDate(data.endDate());
    bool underflow = data.underflow();
    Period amortPeriod = data.frequency().empty() ? 0 * Days : parsePeriod(data.frequency());
    double amort = data.value();
    Date lastAmortDate = Date::minDate();
    for (Size i = 0; i < schedule.size() - 1; i++) {
        if (i > 0 && (lastAmortDate == Date::minDate() || schedule[i] > lastAmortDate + amortPeriod - 4 * Days) &&
            schedule[i] >= startDate && schedule[i] < endDate) { // FIXME: tolerance
            nominals[i] = nominals[i - 1] - amort;
            lastAmortDate = schedule[i];
        } else if (i > 0 && lastAmortDate > Date::minDate()) {
            nominals[i] = nominals[i - 1];
        }
        if (amort > nominals[i] && underflow == false)
            amort = std::max(nominals[i], 0.0);
    }
    DLOG("Fixed amortization notional schedule done");
    return nominals;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildAmortizationScheduleRelativeToInitialNotional()

vector< double > buildAmortizationScheduleRelativeToInitialNotional	(	const vector< double > &	notionals,
		const Schedule &	schedule,
		const AmortizationData &	data
	)

Definition at line 2485 of file legdata.cpp.

                                                                                                {
    DLOG("Build notional schedule with amortizations expressed as percentages of initial notional");
    vector<double> nominals = normaliseToSchedule(notionals, schedule, (Real)Null<Real>());
    Date startDate = data.startDate().empty() ? Date::minDate() : parseDate(data.startDate());
    Date endDate = data.endDate().empty() ? Date::maxDate() : parseDate(data.endDate());
    bool underflow = data.underflow();
    Period amortPeriod = data.frequency().empty() ? 0 * Days : parsePeriod(data.frequency());
    double amort = data.value() * nominals.front();
    Date lastAmortDate = Date::minDate();
    for (Size i = 0; i < schedule.size() - 1; i++) {
        if (i > 0 && (lastAmortDate == Date::minDate() || schedule[i] > lastAmortDate + amortPeriod - 4 * Days) &&
            schedule[i] >= startDate && schedule[i] < endDate) { // FIXME: tolerance
            nominals[i] = nominals[i - 1] - amort;
            lastAmortDate = schedule[i];
        } else if (i > 0 && lastAmortDate > Date::minDate())
            nominals[i] = nominals[i - 1];
        if (amort > nominals[i] && underflow == false) {
            amort = std::max(nominals[i], 0.0);
        }
    }
    DLOG("Fixed amortization notional schedule done");
    return nominals;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildAmortizationScheduleRelativeToPreviousNotional()

vector< double > buildAmortizationScheduleRelativeToPreviousNotional	(	const vector< double > &	notionals,
		const Schedule &	schedule,
		const AmortizationData &	data
	)

Definition at line 2511 of file legdata.cpp.

                                                                                                 {
    DLOG("Build notional schedule with amortizations expressed as percentages of previous notionals");
    vector<double> nominals = normaliseToSchedule(notionals, schedule, (Real)Null<Real>());
    Date startDate = data.startDate().empty() ? Date::minDate() : parseDate(data.startDate());
    Date endDate = data.endDate().empty() ? Date::maxDate() : parseDate(data.endDate());
    Period amortPeriod = data.frequency().empty() ? 0 * Days : parsePeriod(data.frequency());
    double fraction = data.value();
    QL_REQUIRE(fraction < 1.0 || close_enough(fraction, 1.0),
               "amortization fraction " << fraction << " expected to be <= 1");
    Date lastAmortDate = Date::minDate();
    for (Size i = 0; i < schedule.size() - 1; i++) {
        if (i > 0 && (lastAmortDate == Date::minDate() || schedule[i] > lastAmortDate + amortPeriod - 4 * Days) &&
            schedule[i] >= startDate && schedule[i] < endDate) { // FIXME: tolerance
            nominals[i] = nominals[i - 1] * (1.0 - fraction);
            lastAmortDate = schedule[i];
        } else if (i > 0 && lastAmortDate > Date::minDate())
            nominals[i] = nominals[i - 1];
    }
    DLOG("Fixed amortization notional schedule done");
    return nominals;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildAmortizationScheduleFixedAnnuity()

vector< double > buildAmortizationScheduleFixedAnnuity	(	const vector< double > &	notionals,
		const vector< double > &	rates,
		const Schedule &	schedule,
		const AmortizationData &	data,
		const DayCounter &	dc
	)

Definition at line 2535 of file legdata.cpp.

                                                                           {
    DLOG("Build fixed annuity notional schedule");
    vector<double> nominals = normaliseToSchedule(notionals, schedule, (Real)Null<Real>());
    Date startDate = data.startDate().empty() ? Date::minDate() : parseDate(data.startDate());
    Date endDate = data.endDate().empty() ? Date::maxDate() : parseDate(data.endDate());
    bool underflow = data.underflow();
    double annuity = data.value();
    Real amort = 0.0;
    Date lastAmortDate = Date::minDate();
    for (Size i = 0; i < schedule.size() - 1; i++) {
        if (i > 0 && schedule[i] >= startDate && schedule[i] < endDate) {
            nominals[i] = nominals[i - 1] - amort;
            lastAmortDate = schedule[i];
        } else if (i > 0 && lastAmortDate > Date::minDate())
            nominals[i] = nominals[i - 1];
        Real dcf = dc.yearFraction(schedule[i], schedule[i + 1]);
        Real rate = i < rates.size() ? rates[i] : rates.back();
        amort = annuity - rate * nominals[i] * dcf;
        if (amort > nominals[i] && underflow == false) {
            amort = std::max(nominals[i], 0.0);
        }
    }
    DLOG("Fixed Annuity notional schedule done");
    return nominals;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildAmortizationScheduleLinearToMaturity()

vector< double > buildAmortizationScheduleLinearToMaturity	(	const vector< double > &	notionals,
		const Schedule &	schedule,
		const AmortizationData &	data
	)

Definition at line 2563 of file legdata.cpp.

                                                                                       {
    DLOG("Build linear-to-maturity notional schedule");
    vector<double> nominals = normaliseToSchedule(notionals, schedule, (Real)Null<Real>());
    Date startDate = data.startDate().empty() ? Date::minDate() : parseDate(data.startDate());
    Date endDate = data.endDate().empty() ? Date::maxDate() : parseDate(data.endDate());
    Period amortPeriod = data.frequency().empty() ? 0 * Days : parsePeriod(data.frequency());
    Date lastAmortDate = Date::minDate();
    Real periodAmortization = Null<Real>();
    Real accumulatedAmortization = 0.0;
    for (Size i = 0; i < schedule.size() - 1; ++i) {
        if (schedule[i] >= startDate && periodAmortization == Null<Real>()) {
            periodAmortization = nominals[i] / static_cast<Real>(schedule.size() - i);
        }
        if (i > 0 && schedule[i] >= startDate && schedule[i] < endDate) {
            accumulatedAmortization += periodAmortization;
        }
        if (i > 0 && (lastAmortDate == Date::minDate() || schedule[i] > lastAmortDate + amortPeriod - 4 * Days) &&
            schedule[i] >= startDate && schedule[i] < endDate) {
            nominals[i] = nominals[i - 1] - accumulatedAmortization;
            accumulatedAmortization = 0.0;
            lastAmortDate = schedule[i];
        } else if (i > 0 && lastAmortDate > Date::minDate()) {
            nominals[i] = nominals[i - 1];
        }
    }
    DLOG("Linear-to-maturity notional schedule done");
    return nominals;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyAmortization()

void applyAmortization	(	std::vector< Real > &	notionals,
		const LegData &	data,
		const Schedule &	schedule,
		const bool	annuityAllowed,
		const std::vector< Real > &	rates
	)

Definition at line 2593 of file legdata.cpp.

                                                                                {
    Date lastEndDate = Date::minDate();
    for (Size i = 0; i < data.amortizationData().size(); ++i) {
        const AmortizationData& amort = data.amortizationData()[i];
        if (!amort.initialized())
            continue;
        QL_REQUIRE(i == 0 || !amort.startDate().empty(),
                   "All AmortizationData blocks except the first require a StartDate");
        Date startDate = amort.startDate().empty() ? Date::minDate() : parseDate(amort.startDate());
        QL_REQUIRE(startDate >= lastEndDate, "Amortization start date ("
                                                 << startDate << ") is earlier than last end date (" << lastEndDate
                                                 << ")");
        lastEndDate = amort.endDate().empty() ? Date::minDate() : parseDate(amort.endDate());
        AmortizationType amortizationType = parseAmortizationType(amort.type());
        if (amortizationType == AmortizationType::FixedAmount)
            notionals = buildAmortizationScheduleFixedAmount(notionals, schedule, amort);
        else if (amortizationType == AmortizationType::RelativeToInitialNotional)
            notionals = buildAmortizationScheduleRelativeToInitialNotional(notionals, schedule, amort);
        else if (amortizationType == AmortizationType::RelativeToPreviousNotional)
            notionals = buildAmortizationScheduleRelativeToPreviousNotional(notionals, schedule, amort);
        else if (amortizationType == AmortizationType::Annuity) {
            QL_REQUIRE(annuityAllowed, "Amortization type Annuity not allowed for leg type " << data.legType());
            if (!rates.empty())
                notionals = buildAmortizationScheduleFixedAnnuity(notionals, rates, schedule, amort,
                                                                  parseDayCounter(data.dayCounter()));
        } else if (amortizationType == AmortizationType::LinearToMaturity) {
            notionals = buildAmortizationScheduleLinearToMaturity(notionals, schedule, amort);
        } else {
            QL_FAIL("AmortizationType " << amort.type() << " not supported");
        }
        // check that for a floating leg we only have one amortization block, if the type is annuity
        // we recognise a floating leg by an empty (fixed) rates vector
        if (rates.empty() && amortizationType == AmortizationType::Annuity) {
            QL_REQUIRE(data.amortizationData().size() == 1,
                       "Floating Leg supports only one amortisation block of type Annuity");
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyIndexing()

void applyIndexing	(	Leg &	leg,
		const LegData &	data,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		RequiredFixings &	requiredFixings,
		const QuantLib::Date &	openEndDateReplacement,
		const bool	useXbsCurves
	)

Definition at line 2633 of file legdata.cpp.

                                            {
    for (auto const& indexing : data.indexing()) {
        if (indexing.hasData()) {
            DLOG("apply indexing (index='" << indexing.index() << "') to leg of type " << data.legType());
            QL_REQUIRE(engineFactory, "applyIndexing: engineFactory required");
 
            // we allow indexing by equity, commodity and FX indices (technically any QuantLib::Index
            // will work, so the list of index types can be extended here if required)
            QuantLib::ext::shared_ptr<Index> index;
            string config = engineFactory->configuration(MarketContext::pricing);
            if (boost::starts_with(indexing.index(), "EQ-")) {
                string eqName = indexing.index().substr(3);
                index = *engineFactory->market()->equityCurve(eqName, config);
            } else if (boost::starts_with(indexing.index(), "FX-")) {
                auto tmp = parseFxIndex(indexing.index());
                Currency ccy1 = tmp->targetCurrency();
                Currency ccy2 = tmp->sourceCurrency();
                QL_REQUIRE(ccy1.code() == data.currency() || ccy2.code() == data.currency(),
                           "applyIndexing: fx index '" << indexing.index() << "' ccys do not match leg ccy ("
                                                       << data.currency() << ")");
                std::string domestic = data.currency();
                std::string foreign = ccy1.code() == domestic ? ccy2.code() : ccy1.code();
                index = buildFxIndex(indexing.index(), domestic, foreign, engineFactory->market(),
                                     engineFactory->configuration(MarketContext::pricing), useXbsCurves);
 
            } else if (boost::starts_with(indexing.index(), "COMM-")) {
                auto tmp = parseCommodityIndex(indexing.index());
                index = parseCommodityIndex(indexing.index(), true,
                                            engineFactory->market()->commodityPriceCurve(tmp->underlyingName(), config),
                                            tmp->fixingCalendar());
            } else if (boost::starts_with(indexing.index(), "BOND-")) {
                // if we build a bond index, we add the required fixings for the bond underlying
                QuantLib::ext::shared_ptr<BondIndex> bi = parseBondIndex(indexing.index());
                QL_REQUIRE(!(QuantLib::ext::dynamic_pointer_cast<BondFuturesIndex>(bi)),
                           "BondFuture Legs are not yet supported");
                BondData bondData(bi->securityName(), 1.0);
                BondIndexBuilder bondIndexBuilder(bondData, indexing.indexIsDirty(), indexing.indexIsRelative(),
                                       parseCalendar(indexing.fixingCalendar()),
                                       indexing.indexIsConditionalOnSurvival(), engineFactory);
                index = bondIndexBuilder.bondIndex();
                bondIndexBuilder.addRequiredFixings(requiredFixings, leg);
            } else {
                QL_FAIL("invalid index '" << indexing.index()
                                          << "' in indexing data, expected EQ-, FX-, COMM-, BOND- index");
            }
 
            QL_REQUIRE(index, "applyIndexing(): index is null, this is unexpected");
 
            // apply the indexing
            IndexedCouponLeg indLeg(leg, indexing.quantity(), index);
            indLeg.withInitialFixing(indexing.initialFixing());
            // we set the initial notional fixing only if we have an initial exchange, otherwise this is applied to the
            // first notional payment appearing in the leg
            if (data.notionalInitialExchange())
                indLeg.withInitialNotionalFixing(indexing.initialNotionalFixing());
            indLeg.withFixingDays(indexing.fixingDays());
            indLeg.inArrearsFixing(indexing.inArrearsFixing());
            if (indexing.valuationSchedule().hasData())
                indLeg.withValuationSchedule(makeSchedule(indexing.valuationSchedule(), openEndDateReplacement));
            if (!indexing.fixingCalendar().empty())
                indLeg.withFixingCalendar(parseCalendar(indexing.fixingCalendar()));
            if (!indexing.fixingConvention().empty())
                indLeg.withFixingConvention(parseBusinessDayConvention(indexing.fixingConvention()));
            leg = indLeg;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ joinLegs()

Leg joinLegs ( const std::vector< Leg > & legs )

Definition at line 2703 of file legdata.cpp.

                                         {
    Leg masterLeg;
    Size lastLeg = Null<Size>();
    for (Size i = 0; i < legs.size(); ++i) {
        // skip empty legs
        if (legs[i].empty())
            continue;
        // check if the periods of adjacent legs are consistent
        if (lastLeg != Null<Size>()) {
            auto lcpn = QuantLib::ext::dynamic_pointer_cast<Coupon>(legs[lastLeg].back());
            auto fcpn = QuantLib::ext::dynamic_pointer_cast<Coupon>(legs[i].front());
            QL_REQUIRE(lcpn, "joinLegs: expected coupon as last cashflow in leg #" << lastLeg);
            QL_REQUIRE(fcpn, "joinLegs: expected coupon as first cashflow in leg #" << i);
            QL_REQUIRE(lcpn->accrualEndDate() == fcpn->accrualStartDate(),
                       "joinLegs: accrual end date of last coupon in leg #"
                           << lastLeg << " (" << lcpn->accrualEndDate()
                           << ") is not equal to accrual start date of first coupon in leg #" << i << " ("
                           << fcpn->accrualStartDate() << ")");
            lastLeg = i;
        }
        // copy legs together
        masterLeg.insert(masterLeg.end(), legs[i].begin(), legs[i].end());
    }
    return masterLeg;
}

Here is the caller graph for this function:

◆ buildNotionalLeg()

Leg buildNotionalLeg	(	const LegData &	data,
		const Leg &	leg,
		RequiredFixings &	requiredFixings,
		const QuantLib::ext::shared_ptr< Market > &	market,
		const std::string &	configuration
	)

Definition at line 2729 of file legdata.cpp.

                                                                                                  {
 
    if (!data.isNotResetXCCY()) {
        // If we have an FX resetting leg, add the notional amount at the start and end of each coupon period.
        DLOG("Building Resetting XCCY Notional leg");
        Real foreignNotional = data.foreignAmount();
 
        QL_REQUIRE(!data.fxIndex().empty(), "buildNotionalLeg(): need fx index for fx resetting leg");
        auto fxIndex =
            buildFxIndex(data.fxIndex(), data.currency(), data.foreignCurrency(), market, configuration, true);
 
        PaymentLag notionalPayLag = parsePaymentLag(data.notionalPaymentLag());
        Natural payLagInteger = boost::apply_visitor(PaymentLagInteger(), notionalPayLag);
        const Calendar& payCalendar = parseCalendar(data.paymentCalendar());
        const BusinessDayConvention& payConvention = parseBusinessDayConvention(data.paymentConvention());
 
        Leg resettingLeg;
        for (Size j = 0; j < leg.size(); j++) {
 
            QuantLib::ext::shared_ptr<Coupon> c = QuantLib::ext::dynamic_pointer_cast<Coupon>(leg[j]);
            QL_REQUIRE(c, "Expected each cashflow in FX resetting leg to be of type Coupon");
 
            const Date& initFlowDate = payCalendar.advance(c->accrualStartDate(), payLagInteger, Days, payConvention);
            const Date& finalFlowDate = payCalendar.advance(c->accrualEndDate(), payLagInteger, Days, payConvention);
 
            // Build a pair of notional flows, one at the start and one at the end of the accrual period.
            // They both have the same FX fixing date => same amount in this leg's currency.
            QuantLib::ext::shared_ptr<CashFlow> outCf;
            QuantLib::ext::shared_ptr<CashFlow> inCf;
            Date fixingDate;
            if (j == 0) {
 
                // Two possibilities for first coupon:
                // 1. we have not been given a domestic notional so it is an FX linked coupon
                // 2. we have been given an explicit domestic notional so it is a simple cashflow
                if (data.notionals().size() == 0) {
                    fixingDate = fxIndex->fixingDate(c->accrualStartDate());
                    if (data.notionalInitialExchange()) {
                        outCf = QuantLib::ext::make_shared<FXLinkedCashFlow>(initFlowDate, fixingDate, -foreignNotional,
                                                                             fxIndex);
                    }
                    // if there is only one period we generate the cash flow at the period end
                    // only if there is a final notional exchange
                    if (leg.size() > 1 || data.notionalFinalExchange()) {
                        inCf = QuantLib::ext::make_shared<FXLinkedCashFlow>(finalFlowDate, fixingDate, foreignNotional,
                                                                            fxIndex);
                    }
                } else {
                    if (data.notionalInitialExchange()) {
                        outCf = QuantLib::ext::make_shared<SimpleCashFlow>(-c->nominal(), initFlowDate);
                    }
                    if (leg.size() > 1 || data.notionalFinalExchange()) {
                        inCf = QuantLib::ext::make_shared<SimpleCashFlow>(c->nominal(), finalFlowDate);
                    }
                }
            } else {
                fixingDate = fxIndex->fixingDate(c->accrualStartDate());
                outCf =
                    QuantLib::ext::make_shared<FXLinkedCashFlow>(initFlowDate, fixingDate, -foreignNotional, fxIndex);
                // we don't want a final one, unless there is notional exchange
                if (j < leg.size() - 1 || data.notionalFinalExchange()) {
                    inCf =
                        QuantLib::ext::make_shared<FXLinkedCashFlow>(finalFlowDate, fixingDate, foreignNotional, fxIndex);
                }
            }
 
            // Add the cashflows to the notional leg if they have been populated
            if (outCf) {
                resettingLeg.push_back(outCf);
                if (fixingDate != Date())
                    requiredFixings.addFixingDate(fixingDate, data.fxIndex(), outCf->date());
            }
            if (inCf) {
                resettingLeg.push_back(inCf);
                if (fixingDate != Date())
                    requiredFixings.addFixingDate(fixingDate, data.fxIndex(), inCf->date());
            }
        }
 
        if (data.notionalAmortizingExchange()) {
            QL_FAIL("Cannot have an amortizing notional with FX reset");
        }
 
        return resettingLeg;
 
    } else if ((data.notionalInitialExchange() || data.notionalFinalExchange() || data.notionalAmortizingExchange()) &&
               (data.legType() != "CPI")) {
 
        // check for notional exchanges on non FX reseting trades
 
        PaymentLag notionalPayLag = parsePaymentLag(data.notionalPaymentLag());
        Natural notionalPayLagInteger = boost::apply_visitor(PaymentLagInteger(), notionalPayLag);
 
        return makeNotionalLeg(leg, data.notionalInitialExchange(), data.notionalFinalExchange(),
                               data.notionalAmortizingExchange(), notionalPayLagInteger,
                               parseBusinessDayConvention(data.paymentConvention()),
                               parseCalendar(data.paymentCalendar()), true);
    } else {
        return Leg();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCmbLegCreditRiskCurrency()

std::string getCmbLegCreditRiskCurrency	(	const CMBLegData &	ld,
		const QuantLib::ext::shared_ptr< ReferenceDataManager > &	refData
	)

Definition at line 2851 of file legdata.cpp.

                                                                                                                        {
    if (auto bondRefData = getCmbLegRefData(ld, refData)) {
        std::string security = getCmbLegSecurity(ld.genericBond());
        BondData bd(security, 1.0);
        bd.populateFromBondReferenceData(bondRefData);
        return bd.currency();
    }
    return std::string();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCmbLegCreditQualifierMapping()

std::pair< std::string, SimmCreditQualifierMapping > getCmbLegCreditQualifierMapping	(	const CMBLegData &	ld,
		const QuantLib::ext::shared_ptr< ReferenceDataManager > &	refData,
		const std::string &	tradeId,
		const std::string &	tradeType
	)

Definition at line 2862 of file legdata.cpp.

                                                                                      {
    string source;
    ore::data::SimmCreditQualifierMapping target;
    std::string security = getCmbLegSecurity(ld.genericBond());
    if (auto bondRefData = getCmbLegRefData(ld, refData)) {
        source = ore::data::securitySpecificCreditCurveName(security, bondRefData->bondData().creditCurveId);
        target.targetQualifier = security;
        target.creditGroup = bondRefData->bondData().creditGroup;
    }
    if (source.empty() || target.targetQualifier.empty()) {
        ore::data::StructuredTradeErrorMessage(tradeId, tradeType, "getCmbLegCreditQualifierMapping()",
                                                    "Could not set mapping for CMB Leg security '" +
                                                        security +
                                                   "'. Check security name and reference data.")
            .log();
    }
    return std::make_pair(source, target);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeNotionalLeg() [2/2]

Leg makeNotionalLeg	(	const Leg &	refLeg,
		const bool	initNomFlow,
		const bool	finalNomFlow,
		const bool	amortNomFlow,
		const QuantLib::Natural	notionalPaymentLag,
		const BusinessDayConvention	paymentConvention,
		const Calendar	paymentCalendar,
		const bool	excludeIndexing = `true`
	)

◆ makeEquityLeg() [2/2]

Leg makeEquityLeg	(	const LegData &	data,
		const QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 > &	equityCurve,
		const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &	fxIndex = `nullptr`,
		const QuantLib::Date &	openEndDateReplacement = `Null< Date >()`
	)

◆ buildScheduledVector()

vector< T > buildScheduledVector	(	const vector< T > &	values,
		const vector< string > &	dates,
		const Schedule &	schedule,
		const bool	checkAllValuesAppearInResult = `false`
	)

Definition at line 1061 of file legdata.hpp.

                                                                        {
    if (values.size() < 2 || dates.size() == 0)
        return values;
 
    QL_REQUIRE(values.size() == dates.size(), "Value / Date size mismatch in buildScheduledVector."
                                                  << "Value:" << values.size() << ", Dates:" << dates.size());
 
    // parse the dates
    std::vector<QuantLib::Date> parsedDates;
    std::transform(dates.begin(), dates.end(), std::back_inserter(parsedDates), &parseDate);
 
    // adjust the dates using the schedule calendar and roll convention
    if (!schedule.calendar().empty()) {
        for (auto& d : parsedDates)
            if(d != Date())
                d = schedule.calendar().adjust(d, schedule.businessDayConvention());
    }
 
    // Need to use schedule logic
    // Length of data will be 1 less than schedule
    //
    // Notional 100
    // Notional {startDate 2015-01-01} 200
    // Notional {startDate 2016-01-01} 300
    //
    // Given schedule June, Dec from 2014 to 2016 (6 dates, 5 coupons)
    // we return 100, 100, 200, 200, 300
 
    // The first node must not have a date.
    // If the second one has a date, all the rest must have, and we process
    // If the second one does not have a date, none of them must have one
    // and we return the vector unaffected.
    QL_REQUIRE(parsedDates.front() == Date(), "Invalid date " << dates.front() << " for first node");
    if (parsedDates[1] == Date()) {
        // They must all be empty and then we return values
        for (Size i = 2; i < dates.size(); i++) {
            QL_REQUIRE(parsedDates[i] == Date(), "Invalid date " << dates[i] << " for node " << i
                                                                 << ". Cannot mix dates and non-dates attributes");
        }
        return values;
    }
 
    // We have nodes with date attributes now
    Size len = schedule.size() - 1;
    vector<T> data(len);
    Size j = 0, max_j = parsedDates.size() - 1; // j is the index of date/value vector. 0 to max_j
    Date d = parsedDates[j + 1];                // The first start date
    for (Size i = 0; i < len; i++) {            // loop over data vector and populate it.
        // If j == max_j we just fall through and take the final value
        while (schedule[i] >= d && j < max_j) {
            j++;
            if (j < max_j) {
                QL_REQUIRE(parsedDates[j + 1] != Date(), "Cannot have empty date attribute for node " << j + 1);
                d = parsedDates[j + 1];
            }
        }
        data[i] = values[j];
    }
 
    if (checkAllValuesAppearInResult) {
        auto it = checkAllValuesAppearInScheduledVector<T>(data, values);
        QL_REQUIRE(it == values.end(),
                   "buildScheduledVector: input value '" << *it << " does not appear in the result vector");
    }
 
    return data;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ normaliseToSchedule()

vector< T > normaliseToSchedule	(	const vector< T > &	values,
		const Schedule &	schedule,
		const T &	defaultValue
	)

Definition at line 1131 of file legdata.hpp.

                                                                                                        {
    vector<T> res = values;
    if (res.size() < schedule.size() - 1)
        res.resize(schedule.size() - 1, res.size() == 0 ? defaultValue : res.back());
    return res;
}

Here is the caller graph for this function:

◆ buildScheduledVectorNormalised()

vector< T > buildScheduledVectorNormalised	(	const vector< T > &	values,
		const vector< string > &	dates,
		const Schedule &	schedule,
		const T &	defaultValue,
		const bool	checkAllValuesAppearInResult = `false`
	)

Definition at line 1139 of file legdata.hpp.

                                                                                                         {
    return normaliseToSchedule(buildScheduledVector(values, dates, schedule, checkAllValuesAppearInResult), schedule,
                               defaultValue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkAllValuesAppearInScheduledVector()

vector< T >::const_iterator checkAllValuesAppearInScheduledVector	(	const vector< T > &	scheduledVecotr,
		const vector< T > &	inputValues
	)

Definition at line 1146 of file legdata.hpp.

                                                                                                       {
    auto s = scheduledVector.begin();
    auto i = inputValues.begin();
    while (i != inputValues.end()) {
        if (s == scheduledVector.end())
            return i;
        if (*i == *s) {
            ++i;
        } else {
            ++s;
        }
    }
    return i;
}

◆ makeNonStandardIborLeg() [1/2]

Leg makeNonStandardIborLeg	(	const QuantLib::ext::shared_ptr< IborIndex > &	index,
		const std::vector< Date > &	calcDates,
		const std::vector< Date > &	payDatesInput,
		const std::vector< Date > &	fixingDatesInput,
		const std::vector< Date > &	resetDatesInput,
		const Size	fixingDays,
		const std::vector< Real > &	notionals,
		const std::vector< Date > &	notionalDatesInput,
		const std::vector< Real > &	spreadsInput,
		const std::vector< Date > &	spreadDatesInput,
		const std::vector< Real > &	gearingsInput,
		const std::vector< Date > &	gearingDatesInput,
		const bool	strictNotionalDates,
		const DayCounter &	dayCounter,
		const Calendar &	payCalendar,
		const BusinessDayConvention	payConv,
		const Period &	payLag,
		const bool	isInArrears
	)

Definition at line 28 of file makenonstandardlegs.cpp.

                                                                                                              {
 
    // add spread and gearing if none is given
 
    std::vector<Real> spreads = spreadsInput, gearings = gearingsInput;
 
    if (spreads.empty()) {
        spreads.push_back(0.0);
    }
 
    if (gearings.empty()) {
        gearings.push_back(1.0);
    }
 
    // checks
 
    QL_REQUIRE(calcDates.size() >= 2,
               "makeNonStandardIborLeg(): calc dates size (" << calcDates.size() << ") >= 2 required");
    QL_REQUIRE(!notionals.empty(), "makeNonStandardIborLeg(): empty notinoals");
    QL_REQUIRE(notionalDatesInput.empty() || notionalDatesInput.size() == notionals.size() - 1,
               "makeNonStandardIborLeg(): notional dates (" << notionalDatesInput.size() << ") must match notional ("
                                                            << notionals.size() << ") minus 1");
    QL_REQUIRE(spreadDatesInput.empty() || spreadDatesInput.size() == spreads.size() - 1,
               "makeNonStandardIborLeg(): spread dates (" << spreadDatesInput.size() << ") must match spread ("
                                                          << spreads.size() << ") minus 1");
    QL_REQUIRE(gearingDatesInput.empty() || gearingDatesInput.size() == gearings.size() - 1,
               "makeNonStandardIborLeg(): gearing dates (" << gearingDatesInput.size() << ") must match gearing ("
                                                           << gearings.size() << ") minus 1");
 
    // populate pay dates, reset dates, fixing dates, notional dates if not explicitly given
 
    std::vector<Date> payDates(payDatesInput);
    std::vector<Date> resetDates(resetDatesInput);
    std::vector<Date> fixingDates(fixingDatesInput);
    std::vector<Date> notionalDates(notionalDatesInput);
    std::vector<Date> spreadDates(spreadDatesInput);
    std::vector<Date> gearingDates(gearingDatesInput);
 
    if (payDates.empty()) {
        for (Size i = 1; i < calcDates.size(); ++i) {
            payDates.push_back(payCalendar.advance(calcDates[i], payLag, payConv));
        }
    }
 
    if (resetDates.empty() && fixingDates.empty()) {
        for (Size i = 0; i < calcDates.size() - 1; ++i) {
            resetDates.push_back(calcDates[i]);
            fixingDates.push_back(index->fixingCalendar().advance(isInArrears ? calcDates[i + 1] : calcDates[i],
                                                                  -static_cast<int>(fixingDays) * Days, Preceding));
        }
    } else if (resetDates.empty()) {
        for (Size i = 0; i < fixingDates.size(); ++i) {
            resetDates.push_back(index->fixingCalendar().advance(fixingDates[i], fixingDays * Days, Following));
        }
    } else if (fixingDates.empty()) {
        for (Size i = 0; i < resetDates.size(); ++i) {
            fixingDates.push_back(
                index->fixingCalendar().advance(resetDates[i], -static_cast<int>(fixingDays) * Days, Preceding));
        }
    }
 
    if (notionalDates.empty()) {
        for (Size i = 1; i < notionals.size(); ++i)
            notionalDates.push_back(calcDates[i]);
    }
 
    if (spreadDates.empty()) {
        for (Size i = 1; i < spreads.size(); ++i)
            spreadDates.push_back(calcDates[i]);
    }
 
    if (gearingDates.empty()) {
        for (Size i = 1; i < gearings.size(); ++i)
            gearingDates.push_back(calcDates[i]);
    }
 
    // more checks
 
    QL_REQUIRE(payDates.size() == calcDates.size() - 1, "makeNonStandardIborLeg(): pay dates size ("
                                                            << payDates.size() << ") = calc dates size ("
                                                            << calcDates.size() << ") minus 1 required");
    QL_REQUIRE(fixingDates.size() == resetDates.size(), "makeNonStandardIborLeg(): fixing dates ("
                                                            << fixingDates.size() << ") must match reset dates ("
                                                            << resetDates.size() << ")");
 
    for (Size i = 0; i < fixingDates.size(); ++i) {
        QL_REQUIRE(resetDates[i] <= calcDates.back(), "makeNonStandardIborLeg(): reset date at "
                                                          << i << " (" << resetDates[i]
                                                          << ") must be less or equal last calculation date ("
                                                          << calcDates.back());
    }
 
    for (Size i = 0; i < calcDates.size() - 1; ++i) {
        QL_REQUIRE(calcDates[i] <= calcDates[i + 1], "makeNonStandardIborLeg(): calc date at "
                                                         << i << " (" << calcDates[i]
                                                         << ") must be less or equal calc date at " << (i + 1) << " ("
                                                         << calcDates[i + 1]);
    }
 
    for (Size i = 0; i < fixingDates.size() - 1; ++i) {
        QL_REQUIRE(fixingDates[i] <= fixingDates[i + 1], "makeNonStandardIborLeg(): fixing date at "
                                                             << i << " (" << fixingDates[i]
                                                             << ") must be less or equal fixing date at " << (i + 1)
                                                             << " (" << fixingDates[i + 1] << ")");
    }
 
    for (Size i = 0; i < resetDates.size() - 1; ++i) {
        QL_REQUIRE(resetDates[i] <= resetDates[i + 1], "makeNonStandardIborLeg(): reset date at "
                                                           << i << " (" << resetDates[i]
                                                           << ") must be less or equal reset date at " << (i + 1)
                                                           << " (" << resetDates[i + 1] << ")");
    }
 
    // build calculation periods including broken periods due to notional resets or fixing resets
 
    std::set<Date> effCalcDates;
 
    for (auto const& d : calcDates)
        effCalcDates.insert(d);
 
    for (auto const& d : resetDates) {
        if (d >= calcDates.front() && d < calcDates.back())
            effCalcDates.insert(d);
    }
 
    if (strictNotionalDates) {
        for (auto const& d : notionalDates) {
            if (d >= calcDates.front() && d < calcDates.back())
                effCalcDates.insert(d);
        }
    }
 
    // build coupons
 
    Leg leg;
 
    for (auto startDate = effCalcDates.begin(); startDate != std::next(effCalcDates.end(), -1); ++startDate) {
        // determine calc end date from start date
 
        Date endDate = *std::next(startDate, 1);
 
        if (endDate > calcDates.back())
            continue;
 
        // determine pay date
 
        auto nextCalcDate = std::lower_bound(calcDates.begin(), calcDates.end(), endDate);
        Date payDate = payDates[std::max<Size>(1, std::distance(calcDates.begin(), nextCalcDate)) - 1];
 
        // determine reset and thereby fixing date
 
        auto nextReset = std::upper_bound(resetDates.begin(), resetDates.end(), *startDate);
        QL_REQUIRE(nextReset != resetDates.begin(),
                   "makeNonStandardIborLeg(): calc start date "
                       << *startDate << " is before first reset date " << *resetDates.begin()
                       << ". Ensure that there is a reset date on or before the calc start date.");
        Date fixingDate = fixingDates[std::distance(resetDates.begin(), nextReset) - 1];
 
        // determine notional
 
        auto notionalDate = std::upper_bound(notionalDates.begin(), notionalDates.end(), *startDate);
        Real notional =
            notionals[std::min<Size>(notionals.size() - 1, std::distance(notionalDates.begin(), notionalDate))];
 
        // determine spread
 
        auto spreadDate = std::upper_bound(spreadDates.begin(), spreadDates.end(), *startDate);
        Real spread = spreads[std::min<Size>(spreads.size() - 1, std::distance(spreadDates.begin(), spreadDate))];
 
        // determine gearing
 
        auto gearingDate = std::upper_bound(gearingDates.begin(), gearingDates.end(), *startDate);
        Real gearing = gearings[std::min<Size>(gearings.size() - 1, std::distance(gearingDates.begin(), gearingDate))];
 
        // build coupon
 
        leg.push_back(QuantLib::ext::make_shared<IborCoupon>(payDate, notional, *startDate, endDate, fixingDate, index, gearing,
                                                     spread, Date(), Date(), dayCounter));
    }
 
    return leg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeNonStandardFixedLeg() [1/2]

Leg makeNonStandardFixedLeg	(	const std::vector< Date > &	calcDates,
		const std::vector< Date > &	payDatesInput,
		const std::vector< Real > &	notionals,
		const std::vector< Date > &	notionalDatesInput,
		const std::vector< Real > &	rates,
		const std::vector< Date > &	rateDatesInput,
		const bool	strictNotionalDates,
		const DayCounter &	dayCounter,
		const Calendar &	payCalendar,
		const BusinessDayConvention	payConv,
		const Period &	payLag
	)

Definition at line 218 of file makenonstandardlegs.cpp.

                                                                                       {
 
    // checks
 
    QL_REQUIRE(calcDates.size() >= 2,
               "makeNonStandardFixedLeg(): calc dates size (" << calcDates.size() << ") >= 2 required");
    QL_REQUIRE(!notionals.empty(), "makeNonStandardFixedLeg(): empty notinoals");
    QL_REQUIRE(!rates.empty(), "makeNonStandardFixedLeg(): empty rates");
    QL_REQUIRE(notionalDatesInput.empty() || notionalDatesInput.size() == notionals.size() - 1,
               "makeNonStandardFixedLeg(): notional dates (" << notionalDatesInput.size() << ") must match notional ("
                                                             << notionals.size() << ") minus 1");
    QL_REQUIRE(rateDatesInput.empty() || rateDatesInput.size() == rates.size() - 1,
               "makeNonStandardIborLeg(): rate dates (" << rateDatesInput.size() << ") must match rate ("
                                                        << rates.size() << ") minus 1");
 
    for (Size i = 0; i < calcDates.size() - 1; ++i) {
        QL_REQUIRE(calcDates[i] <= calcDates[i + 1], "makeNonStandardFixedLeg(): calc date at "
                                                         << i << " (" << calcDates[i]
                                                         << ") must be less or equal calc date at " << (i + 1) << " ("
                                                         << calcDates[i + 1] << ")");
    }
 
    // populate pay dates, notional dates if not given
 
    std::vector<Date> payDates(payDatesInput);
    std::vector<Date> notionalDates(notionalDatesInput);
    std::vector<Date> rateDates(rateDatesInput);
 
    if (payDates.empty()) {
        for (Size i = 1; i < calcDates.size(); ++i) {
            payDates.push_back(payCalendar.advance(calcDates[i], payLag, payConv));
        }
    }
 
    if (notionalDates.empty()) {
        for (Size i = 1; i < notionals.size(); ++i)
            notionalDates.push_back(calcDates[i]);
    }
 
    if (rateDates.empty()) {
        for (Size i = 1; i < rates.size(); ++i)
            rateDates.push_back(calcDates[i]);
    }
 
    // more checks
 
    QL_REQUIRE(payDates.size() == calcDates.size() - 1, "makeNonStandardFixedLeg(): pay dates size ("
                                                            << payDates.size() << ") = calc dates size ("
                                                            << calcDates.size() << ") minus 1 required");
 
    // build calculation periods including broken periods due to notional resets or fixing resets
 
    std::set<Date> effCalcDates;
 
    for (auto const& d : calcDates)
        effCalcDates.insert(d);
 
    if (strictNotionalDates)
        for (auto const& d : notionalDates) {
            if (d >= calcDates.front() && d < calcDates.back())
                effCalcDates.insert(d);
        }
 
    // build coupons
 
    Leg leg;
 
    for (auto startDate = effCalcDates.begin(); startDate != std::next(effCalcDates.end(), -1); ++startDate) {
 
        // determine calc end date from start date
 
        Date endDate = *std::next(startDate, 1);
 
        if (endDate >= calcDates.back())
            continue;
 
        // determine pay date
 
        auto nextCalcDate = std::lower_bound(calcDates.begin(), calcDates.end(), endDate);
        Date payDate = payDates[std::max<Size>(1, std::distance(calcDates.begin(), nextCalcDate)) - 1];
 
        // determine notional
 
        auto notionalDate = std::upper_bound(notionalDates.begin(), notionalDates.end(), *startDate);
        Real notional =
            notionals[std::min<Size>(notionals.size() - 1, std::distance(notionalDates.begin(), notionalDate))];
 
        // determine rate
 
        auto rateDate = std::upper_bound(rateDates.begin(), rateDates.end(), *startDate);
        Real rate = rates[std::min<Size>(rates.size() - 1, std::distance(rateDates.begin(), rateDate))];
 
        // build coupon
 
        leg.push_back(QuantLib::ext::make_shared<FixedRateCoupon>(payDate, notional, rate, dayCounter, *startDate, endDate,
                                                          Date(), Date()));
    }
 
    return leg;
}

Here is the caller graph for this function:

◆ makeNonStandardIborLeg() [2/2]

QuantLib::Leg makeNonStandardIborLeg	(	const QuantLib::ext::shared_ptr< QuantLib::IborIndex > &	index,
		const std::vector< QuantLib::Date > &	calcDates,
		const std::vector< QuantLib::Date > &	payDates,
		const std::vector< QuantLib::Date > &	fixingDates,
		const std::vector< QuantLib::Date > &	resetDates,
		const QuantLib::Size	fixingDays,
		const std::vector< QuantLib::Real > &	notionals,
		const std::vector< QuantLib::Date > &	notionalDates,
		const std::vector< QuantLib::Real > &	spreads,
		const std::vector< QuantLib::Date > &	spreadDates,
		const std::vector< QuantLib::Real > &	gearings,
		const std::vector< QuantLib::Date > &	gearingDates,
		const bool	strictNotionalDates,
		const QuantLib::DayCounter &	dayCounter,
		const QuantLib::Calendar &	payCalendar,
		const QuantLib::BusinessDayConvention	payConv,
		const QuantLib::Period &	payLag,
		const bool	isInArrears
	)

◆ makeNonStandardFixedLeg() [2/2]

QuantLib::Leg makeNonStandardFixedLeg	(	const std::vector< QuantLib::Date > &	calcDates,
		const std::vector< QuantLib::Date > &	payDates,
		const std::vector< QuantLib::Real > &	notionals,
		const std::vector< QuantLib::Date > &	notionalDates,
		const std::vector< QuantLib::Real > &	rates,
		const std::vector< QuantLib::Date > &	rateDates,
		const bool	strictNotionalDates,
		const QuantLib::DayCounter &	dayCounter,
		const QuantLib::Calendar &	payCalendar,
		const QuantLib::BusinessDayConvention	payConv,
		const QuantLib::Period &	payLag
	)

◆ parseCsaType()

CSA::Type parseCsaType ( const string & s )

Definition at line 29 of file nettingsetdefinition.cpp.

                                      {
    static map<string, CSA::Type> t = {
        {"Bilateral", CSA::Bilateral}, {"CallOnly", CSA::CallOnly}, {"PostOnly", CSA::PostOnly}};
 
    auto it = t.find(s);
    if (it != t.end()) {
        return it->second;
    } else {
        QL_FAIL("Cannot convert \"" << s << "\" to CSA::Type");
    }
}

Here is the caller graph for this function:

◆ operator<<() [42/73]

std::ostream & operator<<	(	std::ostream &	out,
		CSA::Type	t
	)

Definition at line 41 of file nettingsetdefinition.cpp.

                                                   {
    switch (t) {
    case CSA::Bilateral:
        return out << "Bilateral";
    case CSA::CallOnly:
        return out << "CallOnly";
    case CSA::PostOnly:
        return out << "PostOnly";
    default:
        QL_FAIL("csa type not covered");
    }
}

◆ operator<() [12/14]

bool operator<	(	const NettingSetDetails &	lhs,
		const NettingSetDetails &	rhs
	)

Comparison operators.

Definition at line 93 of file nettingsetdetails.cpp.

                                                                           {
    return std::tie(lhs.nettingSetId(), lhs.agreementType(), lhs.callType(), lhs.initialMarginType(),
                    lhs.legalEntityId()) < std::tie(rhs.nettingSetId(), rhs.agreementType(), rhs.callType(),
                                                    rhs.initialMarginType(), rhs.legalEntityId());
}

Here is the call graph for this function:

◆ operator==() [7/13]

bool operator==	(	const NettingSetDetails &	lhs,
		const NettingSetDetails &	rhs
	)

Definition at line 99 of file nettingsetdetails.cpp.

                                                                            {
    return (lhs.nettingSetId() == rhs.nettingSetId() && lhs.agreementType() == rhs.agreementType() &&
            lhs.callType() == rhs.callType() && lhs.initialMarginType() == rhs.initialMarginType() &&
            lhs.legalEntityId() == rhs.legalEntityId());
}

Here is the call graph for this function:

◆ operator!=() [3/4]

bool operator!=	(	const NettingSetDetails &	lhs,
		const NettingSetDetails &	rhs
	)

Definition at line 105 of file nettingsetdetails.cpp.

105{ return !(lhs == rhs); }

◆ operator<<() [43/73]

std::ostream & operator<<	(	std::ostream &	out,
		const NettingSetDetails &	nettingSetDetails
	)

Enable writing of netting set details.

Definition at line 107 of file nettingsetdetails.cpp.

                                                                                    {
    std::ostream& tmp = out << "NettingSetId=\'" << nettingSetDetails.nettingSetId() << "\'";
 
    if (!nettingSetDetails.emptyOptionalFields()) {
        return tmp << ", AgreementType=\'" << nettingSetDetails.agreementType() << "\', CallType=\'"
                   << nettingSetDetails.callType() << "\', InitialMarginType=\'"
                   << nettingSetDetails.initialMarginType() << "\', LegalEntityId=\'"
                   << nettingSetDetails.legalEntityId() << "\'";
    }
 
    return tmp;
}

Here is the call graph for this function:

◆ operator<<() [44/73]

std::ostream & operator<<	(	ostream &	out,
		const OptionPaymentData::RelativeTo &	relativeTo
	)

Print RelativeTo enum values.

Definition at line 107 of file optionpaymentdata.cpp.

                                                                                 {
    switch (relativeTo) {
    case OptionPaymentData::RelativeTo::Expiry:
        return out << "Expiry";
    case OptionPaymentData::RelativeTo::Exercise:
        return out << "Exercise";
    default:
        QL_FAIL("Could not convert the relativeTo enum value to string.");
    }
}

◆ buildTrade()

std::pair< QuantLib::ext::shared_ptr< Trade >, bool > buildTrade	(	QuantLib::ext::shared_ptr< Trade > &	trade,
		const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const std::string &	context,
		const bool	ignoreTradeBuildFail,
		const bool	buildFailedTrades,
		const bool	emitStructuredError
	)

Definition at line 269 of file portfolio.cpp.

                                                                                                                   {
    try {
        trade->reset();
        trade->build(engineFactory);
        TLOG("Required Fixings for trade " << trade->id() << ":");
        TLOGGERSTREAM(trade->requiredFixings());
        return std::make_pair(nullptr, true);
    } catch (std::exception& e) {
        if (emitStructuredError) {
            StructuredTradeErrorMessage(trade, "Error building trade for context '" + context + "'", e.what()).log();
        } else {
            ALOG("Error building trade '" << trade->id() << "' for context '" + context + "': " + e.what());
        }
        if (ignoreTradeBuildFail) {
            return std::make_pair(trade, false);
        } else if (buildFailedTrades) {
            QuantLib::ext::shared_ptr<FailedTrade> failed = QuantLib::ext::make_shared<FailedTrade>();
            failed->id() = trade->id();
            failed->setUnderlyingTradeType(trade->tradeType());
            failed->setEnvelope(trade->envelope());
            failed->build(engineFactory);
            failed->resetPricingStats(trade->getNumberOfPricings(), trade->getCumulativePricingTime());
            LOG("Built failed trade with id " << failed->id());
            return std::make_pair(failed, false);
        } else {
            return std::make_pair(nullptr, false);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator==() [8/13]

bool operator==	(	const RangeBound &	a,
		const RangeBound &	b
	)

Definition at line 66 of file rangebound.cpp.

                                                          {
    return a.from() == b.from() && a.to() == b.to() && a.leverage() == b.leverage() && a.strike() == b.strike() &&
           a.strikeAdjustment() == b.strikeAdjustment();
}

Here is the call graph for this function:

◆ operator<<() [45/73]

std::ostream & operator<<	(	std::ostream &	out,
		const RangeBound &	t
	)

Definition at line 80 of file rangebound.cpp.

                                                             {
    return out << "[" << output(t.from()) << ", " << output(t.to()) << "] x " << output(t.leverage()) << " @ "
               << output(t.strike()) << " +- " << output(t.strikeAdjustment());
}

Here is the call graph for this function:

◆ operator<<() [46/73]

std::ostream & operator<<	(	std::ostream &	out,
		const std::vector< RangeBound > &	t
	)

Definition at line 85 of file rangebound.cpp.

                                                                        {
    std::ostringstream s;
    s << "[ ";
    for (Size i = 0; i < t.size(); ++i)
        s << t[i] << (i < t.size() - 1 ? ", " : "");
    s << " ]";
    return out << s.str();
}

◆ operator<() [13/14]

bool operator<	(	const CreditIndexConstituent &	lhs,
		const CreditIndexConstituent &	rhs
	)

Compare CreditIndexConstituent instances using their name.

Definition at line 199 of file referencedata.cpp.

199{ return lhs.name() < rhs.name(); }

ore::data::CreditIndexConstituent::name

const std::string & name() const

Definition: referencedata.cpp:183

Here is the call graph for this function:

◆ createReferenceDatumBuilder()

QuantLib::ext::shared_ptr< AbstractReferenceDatumBuilder > createReferenceDatumBuilder ( )

Definition at line 71 of file referencedatafactory.hpp.

                                                                                                      {
    return QuantLib::ext::make_shared<T>();
}

◆ makeSchedule() [1/7]

QuantLib::Schedule makeSchedule ( const ScheduleDates & data )

Definition at line 263 of file schedule.cpp.

                                                 {
    QL_REQUIRE(data.dates().size() > 0, "Must provide at least 1 date for Schedule");
    Calendar calendar = parseCalendar(data.calendar());
    BusinessDayConvention convention = ModifiedFollowing;
    if (!data.convention().empty())
        convention = parseBusinessDayConvention(data.convention());
    // Avoid compiler warning on gcc
    // https://www.boost.org/doc/libs/1_74_0/libs/optional/doc/html/boost_optional/tutorial/
    // gotchas/false_positive_with__wmaybe_uninitialized.html
    auto tenor = boost::make_optional(false, Period());
    if (!data.tenor().empty())
        tenor = parsePeriod(data.tenor());
    bool endOfMonth = false;
    if (!data.endOfMonth().empty())
        endOfMonth = parseBool(data.endOfMonth());
    ext::optional<BusinessDayConvention> endOfMonthConvention = boost::none;
    if (!data.endOfMonthConvention().empty())
        endOfMonthConvention = parseBusinessDayConvention(data.endOfMonthConvention());
 
    // Ensure that Schedule ctor is passed a vector of unique ordered dates.
    std::set<Date> uniqueDates;
    for (const string& d : data.dates())
        uniqueDates.insert(calendar.adjust(parseDate(d), convention));
 
    return QuantLib::Schedule(vector<Date>(uniqueDates.begin(), uniqueDates.end()), calendar, convention, boost::none,
                              tenor, boost::none, endOfMonth, vector<bool>(0), false, false, endOfMonthConvention);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeSchedule() [2/7]

Schedule makeSchedule	(	const ScheduleDerived &	data,
		const Schedule &	baseSchedule
	)

Definition at line 291 of file schedule.cpp.

                                                                                 {
 
    string strCalendar = data.calendar();
    Calendar calendar;
    if (strCalendar.empty()) {
        calendar = NullCalendar();
        WLOG("No calendar provided in Schedule, attempting to use a null calendar.");
    }
    else
        calendar = parseCalendar(strCalendar);
 
    BusinessDayConvention convention;
    string strConvention = data.convention();
    if (strConvention.empty())
        convention = BusinessDayConvention::Unadjusted;
    else
        convention = parseBusinessDayConvention(strConvention);
 
    string strShift = data.shift();
    Period shift;
    if (strShift.empty())
        shift = 0 * Days;
    else
        shift = parsePeriod(data.shift());
 
    const std::vector<QuantLib::Date>& baseDates = baseSchedule.dates();
    std::vector<QuantLib::Date> derivedDates;
    QuantLib::Date derivedDate;
    for (const Date& d : baseDates) {
        derivedDate = calendar.advance(d, shift, convention);
        derivedDates.push_back(derivedDate);
    }
    ext::optional<BusinessDayConvention> endOfMonthConvention = boost::none;
    if (baseSchedule.hasEndOfMonthBusinessDayConvention())
        endOfMonthConvention = baseSchedule.endOfMonthBusinessDayConvention();
 
    return QuantLib::Schedule(vector<Date>(derivedDates.begin(), derivedDates.end()), calendar, convention, boost::none,
                              baseSchedule.tenor(), boost::none, baseSchedule.endOfMonth(), std::vector<bool>(0),
                              data.removeFirstDate(), data.removeLastDate(),
                              endOfMonthConvention);
}

Here is the call graph for this function:

◆ makeSchedule() [3/7]

Schedule makeSchedule	(	const ScheduleRules &	data,
		const Date &	openEndDateReplacement
	)

Definition at line 333 of file schedule.cpp.

                                                                                     {
    QL_REQUIRE(!data.endDate().empty() || openEndDateReplacement != Null<Date>(),
               "makeSchedule(): Schedule does not have an end date, this is not supported in this context / for this "
               "trade type. Please provide an end date.");
    QL_REQUIRE(!data.endDate().empty() || data.lastDate().empty(),
               "makeSchedule(): If no end date is given, a last date is not allowed either. Please remove the last "
               "date from the schedule.");
    Calendar calendar = parseCalendar(data.calendar());
    if (calendar == NullCalendar())
        WLOG("No calendar provided in Schedule, attempting to use a null calendar.");
    Date startDate = parseDate(data.startDate());
    Date endDate = data.endDate().empty() ? openEndDateReplacement : parseDate(data.endDate());
    // Handle trivial case here
    if (startDate == endDate)
        return Schedule(vector<Date>(1, startDate), calendar);
 
    QL_REQUIRE(startDate < endDate, "StartDate " << startDate << " is ahead of EndDate " << endDate);
 
    Date firstDate = parseDate(data.firstDate());
    Date lastDate = parseDate(data.lastDate());
    if (firstDate != Date() && lastDate != Date())
        QL_REQUIRE(firstDate <= lastDate, "Schedule::makeSchedule firstDate must be before lastDate");
 
    Period tenor = parsePeriod(data.tenor());
 
    // defaults
    BusinessDayConvention bdc = ModifiedFollowing;
    BusinessDayConvention bdcEnd = ModifiedFollowing;
    DateGeneration::Rule rule = DateGeneration::Forward;
    bool endOfMonth = false;
    ext::optional<BusinessDayConvention> endOfMonthConvention = boost::none;
 
    // now check the strings, if they are empty we take defaults
    if (!data.convention().empty())
        bdc = parseBusinessDayConvention(data.convention());
    if (!data.termConvention().empty())
        bdcEnd = parseBusinessDayConvention(data.termConvention());
    else
        bdcEnd = bdc; // except here
 
    if (!data.endOfMonth().empty())
        endOfMonth = parseBool(data.endOfMonth());
    if (!data.endOfMonthConvention().empty())
        endOfMonthConvention = parseBusinessDayConvention(data.endOfMonthConvention());
 
    if (!data.rule().empty()) {
 
        // handle special rules outside the QuantLib date generation rules
 
        if (data.rule() == "EveryThursday") {
            auto dates = everyWeekDayDates(startDate, endDate, firstDate, QuantLib::Thursday);
            for (auto& d : dates)
                d = calendar.adjust(d, bdc);
            return QuantLib::Schedule(dates, calendar, bdc, bdcEnd, tenor, rule, endOfMonth, std::vector<bool>(0), false, false, endOfMonthConvention);
        } else if (data.rule() == "BusinessWeek" || data.rule() == "CalendarWeek") {
            auto dates = weeklyDates(startDate, endDate, firstDate, data.rule() == "CalendarWeek");
            for (auto& d : dates)
                d = calendar.adjust(d, bdc);
            return QuantLib::Schedule(dates, calendar, bdc, bdcEnd, tenor, rule, endOfMonth, std::vector<bool>(0), data.removeFirstDate(), data.removeLastDate(), endOfMonthConvention);
        }
 
        // parse rule for further processing below
 
        rule = parseDateGenerationRule(data.rule());
    }
 
    // handling of date generation rules that require special adjustments
 
    if ((rule == DateGeneration::CDS || rule == DateGeneration::CDS2015) &&
        (firstDate != Null<Date>() || lastDate != Null<Date>())) {
        // Special handling of first date and last date in combination with CDS and CDS2015 rules:
        // To be able to construct CDS schedules with front or back stub periods, we overwrite the
        // first (last) date of the schedule built in QL with a given first (last) date
        // The schedule builder in QL itself is not capable of doing this, it just throws an exception
        // if a first (last) date is given in combination with a CDS / CDS2015 date generation rule.
        std::vector<Date> dates = QuantLib::Schedule(startDate, endDate, tenor, calendar, bdc, bdcEnd, rule, endOfMonth,
                                                     Date(), Date(), false, false, endOfMonthConvention)
                                      .dates();
        QL_REQUIRE(!dates.empty(),
                   "got empty CDS or CDS2015 schedule, startDate = " << startDate << ", endDate = " << endDate);
        if (firstDate != Date())
            dates.front() = firstDate;
        if (lastDate != Date())
            dates.back() = lastDate;
        return QuantLib::Schedule(dates, calendar, bdc, bdcEnd, tenor, rule, endOfMonth, std::vector<bool>(0),
                        data.removeFirstDate(), data.removeLastDate(), endOfMonthConvention);
    }
 
    // default handling (QuantLib scheduler)
 
    return QuantLib::Schedule(startDate, endDate, tenor, calendar, bdc, bdcEnd, rule, endOfMonth, firstDate, lastDate,
                              data.removeFirstDate(), data.removeLastDate(), endOfMonthConvention);
}

Here is the call graph for this function:

◆ makeSchedule() [4/7]

Schedule makeSchedule	(	const ScheduleData &	data,
		const Date &	openEndDateReplacement,
		const map< string, QuantLib::Schedule > &	baseSchedules
	)

Definition at line 445 of file schedule.cpp.

                                                                                                                                        {
    if(!data.hasData())
        return Schedule();
    // only the last rule-based schedule is allowed to have an open end date, check this
    for (Size i = 1; i < data.rules().size(); ++i) {
        QL_REQUIRE(!data.rules()[i - 1].endDate().empty(),
                   "makeSchedule(): only last schedule is allowed to have an open end date");
    }
    // build all the date and rule based sub-schedules we have
    vector<Schedule> schedules;
    for (auto& d : data.dates())
        schedules.push_back(makeSchedule(d));
    for (auto& r : data.rules())
        schedules.push_back(makeSchedule(r, openEndDateReplacement));
    if (!baseSchedules.empty())
        for (auto& dv : data.derived()) {
            auto baseSchedule = baseSchedules.find(dv.baseSchedule());
            QL_REQUIRE(baseSchedule != baseSchedules.end(), "makeSchedule(): could not find base schedule \"" << dv.baseSchedule() << "\"");
            schedules.push_back(makeSchedule(dv, baseSchedule->second));
    }
    QL_REQUIRE(!schedules.empty(), "No dates or rules to build Schedule from");
    if (schedules.size() == 1)
        // if we have just one, use that (most common case)
        return schedules.front();
    else {
        // if we have multiple, combine them
 
        // 1) sort by start date
        std::sort(schedules.begin(), schedules.end(),
                  [](const Schedule& lhs, const Schedule& rhs) -> bool { return lhs.startDate() < rhs.startDate(); });
 
        // 2) check if meta data is present, and if yes if it is consistent across schedules;
        //    the only exception is the term date convention, this is taken from the last schedule always
        BusinessDayConvention convention = Null<BusinessDayConvention>(),
                              termConvention = Unadjusted; // initialization prevents gcc warning
        Calendar calendar;
        Period tenor;
        DateGeneration::Rule rule = DateGeneration::Zero; // initialization prevents gcc warning
        bool endOfMonth = false;                          // initialization prevents gcc warning
        BusinessDayConvention endOfMonthConvention = Null<BusinessDayConvention>();
        bool hasCalendar = false, hasConvention = false, hasTermConvention = false, hasTenor = false, hasRule = false,
             hasEndOfMonth = false, hasEndOfMonthConvention = false, hasConsistentCalendar = true,
             hasConsistentConvention = true, hasConsistentTenor = true, hasConsistentRule = true,
             hasConsistentEndOfMonth = true, hasConsistentEndOfMonthConvention = true;
        for (auto& d : data.dates()) {
            updateData<Calendar>(d.calendar(), calendar, hasCalendar, hasConsistentCalendar, parseCalendarTemp);
            updateData<BusinessDayConvention>(d.convention(), convention, hasConvention, hasConsistentConvention,
                                              parseBusinessDayConvention);
            updateData<Period>(d.tenor(), tenor, hasTenor, hasConsistentTenor, parsePeriod);
        }
        for (auto& d : data.rules()) {
            updateData<Calendar>(d.calendar(), calendar, hasCalendar, hasConsistentCalendar, parseCalendarTemp);
            updateData<BusinessDayConvention>(d.convention(), convention, hasConvention, hasConsistentConvention,
                                              parseBusinessDayConvention);
            updateData<Period>(d.tenor(), tenor, hasTenor, hasConsistentTenor, parsePeriod);
            updateData<bool>(d.endOfMonth(), endOfMonth, hasEndOfMonth, hasConsistentEndOfMonth, parseBool);
            updateData<BusinessDayConvention>(d.endOfMonthConvention(), endOfMonthConvention, hasEndOfMonthConvention,
                                              hasConsistentEndOfMonthConvention, parseBusinessDayConvention);
            updateData<DateGeneration::Rule>(d.rule(), rule, hasRule, hasConsistentRule, parseDateGenerationRule);
            if (d.termConvention() != "") {
                hasTermConvention = true;
                termConvention = parseBusinessDayConvention(d.termConvention());
            }
        }
 
        // 3) combine dates and fill isRegular flag
        const Schedule& s0 = schedules.front();
        vector<Date> dates = s0.dates();
        std::vector<bool> isRegular(s0.dates().size() - 1, false);
        if (s0.hasIsRegular())
            isRegular = s0.isRegular();
        // will be removed, if next schedule's front date is matching the last date of current schedule
        isRegular.push_back(false);
        for (Size i = 1; i < schedules.size(); ++i) {
            const Schedule& s = schedules[i];
            QL_REQUIRE(dates.back() <= s.dates().front(), "Dates mismatch");
            // if the end points match up, skip one to avoid duplicates, otherwise take both
            Size offset = dates.back() == s.dates().front() ? 1 : 0;
            isRegular.erase(isRegular.end() - offset,
                            isRegular.end()); // correct for superfluous flags from previous schedule
            // add isRegular information, if available, otherwise assume irregular periods
            if (s.hasIsRegular()) {
                isRegular.insert(isRegular.end(), s.isRegular().begin(), s.isRegular().end());
            } else {
                for (Size ii = 0; ii < s.dates().size() - 1; ++ii)
                    isRegular.push_back(false);
            }
            if (i < schedules.size() - 1) {
                // will be removed if next schedule's front date is matching last date of current schedule
                isRegular.push_back(false);
            }
            // add the dates
            dates.insert(dates.end(), s.dates().begin() + offset, s.dates().end());
        }
 
        // 4) Build schedule
        return QuantLib::Schedule(
            dates, hasCalendar && hasConsistentCalendar ? calendar : NullCalendar(),
            hasConvention && hasConsistentConvention ? convention : Unadjusted,
            hasTermConvention ? ext::optional<BusinessDayConvention>(termConvention) : boost::none,
            hasTenor && hasConsistentTenor ? ext::optional<Period>(tenor) : boost::none,
            hasRule && hasConsistentRule ? ext::optional<DateGeneration::Rule>(rule) : boost::none,
            hasEndOfMonth && hasConsistentEndOfMonth ? ext::optional<bool>(endOfMonth) : boost::none, isRegular,
            false, false,
            hasEndOfMonthConvention && hasConsistentEndOfMonthConvention
                ? ext::optional<BusinessDayConvention>(endOfMonthConvention)
                : boost::none);
    }
}

Here is the call graph for this function:

◆ makeSchedule() [5/7]

QuantLib::Schedule makeSchedule	(	const ScheduleData &	data,
		const QuantLib::Date &	openEndDateReplacement = `QuantLib::Null< QuantLib::Date >()`,
		const map< string, QuantLib::Schedule > &	baseSchedules = `map< string, QuantLib::Schedule >()`
	)

Functions.

◆ makeSchedule() [6/7]

QuantLib::Schedule makeSchedule	(	const ScheduleRules &	rules,
		const QuantLib::Date &	openEndDateReplacement = `QuantLib::Null< QuantLib::Date >()`
	)

◆ makeSchedule() [7/7]

QuantLib::Schedule makeSchedule	(	const ScheduleDerived &	derived,
		const QuantLib::Schedule &	baseSchedule
	)

◆ isdaSubProductSwap()

std::string isdaSubProductSwap	(	const std::string &	tradeId,
		const vector< LegData > &	legData
	)

Definition at line 323 of file swap.cpp.

                                                                                       {
 
    Size nFixed = 0;
    Size nFloating = 0;
    for (Size i = 0; i < legData.size(); ++i) {
        std::string type = legData[i].legType();
        if (type == "Fixed" ||
            type == "ZeroCouponFixed" ||
            type == "Cashflow"||
            type == "CommodityFixed")
            nFixed++;
        else if (type == "Floating" ||
                 type == "CPI" ||
                 type == "YY" ||
                 type == "CMS" ||
                 type == "DigitalCMS" ||
                 type == "CMSSpread" ||
                 type == "DigitalCMSSpread" ||
                 type == "CMB" ||
                 type == "Equity"||
                 type == "DurationAdjustedCMS"||
                 type == "FormulaBased"||
                 type =="CommodityFloating"||
                 type =="EquityMargin")
            nFloating++;
        else {
            ALOG("leg type " << type << " not mapped for trade " << tradeId);
        }
    }
 
    if (nFixed == 0)
        return string("Basis");  
    else if (nFloating >= 1)
        return string("Fixed Float");  
    else
        return string("Fixed Fixed");
}

Here is the caller graph for this function:

◆ addTRSRequiredFixings()

void addTRSRequiredFixings	(	RequiredFixings &	fixings,
		const std::vector< Leg > &	returnLegs,
		const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &	ind = `nullptr`
	)

Definition at line 42 of file trs.cpp.

                                                                 {
    QL_REQUIRE(returnLegs.size() > 0, "TrsUnderlyingBuilder: No returnLeg built");
    auto fdg = QuantLib::ext::make_shared<FixingDateGetter>(fixings);
    fdg->setAdditionalFxIndex(ind);
    for (const auto& rl : returnLegs)
        addToRequiredFixings(rl, fdg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parseTrsFundingNotionalType()

TRS::FundingData::NotionalType parseTrsFundingNotionalType ( const std::string & s )

Definition at line 789 of file trs.cpp.

                                                                           {
    auto it = types.left.find(s);
    QL_REQUIRE(it != types.left.end(),
               "parseTrsFundingNotionalType '" << s << "' failed, expected PeriodReset, DailyReset, Fixed");
    return it->second;
}

Here is the caller graph for this function:

◆ operator<<() [47/73]

std::ostream & operator<<	(	std::ostream &	os,
		const TRS::FundingData::NotionalType	t
	)

Definition at line 796 of file trs.cpp.

                                                                           {
    auto it = types.right.find(t);
    QL_REQUIRE(it != types.right.end(), "operator<<(" << static_cast<int>(t) << ") failed, this is an internal error.");
    os << it->second;
    return os;
}

◆ modifyBondTRSLeg()

void modifyBondTRSLeg	(	QuantLib::Leg &	leg,
		QuantLib::Date	issueDate
	)

Definition at line 37 of file trsunderlyingbuilder.cpp.

                                                                {
    auto it = leg.begin();
    while (it != leg.end()) {
        auto cf = QuantLib::ext::dynamic_pointer_cast<QuantExt::BondTRSCashFlow>(*it);
        if (cf) {
            if (cf->fixingEndDate() < issueDate) {
                it = leg.erase(it);
                continue;
            } else if (cf->fixingStartDate() < issueDate)
                cf->setFixingStartDate(issueDate);
        }
        ++it;
    }
}

Here is the caller graph for this function:

◆ makeBondTRSLeg() [1/2]

Leg makeBondTRSLeg	(	const std::vector< Date > &	valuationDates,
		const std::vector< Date > &	paymentDates,
		const BondIndexBuilder &	bondIndexBuilder,
		Real	initialPrice,
		QuantLib::ext::shared_ptr< QuantExt::FxIndex >	fxIndex
	)

Definition at line 52 of file trsunderlyingbuilder.cpp.

                                                                   {
 
    Leg returnLeg =
        QuantExt::BondTRSLeg(valuationDates, paymentDates, bondIndexBuilder.bond().bondData().bondNotional(),
                             bondIndexBuilder.bondIndex(), fxIndex).withInitialPrice(initialPrice);
    modifyBondTRSLeg(returnLeg, parseDate(bondIndexBuilder.bond().bondData().issueDate()));
    return returnLeg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ makeBondTRSLeg() [2/2]

Leg makeBondTRSLeg	(	const std::vector< Date > &	valuationDates,
		const std::vector< Date > &	paymentDates,
		const BondIndexBuilder &	bondIndexBuilder,
		QuantLib::Real	initialPrice = `QuantLib::Null< QuantLib::Real >()`,
		QuantLib::ext::shared_ptr< QuantExt::FxIndex >	fxIndex = `nullptr`
	)

◆ readEventData()

ScriptedTradeEventData readEventData ( XMLNode * node )

Definition at line 379 of file worstofbasketswap.cpp.

                                                    {
    ScriptedTradeEventData eventData;
 
    string name = XMLUtils::getNodeName(node);
    if (XMLNode* sch = XMLUtils::getChildNode(node, "DerivedSchedule")) {
        string baseSchedule = XMLUtils::getChildValue(sch, "BaseSchedule", true);
        
        string shift = XMLUtils::getChildValue(sch, "Shift", false);
        shift = shift.empty() ? "0D" : shift;
 
        string calendar = XMLUtils::getChildValue(sch, "Calendar", false);
        calendar = calendar.empty() ? "NullCalendar" : calendar;
 
        string convention = XMLUtils::getChildValue(sch, "Convention", false);
        convention = convention.empty() ? "Unadjusted" : convention;
 
        eventData = ScriptedTradeEventData(name, baseSchedule, shift, calendar, convention);
 
    } else {
        ScheduleData scheduleData = ScheduleData();
        scheduleData.fromXML(node);
        eventData = ScriptedTradeEventData(name, scheduleData);
    }
 
    return eventData;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ writeEventData()

XMLNode * writeEventData	(	XMLDocument &	doc,
		ScriptedTradeEventData &	eventData
	)

Definition at line 503 of file worstofbasketswap.cpp.

                                                                             {
    XMLNode* n = doc.allocNode(eventData.name());
    if (eventData.type() == ScriptedTradeEventData::Type::Derived) {
        XMLNode* derivedSchedule = doc.allocNode("DerivedSchedule");
        XMLUtils::addChild(doc, derivedSchedule, "BaseSchedule", eventData.baseSchedule());
        XMLUtils::addChild(doc, derivedSchedule, "Shift", eventData.shift());
        XMLUtils::addChild(doc, derivedSchedule, "Calendar", eventData.calendar());
        XMLUtils::addChild(doc, derivedSchedule, "Convention", eventData.convention());
        XMLUtils::appendNode(n, derivedSchedule);
    } else if (eventData.type() == ScriptedTradeEventData::Type::Array) {
        if (!eventData.schedule().dates().empty()) {
            vector<ScheduleDates> scheduleDates = eventData.schedule().dates();
            for (auto& d : scheduleDates)
                XMLUtils::appendNode(n, d.toXML(doc));
        } else {
            vector<ScheduleRules> scheduleRules = eventData.schedule().rules();
            for (auto& r : scheduleRules)
                XMLUtils::appendNode(n, r.toXML(doc));
        }
        //ScheduleData scheduleData = eventData.schedule();
        //XMLUtils::appendNode(n, scheduleData.toXML(doc));
    } else {
        QL_FAIL(":writeEventData(): unexpected ScriptedTradeEventData::Type");
    }
    return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addColumnToExisitingReport()

QuantLib::ext::shared_ptr< ore::data::InMemoryReport > addColumnToExisitingReport	(	const std::string &	columnName,
		const std::string &	value,
		const QuantLib::ext::shared_ptr< ore::data::InMemoryReport > &	report
	)

Adds a column to an existing InMemoryReport, the column value will be set to value for all existing rows Caution: This copies all existing values of the report and create a new one

Definition at line 29 of file utilities.cpp.

                                                                                       {
    QuantLib::ext::shared_ptr<ore::data::InMemoryReport> newReport =
        QuantLib::ext::make_shared<ore::data::InMemoryReport>();
    if (report != nullptr) {
        newReport->addColumn(columnName, string());
        for (size_t i = 0; i < report->columns(); i++) {
            newReport->addColumn(report->header(i), report->columnType(i), report->columnPrecision(i));
        }
        for (size_t row = 0; row < report->rows(); row++) {
            newReport->next();
            newReport->add(value);
            for (size_t col = 0; col < report->columns(); col++) {
                newReport->add(report->data(col)[row]);
            }
        }
        newReport->end();
    }
    return newReport;
}

◆ addColumnsToExisitingReport()

QuantLib::ext::shared_ptr< ore::data::InMemoryReport > addColumnsToExisitingReport	(	const QuantLib::ext::shared_ptr< ore::data::InMemoryReport > &	newColsReport,
		const QuantLib::ext::shared_ptr< ore::data::InMemoryReport > &	report
	)

Definition at line 51 of file utilities.cpp.

                                                                                        {
    QuantLib::ext::shared_ptr<ore::data::InMemoryReport> newReport =
        QuantLib::ext::make_shared<ore::data::InMemoryReport>();
    if (report != nullptr && newColsReport->rows() == 1) {
 
        for (size_t i = 0; i < newColsReport->columns(); ++i) {
            newReport->addColumn(newColsReport->header(i), newColsReport->columnType(i),
                                 newColsReport->columnPrecision(i));
        }
        for (size_t i = 0; i < report->columns(); i++) {
            newReport->addColumn(report->header(i), report->columnType(i), report->columnPrecision(i));
        }
        for (size_t row = 0; row < report->rows(); row++) {
            newReport->next();
            for (size_t i = 0; i < newColsReport->columns(); ++i) {
                newReport->add(newColsReport->data(i)[0]);
            }
            for (size_t col = 0; col < report->columns(); col++) {
                newReport->add(report->data(col)[row]);
            }
        }
        newReport->end();
    }
    return newReport;
}

◆ concatenateReports()

QuantLib::ext::shared_ptr< ore::data::InMemoryReport > concatenateReports ( const std::vector< QuantLib::ext::shared_ptr< ore::data::InMemoryReport > > & reports )

Definition at line 79 of file utilities.cpp.

                                                                                           {
    if (!reports.empty() && reports.front() != nullptr) {
        auto firstReport = reports.front();
        QuantLib::ext::shared_ptr<InMemoryReport> concatenatedReport =
            QuantLib::ext::make_shared<InMemoryReport>(*firstReport);
        for (size_t i = 1; i < reports.size(); i++) {
            if (reports[i] != nullptr) {
                concatenatedReport->add(*reports[i]);
            }
        }
        return concatenatedReport;
    }
    return nullptr;
}

◆ to_string() [1/4]

std::string to_string ( const LocationInfo & l )

Definition at line 28 of file ast.cpp.

                                           {
    if (l.initialised) {
        if (l.lineStart == l.lineEnd && l.columnStart <= l.columnEnd)
            return 'L' + std::to_string(l.lineStart) + ':' + std::to_string(l.columnStart) + ':' +
                   std::to_string(l.columnEnd - l.columnStart);
        else
            return 'L' + std::to_string(l.lineStart) + ':' + std::to_string(l.columnStart) + "-L" +
                   std::to_string(l.lineEnd) + ':' + std::to_string(l.columnEnd);
    } else
        return "L?";
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_string() [2/4]

std::string to_string	(	const ASTNodePtr	root,
		const bool	printLocationInfo
	)

Definition at line 157 of file astprinter.cpp.

                                                                         {
    ASTPrinter p(printLocationInfo);
    root->accept(p);
    return p.str();
}

Here is the call graph for this function:

◆ reset()

void reset ( const ASTNodePtr root )

Definition at line 44 of file astresetter.cpp.

                                  {
    ASTResetter r;
    root->accept(r);
}

Here is the caller graph for this function:

◆ to_script()

std::string to_script ( const ASTNodePtr root )

Definition at line 773 of file asttoscriptconverter.cpp.

                                           {
    ASTToScriptConverter p;
    root->accept(p);
    return p.script;
}

Here is the caller graph for this function:

◆ operator<<() [48/73]

std::ostream & operator<<	(	std::ostream &	out,
		const Context &	context
	)

Definition at line 51 of file context.cpp.

                                                                {
    constexpr Size wd1 = 30, wd2 = 10;
    for (auto const& v : context.scalars) {
        out << std::setw(wd1) << std::left << v.first;
        out << "(" << std::setw(wd2) << valueTypeLabels.at(v.second.which()) << ")";
        if (std::find(context.constants.begin(), context.constants.end(), v.first) != context.constants.end())
            out << "    const    ";
        else
            out << "             ";
        out << std::left << v.second << '\n';
    }
    for (auto const& v : context.arrays) {
        Size counter = 0;
        for (auto const& d : v.second) {
            out << std::setw(wd1) << std::left << (v.first + "[" + std::to_string(counter + 1) + "]");
            out << "(" << std::setw(wd2) << valueTypeLabels.at(d.which()) << ")";
            if (std::find(context.constants.begin(), context.constants.end(), v.first) != context.constants.end())
                out << "    const    ";
            else
                out << "             ";
            out << std::left << d << '\n';
            ++counter;
        }
    }
    return out;
}

◆ addModelParameter()

std::size_t addModelParameter	(	ComputationGraph &	g,
		std::vector< std::pair< std::size_t, std::function< double(void)> > > &	m,
		const std::string &	id,
		std::function< double(void)>	f
	)

Definition at line 480 of file modelcgimpl.cpp.

                                                                                {
    std::size_t n;
    if (n = g.variable(id, ComputationGraph::VarDoesntExist::Nan); n == ComputationGraph::nan) {
        n = cg_var(g, id, ComputationGraph::VarDoesntExist::Create);
        m.push_back(std::make_pair(n, f));
    }
    return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getSloppyDate()

Date getSloppyDate	(	const Date &	d,
		const bool	sloppyDates,
		const std::set< Date > &	dates
	)

Definition at line 490 of file modelcgimpl.cpp.

                                                                                     {
    if (!sloppyDates)
        return d;
    auto s = std::lower_bound(dates.begin(), dates.end(), d);
    if (s == dates.end())
        return *dates.rbegin();
    return *s;
}

Here is the caller graph for this function:

◆ generateRandomAST()

ASTNodePtr generateRandomAST	(	const Size	maxSequenceLength,
		const Size	maxDepth,
		const Size	seed
	)

Definition at line 616 of file randomastgenerator.cpp.

                                                                                                 {
    RandomASTGenerator gen(maxSequenceLength, maxDepth, seed);
    gen.createInstructionSequence();
    return gen.current;
}

Here is the caller graph for this function:

◆ operator<<() [49/73]

std::ostream & operator<<	(	std::ostream &	out,
		const ParserError &	error
	)

Definition at line 32 of file scriptparser.cpp.

                                                                  {
    if (!error.stoppedParsingAt.initialised) {
        out << "parsing succeeded";
    } else {
        out << "parsing stopped at " << to_string(error.stoppedParsingAt) << "\n";
        if (error.expectedWhere.initialised) {
            out << "expected " << error.expectedWhat << " in " << to_string(error.expectedWhere) << ":\n";
            out << error.scriptCurrentLine << "\n";
            out << std::string(std::max<Size>(error.expectedWhere.columnStart, 1) - 1, ' ') << "^--- here\n";
        } else {
            out << "remaining input is\n<<<<<<<<<<\n" << error.remainingInput << "\n>>>>>>>>>>\n";
        }
    }
    return out;
}

Here is the call graph for this function:

◆ printCodeContext()

std::string printCodeContext	(	std::string	script,
		const ASTNode *	loc,
		bool	compact
	)

Definition at line 76 of file scriptparser.cpp.

                                                                               {
 
    if (!loc)
        return "(script reference is not available)\n";
 
    // assume we have either newline or return, but not return alone (old mac csv format?)
    boost::replace_all(script, "\r", "");
 
    auto l = loc->locationInfo;
    if (l.lineEnd < l.lineStart || (l.lineEnd == l.lineStart && l.columnEnd <= l.columnStart))
        return "(script reference invalid: " + to_string(l) + ")\n";
 
    std::string res;
    // if compact is true, we remove leading/trailing symbols used for DLOGGERSTREAM for cleaner error message in log
    if (compact == false)
        res += "<<<<<<<<<<\n";
 
    Size pos = 0, currentLine = 1;
    for (Size line = l.lineStart; line <= l.lineEnd; ++line) {
        // look for the current line
        while (pos < script.size() && currentLine < line) {
            if (script[pos] == '\n')
                ++currentLine;
            ++pos;
        }
        if (pos == script.size())
            break;
        // look for the line end position in the current line
        Size posLineEnd = pos;
        while (posLineEnd < script.size() && script[posLineEnd] != '\n')
            ++posLineEnd;
        // add current line to the result
        std::string curr = std::string(std::next(script.begin(), pos), std::next(script.begin(), posLineEnd));
        if (compact) {
            boost::algorithm::trim(curr);
            res += curr + ' ';
        } else {
            res += curr + '\n';
        }
        // underline the relevant part of the current line
        Size columnStart = 1, columnEnd = posLineEnd - pos + 1;
        if (line == l.lineStart)
            columnStart = l.columnStart;
        if (line == l.lineEnd)
            columnEnd = l.columnEnd;
        if (columnEnd < columnStart)
            return "(script reference internal error: columnEnd (" + std::to_string(columnEnd) +
                   ") should be >= columnStart (" + std::to_string(columnStart) + "))";
        // adjust column start so that trailing spaces are not underlined
        while (columnStart < columnEnd && pos + columnStart < script.size() &&
               script[pos + std::max<Size>(columnStart, 1) - 1] == ' ')
            ++columnStart;
        if (compact == false)
            res +=
                std::string(std::max<Size>(columnStart, 1) - 1, ' ') + std::string(columnEnd - columnStart, '=') + '\n';
    }
 
    if (compact == false)
        res += ">>>>>>>>>>\n";
    return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ coarsenDateGrid()

std::vector< Date > coarsenDateGrid	(	const std::vector< Date > &	date,
		const std::string &	rule,
		const Date &	referenceDate = `Null< Date >()`
	)

coarsens given date grid starting at eval date using the given rule, which is of the form 3M(1W),1Y(1M),5Y(3M),10Y(1Y),50Y(5Y) the rough idea is out to 3M at least a 1W spacing is used, output 1Y a 1M spacing etc. for the exact algorithm that generates the coarsened grid, see the code

Definition at line 41 of file utilities.cpp.

                                                                                                                {
 
    // if rule is empty return original grid
 
    if (rule.empty())
        return dates;
 
    // get ref date and prepare result vector
 
    Date refDate = referenceDate == Null<Date>() ? Settings::instance().evaluationDate() : referenceDate;
 
    std::vector<Date> result;
 
    // parse the rule
 
    std::vector<std::pair<Period, Period>> grid;
    std::vector<std::string> tokens;
    boost::split(tokens, rule, boost::is_any_of(","));
    for (auto const& t : tokens) {
        std::vector<std::string> tmp;
        boost::split(tmp, t, boost::is_any_of("()"));
        QL_REQUIRE(tmp.size() == 3, "coarsenGrid: invalid rule token '" << t << "', expected e.g. '10Y(1M)'");
        grid.push_back(std::make_pair(parsePeriod(tmp[0]), parsePeriod(tmp[1])));
    }
 
    // keep all dates <= refDate
 
    auto d = dates.begin();
    for (; d != dates.end() && *d <= refDate; ++d) {
        result.push_back(*d);
    }
 
    // step through the rule grid...
 
    Date start = refDate;
    for (auto const& p : grid) {
        Date end = refDate + p.first;
 
        do {
 
            // look at subperiods defined by the second tenor in the rule
 
            start = std::min(end, start + p.second);
 
            // avoid too short stubs at the end
            if (static_cast<double>(end - start) / static_cast<double>(end - (end - p.second)) < 0.2)
                start = end;
 
            // for each subperiod keep at most one date, if there are several in the subperiod, keep the latest one
 
            std::vector<Date> candidates;
            while (d != dates.end() && *d <= start)
                candidates.push_back(*d++);
 
            if (!candidates.empty())
                result.push_back(candidates.back());
        } while (start < end);
 
        start = end;
    }
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getScript()

std::pair< std::string, ScriptedTradeScriptData > getScript	(	const ScriptedTrade &	scriptedTrade,
		const ScriptLibraryData &	scriptLibrary,
		const std::string &	purpose,
		const bool	fallBackOnEmptyPurpose
	)

get product tag + script, if a name is defined in the scriptTrade, get the script from the library, otherwise from the trade itself; use the give purpose and fall back on an empty purpose if specified

Definition at line 105 of file utilities.cpp.

                                                                                             {
    if (!scriptedTrade.scriptName().empty()) {
        DLOG("get script '" << scriptedTrade.scriptName() << "' for purpose '" << purpose
                            << "' (fallBackOnEmptyPurpose=" << std::boolalpha << fallBackOnEmptyPurpose
                            << ") from script library");
        return scriptLibrary.get(scriptedTrade.scriptName(), purpose, fallBackOnEmptyPurpose);
    } else {
        DLOG("get script for purpose '" << purpose << "' (fallBackOnEmptyPurpose=" << std::boolalpha
                                        << fallBackOnEmptyPurpose << ") from inline script in scripted trade");
        return std::make_pair(scriptedTrade.productTag(), scriptedTrade.script(purpose, fallBackOnEmptyPurpose));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parseScript()

ASTNodePtr parseScript ( const std::string & code )

parse script and return ast

Definition at line 121 of file utilities.cpp.

                                              {
    ScriptParser parser(code);
    DLOG("parsing script (size " << code.size() << ")");
    if (parser.success()) {
        DLOG("successfully parsed the script");
    } else {
        ALOG("an error occured during script parsing:");
        LOGGERSTREAM(parser.error());
        LOG("full script is:");
        LOG("<<<<<<<<<<");
        LOGGERSTREAM(code);
        LOG(">>>>>>>>>>");
        QL_FAIL("scripted trade could not be built due to parser errors, see log for more details.");
    }
    return parser.ast();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ convertIndexToCamCorrelationEntry()

std::pair< std::string, Period > convertIndexToCamCorrelationEntry ( const std::string & i )

convert a IR / FX / EQ index name to a correlation label that is understood by the cam builder; return the tenor of the index too (or 0*Days if not applicable)

Definition at line 138 of file utilities.cpp.

                                                                                 {
    IndexInfo info(i);
    if (info.isIr()) {
        return std::make_pair("IR#" + info.ir()->currency().code(), info.ir()->tenor());
    } else if (info.isInf()) {
        return std::make_pair("INF#" + info.infName(), 0 * Days);
    } else if (info.isFx()) {
        return std::make_pair("FX#" + info.fx()->sourceCurrency().code() + info.fx()->targetCurrency().code(),
                              0 * Days);
    } else if (info.isEq()) {
        return std::make_pair("EQ#" + info.eq()->name(), 0 * Days);
    } else if (info.isComm()) {
        return std::make_pair("COM#" + info.commName(), 0 * Days);
    } else {
        QL_FAIL("convertIndextoCamCorrelationEntry(): index '" << i << "' not recognised");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkDuplicateName()

void checkDuplicateName	(	const QuantLib::ext::shared_ptr< Context >	context,
		const std::string &	name
	)

check whether variable name is already present in given context, if yes throw an exception

Definition at line 156 of file utilities.cpp.

                                                                                             {
    auto scalar = context->scalars.find(name);
    auto array = context->arrays.find(name);
    QL_REQUIRE(scalar == context->scalars.end() && array == context->arrays.end(),
               "variable '" << name << "' already declared.");
}

Here is the caller graph for this function:

◆ makeContext()

QuantLib::ext::shared_ptr< Context > makeContext	(	const Size	nPaths,
		const std::string &	gridCoarsening,
		const std::vector< std::string > &	schedulesEligibleForCoarsening,
		const QuantLib::ext::shared_ptr< ReferenceDataManager > &	referenceData,
		const std::vector< ScriptedTradeEventData > &	events,
		const std::vector< ScriptedTradeValueTypeData > &	numbers,
		const std::vector< ScriptedTradeValueTypeData > &	indices,
		const std::vector< ScriptedTradeValueTypeData > &	currencies,
		const std::vector< ScriptedTradeValueTypeData > &	daycounters
	)

build a context from the given data and apply the given gridCoarsening rule, if required

Definition at line 163 of file utilities.cpp.

                                                                                                 {
 
    TLOG("make context");
 
    auto context = QuantLib::ext::make_shared<Context>();
 
 
    map<string, ScriptedTradeEventData> derivedSchedules;
    for (auto const& x : events) {
        TLOG("adding event " << x.name());
        if (x.type() == ScriptedTradeEventData::Type::Value) {
            checkDuplicateName(context, x.name());
            Date d = parseDate(x.value());
            context->scalars[x.name()] = EventVec{nPaths, d};
        } else if (x.type() == ScriptedTradeEventData::Type::Array) {
            checkDuplicateName(context, x.name());
            QuantLib::Schedule s;
            try {
                s = makeSchedule(x.schedule());
            } catch (const std::exception& e) {
                QL_FAIL("failed building schedule '" << x.name() << "': " << e.what());
            }
            std::vector<Date> c;
            if (std::find(schedulesEligibleForCoarsening.begin(), schedulesEligibleForCoarsening.end(), x.name()) !=
                schedulesEligibleForCoarsening.end()) {
                c = coarsenDateGrid(s.dates(), gridCoarsening);
                if (!gridCoarsening.empty()) {
                    TLOG("apply grid coarsening rule = " << gridCoarsening << " to '" << x.name()
                                                         << "', resulting grid:")
                    for (auto const& d : c) {
                        TLOG("date " << ore::data::to_string(d));
                    }
                }
            } else {
                c = s.dates();
            }
            std::vector<ValueType> tmp;
            for (auto const& d : c)
                tmp.push_back(EventVec{nPaths, d});
            context->arrays[x.name()] = tmp;
            QL_REQUIRE(!tmp.empty(), "empty event array '" << x.name() << "' not allowed");
        } else if (x.type() == ScriptedTradeEventData::Type::Derived) {
            derivedSchedules[x.name()] = x;
        } else {
            QL_FAIL("unexpected ScriptedTradeEventData::Type");
        }
        context->constants.insert(x.name());
    }
 
    bool calculated;
    while (derivedSchedules.size() > 0) {
        calculated = false;
        for (auto& ds : derivedSchedules) {
            auto base = context->arrays.find(ds.second.baseSchedule());
            checkDuplicateName(context, ds.second.name());
            if (base != context->arrays.end()) {
                try {
                    Calendar cal = parseCalendar(ds.second.calendar());
                    BusinessDayConvention conv = parseBusinessDayConvention(ds.second.convention());
                    Period shift = parsePeriod(ds.second.shift());
                    std::vector<ValueType> tmp;
                    for (auto const& d : base->second) {
                        QL_REQUIRE(d.which() == ValueTypeWhich::Event,
                                   "expected event in base schedule, got " << valueTypeLabels.at(d.which()));
                        EventVec e = QuantLib::ext::get<EventVec>(d);
                        tmp.push_back(EventVec{nPaths, cal.advance(e.value, shift, conv)});
                    }
                    context->arrays[ds.second.name()] = tmp;
                    derivedSchedules.erase(ds.second.name());
                    calculated = true;
                } catch (const std::exception& e) {
                    QL_FAIL("failed building derived schedule '" << ds.second.name() << "': " << e.what());
                }
                break;
            }
        }
 
        // If, after looping through the full list of derived schedules, we are unable to build any of them.
        if (!calculated) {
            for (const auto& ds : derivedSchedules) {
                ALOG("Failed to build the derived schedule: " << ds.first);
            }
            QL_FAIL("Failed to build at least one derived schedule");
            break;
        }
    }
 
    for (auto const& x : numbers) {
        TLOG("adding number " << x.name());
        checkDuplicateName(context, x.name());
        if (!x.isArray()) {
            double d = parseReal(x.value());
            context->scalars[x.name()] = RandomVariable(nPaths, d);
        } else {
            std::vector<ValueType> tmp;
            for (auto const& d : x.values())
                tmp.push_back(RandomVariable(nPaths, parseReal(d)));
            context->arrays[x.name()] = tmp;
            QL_REQUIRE(!tmp.empty(), "empty number array '" << x.name() << "' not allowed");
        }
        context->constants.insert(x.name());
    }
 
    for (auto const& x : indices) {
        TLOG("adding index " << x.name());
        checkDuplicateName(context, x.name());
        if (!x.isArray()) {
            context->scalars[x.name()] = IndexVec{nPaths, x.value()};
        } else {
            std::vector<ValueType> tmp;
            for (auto const& d : x.values())
                tmp.push_back(IndexVec{nPaths, d});
            context->arrays[x.name()] = tmp;
            QL_REQUIRE(!tmp.empty(), "empty index array '" << x.name() << "' not allowed");
        }
        context->constants.insert(x.name());
    }
 
    for (auto const& x : currencies) {
        TLOG("adding currency " << x.name());
        checkDuplicateName(context, x.name());
        if (!x.isArray()) {
            context->scalars[x.name()] = CurrencyVec{nPaths, x.value()};
        } else {
            std::vector<ValueType> tmp;
            for (auto const& d : x.values())
                tmp.push_back(CurrencyVec{nPaths, d});
            context->arrays[x.name()] = tmp;
            QL_REQUIRE(!tmp.empty(), "empty currency array '" << x.name() << "' not allowed");
        }
        context->constants.insert(x.name());
    }
 
    for (auto const& x : daycounters) {
        TLOG("adding daycounter " << x.name());
        checkDuplicateName(context, x.name());
        if (!x.isArray()) {
            context->scalars[x.name()] = DaycounterVec{nPaths, x.value()};
        } else {
            std::vector<ValueType> tmp;
            for (auto const& d : x.values())
                tmp.push_back(DaycounterVec{nPaths, d});
            context->arrays[x.name()] = tmp;
            QL_REQUIRE(!tmp.empty(), "empty currency array '" << x.name() << "' not allowed");
        }
        context->constants.insert(x.name());
    }
 
    DLOG("context built with " << context->scalars.size() << " scalars and " << context->arrays.size() << " arrays.");
    return context;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addNewSchedulesToContext()

void addNewSchedulesToContext	(	QuantLib::ext::shared_ptr< Context >	context,
		const std::vector< ScriptedTradeScriptData::NewScheduleData > &	newSchedules
	)

add new schedules (as specified in the script node) to schedules

Definition at line 322 of file utilities.cpp.

                                                                                                     {
    for (auto const& x : newSchedules) {
        DLOG("adding new schedule " << x.name());
        checkDuplicateName(context, x.name());
        std::vector<std::vector<ValueType>> sources;
        for (auto const& s : x.sourceSchedules()) {
            auto d = context->arrays.find(s);
            QL_REQUIRE(d != context->arrays.end(),
                       "ScriptedTradeGenericEngineBuilder::engineBuilder(): did not find source schedule '"
                           << s << "' when building new schedule '" << x.name() << "'");
            sources.push_back(d->second);
        }
        std::vector<ValueType> result;
        if (x.operation() == "Join") {
            std::set<QuantLib::Date> tmp;
            Size n = 0;
            for (auto const& s : sources) {
                for (auto const& d : s) {
                    tmp.insert(QuantLib::ext::get<EventVec>(d).value);
                    n = QuantLib::ext::get<EventVec>(d).size;
                }
            }
            for (auto const& d : tmp) {
                result.push_back(EventVec{n, d});
            }
            context->arrays[x.name()] = result;
            context->constants.insert(x.name());
        } else {
            QL_FAIL("new schedule operation '" << x.operation() << "' not supported");
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ amendContextVariablesSizes()

void amendContextVariablesSizes	(	QuantLib::ext::shared_ptr< Context >	context,
		const Size	newSize
	)

maend the variables sizes in a context to a new size, this is only possible for deterministic variables

Definition at line 379 of file utilities.cpp.

                                                                                            {
    SizeSetter setter(newSize);
    for (auto& x : context->scalars)
        boost::apply_visitor(setter, x.second);
    for (auto& v : context->arrays)
        for (auto& x : v.second)
            boost::apply_visitor(setter, x);
}

Here is the caller graph for this function:

◆ operator<<() [50/73]

std::ostream & operator<<	(	std::ostream &	o,
		const IndexInfo &	i
	)

Definition at line 484 of file utilities.cpp.

                                                          {
    o << "index '" << i.name() << "'";
    if (i.isFx())
        o << ", type FX, index name '" << i.fx()->name() << "'";
    if (i.isEq())
        o << ", type EQ, index name '" << i.eq()->name() << "'";
    if (i.isComm())
        o << ", type COMM";
    if (i.isIrIbor())
        o << ", type IR Ibor, index name '" << i.irIbor()->name() << "'";
    if (i.isIrSwap())
        o << ", type IR Swap, index name '" << i.irSwap()->name() << "'";
    if (i.isGeneric())
        o << ", type Generic, index name '" << i.generic()->name() << "'";
    return o;
}

Here is the call graph for this function:

◆ parseScriptedCommodityIndex()

QuantLib::ext::shared_ptr< QuantExt::CommodityIndex > parseScriptedCommodityIndex	(	const std::string &	indexName,
		const QuantLib::Date &	obsDate = `Date()`
	)

This method tries to parse an commodity index name used in the scripting context

0) COMM-name 1) COMM-name-YYYY-MM-DD

2) COMM-name-YYYY-MM

3) CMMM-name#N#D#Cal 4) COMM-name#N#D

5) COMM-name#N

6) COMM-name!N

Here 0) - 2) are corresponding to the usual ORE conventions while 3) - 6) are specific to the scripting module: Expressions of the form 3) - 5) are resolved to one of the forms 1) and 2) using a given commodity future expiry calculator as follows:

3) COMM-name#N#D#Cal is resolved to the (N+1)th future with expiry greater than the given obsDate advanced by D business days w.r.t. Calendar Cal, N >= 0 4) as 3), Cal is taken as the commodity index's fixing calendar 5) as 4), D is set to 0 if not given 6) COMM-name!N is resolved to the future with month / year equal to the obsDate and monthOffst = N, N >=0

Notice that the forms 1) and 2) can be parsed without an obsDate and a commodity future convention given. If no convention is given, the fixing calendar in the index is set to the NullCalendar. In case a commodity future convention is given for the name, the fixing calendar is set to the calendar from the convention.

TODO if the form is COMM-name-YYYY-MM, the day of month of the expiry date will be set to 01, consistently with the ORE index parser, even if a convention is present, that would allow us to determine the correct expiry date. Should we use that latter date in the returned index?

Forms 3) to 6) on the other hand require a commodity future convention in any case, and an obsDate.

Definition at line 530 of file utilities.cpp.

                                                                                                     {
 
    QL_REQUIRE(!indexName.empty(), "parseScriptedCommodityIndex(): empty index name");
    QuantLib::ext::shared_ptr<Conventions> conventions = InstrumentConventions::instance().conventions();
    std::vector<std::string> tokens;
    boost::split(tokens, indexName, boost::is_any_of("#!"));
    std::string plainIndexName = tokens.front();
    std::string commName = parseCommodityIndex(plainIndexName)->underlyingName();
 
    QuantLib::ext::shared_ptr<CommodityFutureConvention> convention;
    if (conventions->has(commName)) {
        convention = QuantLib::ext::dynamic_pointer_cast<CommodityFutureConvention>(conventions->get(commName));
    }
    Calendar fixingCalendar = convention ? convention->calendar() : NullCalendar();
 
    std::vector<std::string> tokens1;
    boost::split(tokens1, indexName, boost::is_any_of("#"));
    std::vector<std::string> tokens2;
    boost::split(tokens2, indexName, boost::is_any_of("!"));
 
    QuantLib::ext::shared_ptr<CommodityIndex> res;
    if (tokens1.size() >= 2) {
        // handle form 3)- 5), i.e. COMM-name#N#D#Cal, COMM-name#N#D, COMM-name#N
        QL_REQUIRE(tokens.size() <= 4,
                   "parseScriptedCommodityIndex(): expected COMM-Name#N, Comm-Name#N#D, Comm-Name#N#D#Cal, got '"
                       << indexName << "'");
        QL_REQUIRE(convention,
                   "parseScriptedCommodityIndex(): commodity future convention required for '" << indexName << "'");
        QL_REQUIRE(obsDate != Date(), "parseScriptedCommodityIndex(): obsDate required for '" << indexName << "'");
        int offset = std::stoi(tokens[1]);
        int deliveryRollDays = 0;
        if (tokens.size() >= 3)
            deliveryRollDays = parseInteger(tokens[2]);
        Calendar rollCal = tokens.size() == 4 ? parseCalendar(tokens[3]) : fixingCalendar;
        ConventionsBasedFutureExpiry expiryCalculator(*convention);
        Date adjustedObsDate = deliveryRollDays != 0 ? rollCal.advance(obsDate, deliveryRollDays * Days) : obsDate;
        res = parseCommodityIndex(commName, false, Handle<PriceTermStructure>(), fixingCalendar, true);
        res = res->clone(expiryCalculator.nextExpiry(true, adjustedObsDate, offset));
    } else if (tokens2.size() >= 2) {
        // handle form 6), i.e. COMM-name!N
        QL_REQUIRE(tokens.size() <= 2,
                   "parseScriptedCommodityIndex(): expected COMM-Name!N, got '" << indexName << "'");
        QL_REQUIRE(convention,
                   "parseScriptedCommodityIndex(): commodity future convention required for '" << indexName << "'");
        QL_REQUIRE(obsDate != Date(), "parseScriptedCommodityIndex(): obsDate required for '" << indexName << "'");
        int offset = std::stoi(tokens[1]);
        ConventionsBasedFutureExpiry expiryCalculator(*convention);
        res = parseCommodityIndex(commName, false, Handle<PriceTermStructure>(), fixingCalendar, true);
        res = res->clone(expiryCalculator.expiryDate(obsDate, offset));
    } else {
        // handle 0), 1) and 2)
        res = parseCommodityIndex(indexName, true, QuantLib::Handle<QuantExt::PriceTermStructure>(), fixingCalendar,
                                  false);
    }
 
    TLOG("parseScriptCommodityIndex(" << indexName << "," << QuantLib::io::iso_date(obsDate) << ") = " << res->name());
    return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parseScriptedInflationIndex()

std::pair< QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex >, std::string > parseScriptedInflationIndex ( const std::string & indexName )

This method tries to parse an inflation index name used in the scripting context

1) EUHICPXT 2) EUHICPXT::F 3) EUHICPXT::L

Here 1) is the original form used in ORE. This represents a non-interpolated index. 2,3) is the extended form including a flag indicating the interpolation F (flat, =1) or L (linear)

The function returns a ql inflation index accounting for the interpolation (but without ts attached), and the ORE index name without the #F, #L suffix.

Definition at line 593 of file utilities.cpp.

                                                        {
    QL_REQUIRE(!indexName.empty(), "parseScriptedInflationIndex(): empty index name");
    std::vector<std::string> tokens;
    boost::split(tokens, indexName, boost::is_any_of("#"));
    std::string plainIndexName = tokens.front();
    bool interpolated = false;
    if (tokens.size() == 1) {
        interpolated = false;
    } else if (tokens.size() == 2) {
        QL_REQUIRE(tokens[1] == "F" || tokens[1] == "L", "parseScriptedInflationIndex(): expected ...#[L|F], got ...#"
                                                             << tokens[1] << " in '" << indexName << "'");
        interpolated = tokens[1] == "L";
    } else {
        QL_FAIL("parseScriptedInflationIndex(): expected IndexName or IndexName#[F|L], got '" << indexName << "'");
    }
    return std::make_pair(
        parseZeroInflationIndex(plainIndexName, interpolated, Handle<ZeroInflationTermStructure>()),
        plainIndexName);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scriptedIndexName()

std::string scriptedIndexName ( const QuantLib::ext::shared_ptr< Underlying > & underlying )

Builds an index (EQ-SP5-EUR, FX-ECB-EUR-USD, ...) that can be used in scripted trades, from an underlying

Definition at line 614 of file utilities.cpp.

                                                                                 {
    if (underlying->type() == "Equity") {
        return "EQ-" + underlying->name();
    } else if (underlying->type() == "FX") {
        return "FX-" + underlying->name();
    } else if (underlying->type() == "Commodity") {
        QuantLib::ext::shared_ptr<CommodityUnderlying> comUnderlying =
            QuantLib::ext::dynamic_pointer_cast<CommodityUnderlying>(underlying);
        std::string tmp = "COMM-" + comUnderlying->name();
        if (comUnderlying->priceType().empty() || comUnderlying->priceType() == "Spot") {
            return tmp;
        } else if (comUnderlying->priceType() == "FutureSettlement") {
            tmp += "#" + std::to_string(comUnderlying->futureMonthOffset() == Null<Size>()
                                            ? 0
                                            : comUnderlying->futureMonthOffset());
            if (comUnderlying->deliveryRollDays() != Null<Size>()) {
                tmp += "#" + std::to_string(comUnderlying->deliveryRollDays());
                if (!comUnderlying->deliveryRollCalendar().empty()) {
                    tmp += "#" + comUnderlying->deliveryRollCalendar();
                }
            }
            return tmp;
        } else {
            QL_FAIL("underlying price type '" << comUnderlying->priceType() << "' for commodity underlying '"
                                              << comUnderlying->name() << "' not handled.");
        }
    } else if (underlying->type() == "InterestRate") {
        return underlying->name();
    } else if (underlying->type() == "Inflation") {
        QuantLib::ext::shared_ptr<InflationUnderlying> infUnderlying =
            QuantLib::ext::dynamic_pointer_cast<InflationUnderlying>(underlying);
        if (infUnderlying->interpolation() == QuantLib::CPI::InterpolationType::Linear)
            return underlying->name() + "#L";
        else if (infUnderlying->interpolation() == QuantLib::CPI::InterpolationType::Flat)
            return underlying->name() + "#F";
        else {
            QL_FAIL("observation interpolation " << infUnderlying->interpolation()
                                                 << " not covered in scripted inflation indexes");
        }
    } else if (underlying->type() == "Basic") {
        return underlying->name();
    } else {
        QL_FAIL("underlying type '" << underlying->type() << "' not handled.");
    }
}

Here is the caller graph for this function:

◆ getInflationSimulationLag()

Size getInflationSimulationLag ( const QuantLib::ext::shared_ptr< ZeroInflationIndex > & index )

Get inflation simulation lag in calendar days

Definition at line 660 of file utilities.cpp.

                                                                                       {
    // this is consistent with the lag computation in CrossAssetModel::infDki()
    Date d1 = index->zeroInflationTermStructure()->baseDate();
    Date d2 = index->zeroInflationTermStructure()->referenceDate();
    QL_DEPRECATED_DISABLE_WARNING
    if (!index->interpolated()) {
        d2 = inflationPeriod(d2, index->frequency()).first;
    }
    QL_DEPRECATED_ENABLE_WARNING
    return d2 - d1;
}

Here is the caller graph for this function:

◆ getCalibrationStrikes()

std::map< std::string, std::vector< Real > > getCalibrationStrikes	(	const std::vector< ScriptedTradeScriptData::CalibrationData > &	calibrationSpec,
		const QuantLib::ext::shared_ptr< Context > &	context
	)

Get map index => calibration strikes as vector<Real> from calibration spec and context

Definition at line 673 of file utilities.cpp.

                                                                     {
    std::map<std::string, std::vector<Real>> result;
    for (auto const& c : calibrationSpec) {
 
        std::vector<std::string> indexNames;
        // set up index
        auto index = context->scalars.find(c.index());
        if (index != context->scalars.end()) {
            QL_REQUIRE(index->second.which() == ValueTypeWhich::Index,
                "calibration index variable '" << c.index() << "' must evaluate to an index");
            std::string indexName = QuantLib::ext::get<IndexVec>(index->second).value;
            // replace fixing source tag in FX indices by GENERIC, since this is what is passed to the model
            // TODO FX indices might be reorganised vs. a base ccy != their original target ccy, is there anything
            // we can do to get an effective calibration at the specified deal strike?
            IndexInfo info(indexName);
            if (info.isFx())
                indexName =
                    "FX-GENERIC-" + info.fx()->sourceCurrency().code() + "-" + info.fx()->targetCurrency().code();            
            indexNames.push_back(indexName);
        } else {
            auto indexes = context->arrays.find(c.index());
            if (indexes != context->arrays.end()) {
                for (Size i = 0; i < indexes->second.size(); ++i) {
                    QL_REQUIRE(indexes->second[i].which() == ValueTypeWhich::Index,
                               "calibration strike variable '" << c.index() << "[" << i
                                                               << "]' must evaluate to an index");
                    auto indexName = QuantLib::ext::get<IndexVec>(indexes->second[i]).value;
                    IndexInfo info(indexName);
                    if (info.isFx())
                        indexName = "FX-GENERIC-" + info.fx()->sourceCurrency().code() + "-" +
                                    info.fx()->targetCurrency().code();
                    indexNames.push_back(indexName);
                }
            } else
                QL_FAIL("did not find calibration index variable '" << c.index()
                    << "' (as scalar or array) in context");
        }
        
        
        // loop over calibration strikes for index
        for (auto const& strikeStr : c.strikes()) {
            auto strike = context->scalars.find(strikeStr);
            if (strike != context->scalars.end()) {
                QL_REQUIRE(strike->second.which() == ValueTypeWhich::Number,
                            "calibration strike variable '" << strikeStr << "' must evaluate to a number");
                auto strikeNum = QuantLib::ext::get<RandomVariable>(strike->second);
                QL_REQUIRE(strikeNum.deterministic(), "calibration strike variable '"
                                                            << strikeStr << "' must be deterministic, got "
                                                            << strikeNum);
                QL_REQUIRE(indexNames.size() == 1, "Can only have one index if one strike provided");
                result[indexNames.at(0)].push_back(strikeNum.at(0));
                DLOG("add calibration strike for index '" << indexNames.at(0) << "': " << strikeNum.at(0));
            } else {
                auto strikeVec = context->arrays.find(strikeStr);
                if (strikeVec != context->arrays.end()) {
                    QL_REQUIRE(strikeVec->second.size() % indexNames.size() == 0, 
                        "StrikeVec must contain the same number of strikes for each index");
                    auto strikeSize = strikeVec->second.size() / indexNames.size();
                    Size ind = 0;
                    for (Size j = 0; j < indexNames.size(); j++) {
                        for (Size i = 0; i < strikeSize; ++i) {
                            QL_REQUIRE(strikeVec->second[ind].which() == ValueTypeWhich::Number,
                                        "calibration strike variable '" << strikeStr << "[" << i
                                                                        << "]' must evaluate to a number");
                            auto strikeNum = QuantLib::ext::get<RandomVariable>(strikeVec->second[ind]);
                            QL_REQUIRE(strikeNum.deterministic(), "calibration strike variable '"
                                                                    "calibration strike variable '"
                                                                        << strikeStr << "[" << i
                                                                        << "]' must be deterministic, got "
                                                                        << strikeNum);
                            result[indexNames[j]].push_back(strikeNum.at(0));
                            DLOG("add calibration strike for index '" << indexNames[j] << "' from : '" << strikeStr
                                                                        << "[" << i << "]'  " << strikeNum.at(0));
                            ind++;
                        }
                    }
                } else {
                    WLOG("getCalibrationStrikes: did not find calibration strike variable '" << strikeStr
                        << "' (as scalar or array) in context forcalibration index variable '" << c.index());
                }
            }
        }
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator<<() [51/73]

std::ostream & operator<<	(	std::ostream &	out,
		const EventVec &	a
	)

Definition at line 27 of file value.cpp.

                                                           {
    out << a.value;
    return out;
}

◆ operator<<() [52/73]

std::ostream & operator<<	(	std::ostream &	out,
		const CurrencyVec &	a
	)

Definition at line 32 of file value.cpp.

                                                              {
    out << a.value;
    return out;
}

◆ operator<<() [53/73]

std::ostream & operator<<	(	std::ostream &	out,
		const IndexVec &	a
	)

Definition at line 37 of file value.cpp.

                                                           {
    out << a.value;
    return out;
}

◆ operator<<() [54/73]

std::ostream & operator<<	(	std::ostream &	out,
		const DaycounterVec &	a
	)

Definition at line 42 of file value.cpp.

                                                                {
    out << a.value;
    return out;
}

◆ deterministic()

bool deterministic ( const ValueType & v )

Definition at line 144 of file value.cpp.

144{ return boost::apply_visitor(IsDet(), v); }

Here is the caller graph for this function:

◆ size()

Size size ( const ValueType & v )

Definition at line 145 of file value.cpp.

145{ return boost::apply_visitor(SizeGetter(), v); }

Here is the caller graph for this function:

◆ operator==() [9/13]

bool operator==	(	const EventVec &	a,
		const EventVec &	b
	)

Definition at line 147 of file value.cpp.

147{ return a.value == b.value && a.size == b.size; }

ore::data::EventVec::size

Size size

Definition: value.hpp:41

◆ operator==() [10/13]

bool operator==	(	const CurrencyVec &	a,
		const CurrencyVec &	b
	)

Definition at line 148 of file value.cpp.

148{ return a.value == b.value && a.size == b.size; }

ore::data::CurrencyVec::size

Size size

Definition: value.hpp:46

◆ operator==() [11/13]

bool operator==	(	const IndexVec &	a,
		const IndexVec &	b
	)

Definition at line 149 of file value.cpp.

149{ return a.value == b.value && a.size == b.size; }

ore::data::IndexVec::size

Size size

Definition: value.hpp:51

◆ operator==() [12/13]

bool operator==	(	const DaycounterVec &	a,
		const DaycounterVec &	b
	)

Definition at line 150 of file value.cpp.

150{ return a.value == b.value && a.size == b.size; }

ore::data::DaycounterVec::size

Size size

Definition: value.hpp:56

◆ operator+()

ValueType operator+	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 152 of file value.cpp.

                                                            {
    return boost::apply_visitor(
        BinaryOp([](const RandomVariable& x, const RandomVariable& y) -> RandomVariable { return x + y; }), x, y);
}

◆ operator-() [1/2]

ValueType operator-	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 157 of file value.cpp.

                                                            {
    return boost::apply_visitor(
        BinaryOp([](const RandomVariable& x, const RandomVariable& y) -> RandomVariable { return x - y; }), x, y);
}

◆ operator*()

ValueType operator*	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 162 of file value.cpp.

                                                            {
    return boost::apply_visitor(
        BinaryOp([](const RandomVariable& x, const RandomVariable& y) -> RandomVariable { return x * y; }), x, y);
}

◆ operator/()

ValueType operator/	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 167 of file value.cpp.

                                                            {
    return boost::apply_visitor(
        BinaryOp([](const RandomVariable& x, const RandomVariable& y) -> RandomVariable { return x / y; }), x, y);
}

◆ min() [1/2]

ValueType min	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 172 of file value.cpp.

                                                      {
    return boost::apply_visitor(
        BinaryOp([](const RandomVariable& x, const RandomVariable& y) -> RandomVariable { return min(x, y); }), x, y);
}

Here is the call graph for this function:

◆ max() [1/2]

ValueType max	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 177 of file value.cpp.

                                                      {
    return boost::apply_visitor(
        BinaryOp([](const RandomVariable& x, const RandomVariable& y) -> RandomVariable { return max(x, y); }), x, y);
}

Here is the call graph for this function:

◆ pow()

ValueType pow	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 182 of file value.cpp.

                                                      {
    return boost::apply_visitor(
        BinaryOp([](const RandomVariable& x, const RandomVariable& y) -> RandomVariable { return pow(x, y); }), x, y);
}

Here is the call graph for this function:

◆ operator-() [2/2]

ValueType operator- ( const ValueType & x )

Definition at line 187 of file value.cpp.

187{ return boost::apply_visitor(UnaryOp(std::negate<RandomVariable>()), x); }

◆ abs()

ValueType abs ( const ValueType & x )

Definition at line 189 of file value.cpp.

                                  {
    return boost::apply_visitor(UnaryOp([](const RandomVariable& x) -> RandomVariable { return abs(x); }), x);
}

Here is the call graph for this function:

◆ exp()

ValueType exp ( const ValueType & x )

Definition at line 193 of file value.cpp.

                                  {
    return boost::apply_visitor(UnaryOp([](const RandomVariable& x) -> RandomVariable { return exp(x); }), x);
}

Here is the call graph for this function:

◆ log()

ValueType log ( const ValueType & x )

Definition at line 197 of file value.cpp.

                                  {
    return boost::apply_visitor(UnaryOp([](const RandomVariable& x) -> RandomVariable { return log(x); }), x);
}

Here is the call graph for this function:

◆ sqrt()

ValueType sqrt ( const ValueType & x )

Definition at line 201 of file value.cpp.

                                   {
    return boost::apply_visitor(UnaryOp([](const RandomVariable& x) -> RandomVariable { return sqrt(x); }), x);
}

Here is the call graph for this function:

◆ normalCdf()

ValueType normalCdf ( const ValueType & x )

Definition at line 205 of file value.cpp.

                                        {
    return boost::apply_visitor(UnaryOp([](const RandomVariable& x) -> RandomVariable { return normalCdf(x); }), x);
}

Here is the call graph for this function:

◆ normalPdf()

ValueType normalPdf ( const ValueType & x )

Definition at line 209 of file value.cpp.

                                        {
    return boost::apply_visitor(UnaryOp([](const RandomVariable& x) -> RandomVariable { return normalPdf(x); }), x);
}

Here is the call graph for this function:

◆ typeSafeAssign()

ValueType typeSafeAssign	(	ValueType &	x,
		const ValueType &	y
	)

Definition at line 213 of file value.cpp.

213{ return boost::apply_visitor(Assignment(), x, y); }

Here is the caller graph for this function:

◆ equal()

Filter equal	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 215 of file value.cpp.

                                                     {
    return boost::apply_visitor(
        BinaryComp(
            [](const RandomVariable& x, const RandomVariable& y) -> Filter { return close_enough(x, y); },
            [](const EventVec& x, const EventVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size EventVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value == y.value);
            },
            [](const IndexVec& x, const IndexVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size IndexVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value == y.value);
            },
            [](const CurrencyVec& x, const CurrencyVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size CurrencyVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value == y.value);
            },
            [](const DaycounterVec& x, const DaycounterVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size DaycounterVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value == y.value);
            },
            [](const Filter& x, const Filter& y) -> Filter { return equal(x, y); }),
        x, y);
}

Here is the call graph for this function:

◆ notequal()

Filter notequal	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 239 of file value.cpp.

                                                        {
    return boost::apply_visitor(
        BinaryComp(
            [](const RandomVariable& x, const RandomVariable& y) -> Filter { return !close_enough(x, y); },
            [](const EventVec& x, const EventVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size EventVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value != y.value);
            },
            [](const IndexVec& x, const IndexVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size IndexVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value != y.value);
            },
            [](const CurrencyVec& x, const CurrencyVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size CurrencyVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value != y.value);
            },
            [](const DaycounterVec& x, const DaycounterVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size DaycounterVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value != y.value);
            },
            [](const Filter& x, const Filter& y) -> Filter { return !equal(x, y); }),
        x, y);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lt()

Filter lt	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 263 of file value.cpp.

                                                  {
    return boost::apply_visitor(
        BinaryComp(
            [](const RandomVariable& x, const RandomVariable& y) -> Filter { return x < y; },
            [](const EventVec& x, const EventVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size EventVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value < y.value);
            },
            [](const IndexVec& x, const IndexVec& y) -> Filter { QL_FAIL("invalid comparison lt for IndexVec"); },
            [](const CurrencyVec& x, const CurrencyVec& y) -> Filter {
                QL_FAIL("invalid comparison lt for CurrencyVec");
            },
            [](const DaycounterVec& x, const DaycounterVec& y) -> Filter {
                QL_FAIL("invalid comparison lt for DaycounterVec");
            },
            [](const Filter& x, const Filter& y) -> Filter { QL_FAIL("invalid comparison lt for Filter"); }),
        x, y);
}

Here is the caller graph for this function:

◆ gt()

Filter gt	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 282 of file value.cpp.

                                                  {
    return boost::apply_visitor(
        BinaryComp(
            [](const RandomVariable& x, const RandomVariable& y) -> Filter { return x > y; },
            [](const EventVec& x, const EventVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size EventVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value > y.value);
            },
            [](const IndexVec& x, const IndexVec& y) -> Filter { QL_FAIL("invalid comparison gt for IndexVec"); },
            [](const CurrencyVec& x, const CurrencyVec& y) -> Filter {
                QL_FAIL("invalid comparison gt for CurrencyVec");
            },
            [](const DaycounterVec& x, const DaycounterVec& y) -> Filter {
                QL_FAIL("invalid comparison gt for DaycounterVec");
            },
            [](const Filter& x, const Filter& y) -> Filter { QL_FAIL("invalid comparison gt for Filter"); }),
        x, y);
}

Here is the caller graph for this function:

◆ leq()

Filter leq	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 301 of file value.cpp.

                                                   {
    return boost::apply_visitor(
        BinaryComp(
            [](const RandomVariable& x, const RandomVariable& y) -> Filter { return x <= y; },
            [](const EventVec& x, const EventVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size EventVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value <= y.value);
            },
            [](const IndexVec& x, const IndexVec& y) -> Filter { QL_FAIL("invalid comparison leq for IndexVec"); },
            [](const CurrencyVec& x, const CurrencyVec& y) -> Filter {
                QL_FAIL("invalid comparison leq for CurrencyVec");
            },
            [](const DaycounterVec& x, const DaycounterVec& y) -> Filter {
                QL_FAIL("invalid comparison leq for DaycounterVec");
            },
            [](const Filter& x, const Filter& y) -> Filter { QL_FAIL("invalid comparison leq for Filter"); }),
 
        x, y);
}

Here is the caller graph for this function:

◆ geq()

Filter geq	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 321 of file value.cpp.

                                                   {
    return boost::apply_visitor(
        BinaryComp(
            [](const RandomVariable& x, const RandomVariable& y) -> Filter { return x >= y; },
            [](const EventVec& x, const EventVec& y) -> Filter {
                QL_REQUIRE(x.size == y.size, "inconsistent size EventVec (" << x.size << ", " << y.size << ")");
                return Filter(x.size, x.value >= y.value);
            },
            [](const IndexVec& x, const IndexVec& y) -> Filter { QL_FAIL("invalid comparison geq for IndexVec"); },
            [](const CurrencyVec& x, const CurrencyVec& y) -> Filter {
                QL_FAIL("invalid comparison geq for CurrencyVec");
            },
            [](const DaycounterVec& x, const DaycounterVec& y) -> Filter {
                QL_FAIL("invalid comparison geq for DaycounterVec");
            },
            [](const Filter& x, const Filter& y) -> Filter { QL_FAIL("invalid comparison geq for Filter"); }),
 
        x, y);
}

Here is the caller graph for this function:

◆ logicalNot()

Filter logicalNot ( const ValueType & x )

Definition at line 341 of file value.cpp.

                                      {
    return boost::apply_visitor(
        UnaryComp([](const RandomVariable& x) -> Filter { QL_FAIL("invalid logicalNot for RandomVariable"); },
                  [](const EventVec& x) -> Filter { QL_FAIL("invalid logicalNot for EventVec"); },
                  [](const IndexVec& x) -> Filter { QL_FAIL("invalid logicalNot for IndexVec"); },
                  [](const CurrencyVec& x) -> Filter { QL_FAIL("invalid logicalNot for CurrencyVec"); },
                  [](const DaycounterVec& x) -> Filter { QL_FAIL("invalid logicalNot for DaycounterVec"); },
                  [](const Filter& x) -> Filter { return !x; }),
        x);
}

◆ logicalAnd()

Filter logicalAnd	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 352 of file value.cpp.

                                                          {
    return boost::apply_visitor(
        BinaryComp(
            [](const RandomVariable& x, const RandomVariable& y) -> Filter {
                QL_FAIL("invalid logicalAnd for RandomVariable");
            },
            [](const EventVec& x, const EventVec& y) -> Filter { QL_FAIL("invalid logicalAnd for EventVec"); },
            [](const IndexVec& x, const IndexVec& y) -> Filter { QL_FAIL("invalid logicalAnd for IndexVec"); },
            [](const CurrencyVec& x, const CurrencyVec& y) -> Filter { QL_FAIL("invalid logicalAnd for CurrencyVec"); },
            [](const DaycounterVec& x, const DaycounterVec& y) -> Filter {
                QL_FAIL("invalid logicalAnd for DaycounterVec");
            },
            [](const Filter& x, const Filter& y) -> Filter { return x && y; }),
        x, y);
}

◆ logicalOr()

Filter logicalOr	(	const ValueType &	x,
		const ValueType &	y
	)

Definition at line 368 of file value.cpp.

                                                         {
    return boost::apply_visitor(
        BinaryComp(
            [](const RandomVariable& x, const RandomVariable& y) -> Filter {
                QL_FAIL("invalid logicalOr for RandomVariable");
            },
            [](const EventVec& x, const EventVec& y) -> Filter { QL_FAIL("invalid logicalOr for EventVec"); },
            [](const IndexVec& x, const IndexVec& y) -> Filter { QL_FAIL("invalid logicalOr for IndexVec"); },
            [](const CurrencyVec& x, const CurrencyVec& y) -> Filter { QL_FAIL("invalid logicalOr for CurrencyVec"); },
            [](const DaycounterVec& x, const DaycounterVec& y) -> Filter {
                QL_FAIL("invalid logicalOr for DaycounterVec");
            },
            [](const Filter& x, const Filter& y) -> Filter { return x || y; }),
        x, y);
}

◆ operator<() [14/14]

bool operator<	(	const CorrelationFactor &	lhs,
		const CorrelationFactor &	rhs
	)

Definition at line 42 of file correlationmatrix.cpp.

                                                                           {
    return tie(lhs.type, lhs.name, lhs.index) < tie(rhs.type, rhs.name, rhs.index);
}

◆ operator==() [13/13]

bool operator==	(	const CorrelationFactor &	lhs,
		const CorrelationFactor &	rhs
	)

Definition at line 46 of file correlationmatrix.cpp.

                                                                            {
    return lhs.type == rhs.type && lhs.name == rhs.name && lhs.index == rhs.index;
}

◆ operator!=() [4/4]

bool operator!=	(	const CorrelationFactor &	lhs,
		const CorrelationFactor &	rhs
	)

Definition at line 50 of file correlationmatrix.cpp.

                                                                            {
    return !(lhs == rhs);
}

◆ operator<<() [55/73]

std::ostream & operator<<	(	ostream &	out,
		const CorrelationFactor &	f
	)

Allow CorrelationFactors to be written.

Definition at line 54 of file correlationmatrix.cpp.

                                                              {
    return out << f.type << ":" << f.name << ":" << f.index;
}

◆ parseCorrelationFactor()

CorrelationFactor parseCorrelationFactor	(	const std::string &	name,
		const char	separator = `':'`
	)

Parse a correlation factor name. For example, a name like IR:EUR is parsed to a CorrelationFactor with type, name and index set to IR, EUR and 0 respectively. Note that the name is of the form type:name and the index is always set to 0 initially. The actual index is set separately.

Definition at line 58 of file correlationmatrix.cpp.

                                                                                   {
 
    std::string sep(1, separator);
    vector<string> tokens;
    boost::split(tokens, name, boost::is_any_of(sep));
 
    QL_REQUIRE(tokens.size() == 2 || tokens.size() == 3,
               "parseCorrelationFactor(" << name << "): expected 2 or 3 tokens separated by separator ('" << sep
                                         << "'), e.g. 'IR" << sep << "USD' or 'INF" << sep << "UKRPI" << sep << "0'");
 
    return {parseCamAssetType(tokens[0]), tokens[1],
            static_cast<Size>(tokens.size() == 3 ? parseInteger(tokens[3]) : 0)};
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ loadCurrencyHedgedIndexDecomposition() [1/2]

QuantLib::ext::shared_ptr< CurrencyHedgedEquityIndexDecomposition > loadCurrencyHedgedIndexDecomposition	(	const std::string &	name,
		const QuantLib::ext::shared_ptr< ReferenceDataManager > &	refDataMgr,
		const QuantLib::ext::shared_ptr< CurveConfigurations > &	curveConfigs
	)

Definition at line 16 of file currencyhedgedequityindexdecomposition.cpp.

                                                                                                     {
    QuantLib::ext::shared_ptr<CurrencyHedgedEquityIndexReferenceDatum> indexRefData;
    QuantLib::ext::shared_ptr<EquityIndexReferenceDatum> underlyingRefData;
    std::map<std::string, std::pair<double, std::string>> currencyWeightsAndFxIndexNames;
    
    if (refDataMgr) {
        if (refDataMgr->hasData("CurrencyHedgedEquityIndex", name))
            indexRefData = QuantLib::ext::dynamic_pointer_cast<CurrencyHedgedEquityIndexReferenceDatum>(
                refDataMgr->getData("CurrencyHedgedEquityIndex", name));
 
        if (indexRefData != nullptr && refDataMgr->hasData("EquityIndex", indexRefData->underlyingIndexName()))
            underlyingRefData = QuantLib::ext::dynamic_pointer_cast<EquityIndexReferenceDatum>(
                refDataMgr->getData("EquityIndex", indexRefData->underlyingIndexName()));
    }
 
    if (indexRefData == nullptr || underlyingRefData == nullptr) {
        return nullptr;
    }
 
    // Load currency Weights
    std::map<std::string, double> currencyWeights;
    std::string indexCurrency;
    std::string underlyingIndexCurrency;
    std::string fxIndexName;
    
    // Get currency hedged index currency
    if (curveConfigs && curveConfigs->hasEquityCurveConfig(indexRefData->id())) {
        indexCurrency = curveConfigs->equityCurveConfig(indexRefData->id())->currency();
    } else {
        WLOG("Can not find curveConfig for " << indexRefData->id() << " and can not determine the index currecy");
        return nullptr;
    }
 
    
    if (curveConfigs && curveConfigs->hasEquityCurveConfig(indexRefData->underlyingIndexName())) {
        
        // Get Fx Index to convert UnderlyingIndexCCY into HedgedIndexCurrency
        std::string underlyingIndexName = indexRefData->underlyingIndexName();
        underlyingIndexCurrency =
            curveConfigs->equityCurveConfig(indexRefData->underlyingIndexName())->currency();
        
        auto fxIndexIt = indexRefData->fxIndexes().find(underlyingIndexCurrency);
        if (fxIndexIt != indexRefData->fxIndexes().end()) {
            fxIndexName = fxIndexIt->second;
        } else {
            fxIndexName = "FX-GENERIC-" + indexCurrency + "-" + underlyingIndexCurrency;
        }
 
        // Load the currency weights at referenceDate for hedge notionals 
        QuantLib::Date refDate =
            CurrencyHedgedEquityIndexDecomposition::referenceDate(indexRefData, Settings::instance().evaluationDate());
        
        std::map<std::string, double> underlyingIndexWeightsAtRebalancing;
 
        if (indexRefData->currencyWeights().empty()) {
            QuantLib::ext::shared_ptr<ReferenceDatum> undIndexRefDataAtRefDate;
            try {
                undIndexRefDataAtRefDate = refDataMgr->getData("EquityIndex", underlyingIndexName, refDate);
            } catch (...) {
                // Try to load ref data, but don't throw on error
            }
            if (undIndexRefDataAtRefDate) {
                underlyingIndexWeightsAtRebalancing =
                    QuantLib::ext::dynamic_pointer_cast<EquityIndexReferenceDatum>(undIndexRefDataAtRefDate)->underlyings();
            }
        } else {
            underlyingIndexWeightsAtRebalancing = indexRefData->currencyWeights();
        }
        
        if (underlyingIndexWeightsAtRebalancing.empty()) {
            currencyWeights[underlyingIndexCurrency] = 1.0;
        } else {
            for (const auto& [name, weight] : underlyingIndexWeightsAtRebalancing) {
                // try look up currency in reference data and add if FX delta risk if necessary
                if (curveConfigs->hasEquityCurveConfig(name)) {
                    auto ecc = curveConfigs->equityCurveConfig(name);
                    auto eqCcy = ecc->currency();
                    currencyWeights[eqCcy] += weight;
                } else {
                    // Assume Index currency
                    currencyWeights[underlyingIndexCurrency] += weight;
                }
            }
        }
    }
 
    for (const auto& [currency, weight] : currencyWeights) {
        if (currency != indexCurrency) {
            auto defaultIndexIt = indexRefData->fxIndexes().find(currency);
            if (defaultIndexIt != indexRefData->fxIndexes().end()) {
                currencyWeightsAndFxIndexNames[currency] = std::make_pair(weight, defaultIndexIt->second);
            } else {
                currencyWeightsAndFxIndexNames[currency] =
                    std::make_pair(weight, "FX-GENERIC-" + indexCurrency + "-" + currency);
            }
        }
    }
    return QuantLib::ext::make_shared<CurrencyHedgedEquityIndexDecomposition>(name, indexRefData, underlyingRefData,
                                                                      indexCurrency, underlyingIndexCurrency,
                                                                      fxIndexName, currencyWeightsAndFxIndexNames);
}

Here is the call graph for this function:

◆ loadCurrencyHedgedIndexDecomposition() [2/2]

QuantLib::ext::shared_ptr< CurrencyHedgedEquityIndexDecomposition > loadCurrencyHedgedIndexDecomposition	(	const std::string &	name,
		const QuantLib::ext::shared_ptr< ore::data::ReferenceDataManager > &	refDataMgr,
		const QuantLib::ext::shared_ptr< ore::data::CurveConfigurations > &	curveConfigs
	)

◆ dataBuilders()

void dataBuilders ( )

Definition at line 219 of file databuilders.cpp.

                    {
 
    static boost::shared_mutex mutex;
    static bool hasRun = false;
 
    boost::unique_lock<boost::shared_mutex> lock(mutex);
 
    if (hasRun)
        return;
 
    hasRun = true;
 
    ORE_REGISTER_LEG_DATA("Cashflow", CashflowData, false)
    ORE_REGISTER_LEG_DATA("Fixed", FixedLegData, false)
    ORE_REGISTER_LEG_DATA("ZeroCouponFixed", ZeroCouponFixedLegData, false)
    ORE_REGISTER_LEG_DATA("Floating", FloatingLegData, false)
    ORE_REGISTER_LEG_DATA("CPI", CPILegData, false)
    ORE_REGISTER_LEG_DATA("YY", YoYLegData, false)
    ORE_REGISTER_LEG_DATA("CMS", CMSLegData, false)
    ORE_REGISTER_LEG_DATA("CMB", CMBLegData, false)
    ORE_REGISTER_LEG_DATA("DigitalCMS", DigitalCMSLegData, false)
    ORE_REGISTER_LEG_DATA("CMSSpread", CMSSpreadLegData, false)
    ORE_REGISTER_LEG_DATA("DigitalCMSSpread", DigitalCMSSpreadLegData, false)
    ORE_REGISTER_LEG_DATA("Equity", EquityLegData, false)
    ORE_REGISTER_LEG_DATA("CommodityFixed", CommodityFixedLegData, false)
    ORE_REGISTER_LEG_DATA("CommodityFloating", CommodityFloatingLegData, false)
    ORE_REGISTER_LEG_DATA("DurationAdjustedCMS", DurationAdjustedCmsLegData, false)
    ORE_REGISTER_LEG_DATA("EquityMargin", EquityMarginLegData, false)
    ORE_REGISTER_LEG_DATA("FormulaBased", FormulaBasedLegData, false)
 
    ORE_REGISTER_CALIBRATION_INSTRUMENT("CpiCapFloor", CpiCapFloor, false)
    ORE_REGISTER_CALIBRATION_INSTRUMENT("YoYCapFloor", YoYCapFloor, false)
    ORE_REGISTER_CALIBRATION_INSTRUMENT("YoYSwap", YoYSwap, false)
 
    ORE_REGISTER_REFERENCE_DATUM("Bond", BondReferenceDatum, false)
    ORE_REGISTER_REFERENCE_DATUM("CreditIndex", CreditIndexReferenceDatum, false)
    ORE_REGISTER_REFERENCE_DATUM("EquityIndex", EquityIndexReferenceDatum, false)
    ORE_REGISTER_REFERENCE_DATUM("CurrencyHedgedEquityIndex", CurrencyHedgedEquityIndexReferenceDatum, false)
    ORE_REGISTER_REFERENCE_DATUM("PortfolioBasket", PortfolioBasketReferenceDatum, false)
    ORE_REGISTER_REFERENCE_DATUM("CommodityIndex", CommodityIndexReferenceDatum, false)
    ORE_REGISTER_REFERENCE_DATUM("Credit", CreditReferenceDatum, false)
    ORE_REGISTER_REFERENCE_DATUM("Equity", EquityReferenceDatum, false)
    ORE_REGISTER_REFERENCE_DATUM("BondBasket", BondBasketReferenceDatum, false)
    ORE_REGISTER_REFERENCE_DATUM("ConvertibleBond", ConvertibleBondReferenceDatum, false)
    ORE_REGISTER_REFERENCE_DATUM("CBO", CboReferenceDatum, false)
 
    ORE_REGISTER_BOND_BUILDER("Bond", VanillaBondBuilder, false)
    ORE_REGISTER_BOND_BUILDER("ConvertibleBond", ConvertibleBondBuilder, false)
 
    ORE_REGISTER_TRADE_BUILDER("CrossCurrencySwap", CrossCurrencySwap, false)
    ORE_REGISTER_TRADE_BUILDER("CommoditySpreadOption", CommoditySpreadOption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityFutureOption", EquityFutureOption, false)
    ORE_REGISTER_TRADE_BUILDER("BondTRS", BondTRS, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityOption", CommodityOption, false)
    ORE_REGISTER_TRADE_BUILDER("CapFloor", CapFloor, false)
    ORE_REGISTER_TRADE_BUILDER("FxDigitalOption", FxDigitalOption, false)
    ORE_REGISTER_TRADE_BUILDER("CommoditySwaption", CommoditySwaption, false)
    ORE_REGISTER_TRADE_BUILDER("FxDigitalBarrierOption", FxDigitalBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("ForwardRateAgreement", ForwardRateAgreement, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityDigitalAveragePriceOption", CommodityDigitalAveragePriceOption, false)
    ORE_REGISTER_TRADE_BUILDER("CommoditySwap", CommoditySwap, false)
    ORE_REGISTER_TRADE_BUILDER("EquitySwap", EquitySwap, false)
    ORE_REGISTER_TRADE_BUILDER("FxForward", FxForward, false)
    ORE_REGISTER_TRADE_BUILDER("BondRepo", BondRepo, false)
    ORE_REGISTER_TRADE_BUILDER("FxAverageForward", FxAverageForward, false)
    ORE_REGISTER_TRADE_BUILDER("FxEuropeanBarrierOption", FxEuropeanBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("FxTouchOption", FxTouchOption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityAsianOption", EquityAsianOption, false)
    ORE_REGISTER_TRADE_BUILDER("FxAsianOption", FxAsianOption, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityAsianOption", CommodityAsianOption, false)
    ORE_REGISTER_TRADE_BUILDER("Swaption", Swaption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityVarianceSwap", EqVarSwap, false)
    ORE_REGISTER_TRADE_BUILDER("FxVarianceSwap", FxVarSwap, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityVarianceSwap", ComVarSwap, false)
    ORE_REGISTER_TRADE_BUILDER("FxDoubleTouchOption", FxDoubleTouchOption, false)
    ORE_REGISTER_TRADE_BUILDER("FxDoubleBarrierOption", FxDoubleBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityBarrierOption", EquityBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("FxSwap", FxSwap, false)
    ORE_REGISTER_TRADE_BUILDER("EquityTouchOption", EquityTouchOption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityDigitalOption", EquityDigitalOption, false)
    ORE_REGISTER_TRADE_BUILDER("CompositeTrade", CompositeTrade, false)
    ORE_REGISTER_TRADE_BUILDER("MultiLegOption", MultiLegOption, false)
    ORE_REGISTER_TRADE_BUILDER("Swap", Swap, false)
    ORE_REGISTER_TRADE_BUILDER("IndexCreditDefaultSwap", IndexCreditDefaultSwap, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityForward", CommodityForward, false)
    ORE_REGISTER_TRADE_BUILDER("EquityCliquetOption", EquityCliquetOption, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityDigitalOption", CommodityDigitalOption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityForward", EquityForward, false)
    ORE_REGISTER_TRADE_BUILDER("IndexCreditDefaultSwapOption", IndexCreditDefaultSwapOption, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityAveragePriceOption", CommodityAveragePriceOption, false)
    ORE_REGISTER_TRADE_BUILDER("CreditDefaultSwapOption", CreditDefaultSwapOption, false)
    ORE_REGISTER_TRADE_BUILDER("Failed", FailedTrade, false)
    ORE_REGISTER_TRADE_BUILDER("ForwardBond", ForwardBond, false)
    ORE_REGISTER_TRADE_BUILDER("EquityDoubleTouchOption", EquityDoubleTouchOption, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityOptionStrip", CommodityOptionStrip, false)
    ORE_REGISTER_TRADE_BUILDER("SyntheticCDO", SyntheticCDO, false)
    ORE_REGISTER_TRADE_BUILDER("Bond", Bond, false)
    ORE_REGISTER_TRADE_BUILDER("CreditLinkedSwap", CreditLinkedSwap, false)
    ORE_REGISTER_TRADE_BUILDER("EquityEuropeanBarrierOption", EquityEuropeanBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("InflationSwap", InflationSwap, false)
    ORE_REGISTER_TRADE_BUILDER("EquityDoubleBarrierOption", EquityDoubleBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("BondOption", BondOption, false)
    ORE_REGISTER_TRADE_BUILDER("CreditDefaultSwap", CreditDefaultSwap, false)
    ORE_REGISTER_TRADE_BUILDER("FxKIKOBarrierOption", FxKIKOBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("FxBarrierOption", FxBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityOption", EquityOption, false)
    ORE_REGISTER_TRADE_BUILDER("FxOption", FxOption, false)
    ORE_REGISTER_TRADE_BUILDER("CBO", CBO, false)
 
    ORE_REGISTER_TRADE_BUILDER("TotalReturnSwap", TRS, false)
    ORE_REGISTER_TRADE_BUILDER("ContractForDifference", CFD, false)
    ORE_REGISTER_TRADE_BUILDER("BondPosition", BondPosition, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityPosition", CommodityPosition, false)
    ORE_REGISTER_TRADE_BUILDER("EquityPosition", EquityPosition, false)
    ORE_REGISTER_TRADE_BUILDER("EquityOptionPosition", EquityOptionPosition, false)
    ORE_REGISTER_TRADE_BUILDER("Ascot", Ascot, false)
    ORE_REGISTER_TRADE_BUILDER("ConvertibleBond", ConvertibleBond, false)
 
    ORE_REGISTER_TRADE_BUILDER("ScriptedTrade", ScriptedTrade, false)
    ORE_REGISTER_TRADE_BUILDER("Autocallable_01", Autocallable_01, false)
    ORE_REGISTER_TRADE_BUILDER("EquityWindowBarrierOption", EquityWindowBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("FxWindowBarrierOption", FxWindowBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityWindowBarrierOption", CommodityWindowBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityRainbowOption", EquityRainbowOption, false)
    ORE_REGISTER_TRADE_BUILDER("FxRainbowOption", FxRainbowOption, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityRainbowOption", CommodityRainbowOption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityGenericBarrierOption", EquityGenericBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("FxGenericBarrierOption", FxGenericBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityGenericBarrierOption", CommodityGenericBarrierOption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityBestEntryOption", EquityBestEntryOption, false)
    ORE_REGISTER_TRADE_BUILDER("FxBestEntryOption", FxBestEntryOption, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityBestEntryOption", CommodityBestEntryOption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityAccumulator", EquityAccumulator, false)
    ORE_REGISTER_TRADE_BUILDER("FxAccumulator", FxAccumulator, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityAccumulator", CommodityAccumulator, false)
    ORE_REGISTER_TRADE_BUILDER("EquityBasketVarianceSwap", EquityBasketVarianceSwap, false)
    ORE_REGISTER_TRADE_BUILDER("FxBasketVarianceSwap", FxBasketVarianceSwap, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityBasketVarianceSwap", CommodityBasketVarianceSwap, false)
    ORE_REGISTER_TRADE_BUILDER("EquityTaRF", EquityTaRF, false)
    ORE_REGISTER_TRADE_BUILDER("FxTaRF", FxTaRF, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityTaRF", CommodityTaRF, false)
    ORE_REGISTER_TRADE_BUILDER("EquityWorstOfBasketSwap", EquityWorstOfBasketSwap, false)
    ORE_REGISTER_TRADE_BUILDER("FxWorstOfBasketSwap", FxWorstOfBasketSwap, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityWorstOfBasketSwap", CommodityWorstOfBasketSwap, false)
    ORE_REGISTER_TRADE_BUILDER("EquityBasketOption", EquityBasketOption, false)
    ORE_REGISTER_TRADE_BUILDER("FxBasketOption", FxBasketOption, false)
    ORE_REGISTER_TRADE_BUILDER("CommodityBasketOption", CommodityBasketOption, false)
    ORE_REGISTER_TRADE_BUILDER("EuropeanOptionBarrier", EuropeanOptionBarrier, false)
    ORE_REGISTER_TRADE_BUILDER("KnockOutSwap", KnockOutSwap, false)
    ORE_REGISTER_TRADE_BUILDER("DoubleDigitalOption", DoubleDigitalOption, false)
    ORE_REGISTER_TRADE_BUILDER("PerformanceOption_01", PerformanceOption_01, false)
    ORE_REGISTER_TRADE_BUILDER("RiskParticipationAgreement", RiskParticipationAgreement, false)
    ORE_REGISTER_TRADE_BUILDER("EquityOutperformanceOption", EquityOutperformanceOption, false)
    ORE_REGISTER_TRADE_BUILDER("EquityPairwiseVarianceSwap", EqPairwiseVarSwap, false)
    ORE_REGISTER_TRADE_BUILDER("FxPairwiseVarianceSwap", FxPairwiseVarSwap, false)
 
    ORE_REGISTER_TRADE_BUILDER("BalanceGuaranteedSwap", BalanceGuaranteedSwap, false)
    ORE_REGISTER_TRADE_BUILDER("CallableSwap", CallableSwap, false)
    ORE_REGISTER_TRADE_BUILDER("FlexiSwap", FlexiSwap, false)
 
    ORE_REGISTER_LEGBUILDER("CommodityFixedLegBuilder", CommodityFixedLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("CommodityFloatingLegBuilder", CommodityFloatingLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("DurationAdjustedCmsLegBuilder", DurationAdjustedCmsLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("FixedLegBuilder", FixedLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("ZeroCouponFixedLegBuilder", ZeroCouponFixedLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("FloatingLegBuilder", FloatingLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("CashflowLegBuilder", CashflowLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("CPILegBuilder", CPILegBuilder, false)
    ORE_REGISTER_LEGBUILDER("YYLegBuilder", YYLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("CMSLegBuilder", CMSLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("CMBLegBuilder", CMBLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("DigitalCMSLegBuilder", DigitalCMSLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("CMSSpreadLegBuilder", CMSSpreadLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("DigitalCMSSpreadLegBuilder", DigitalCMSSpreadLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("EquityLegBuilder", EquityLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("EquityMarginLegBuilder", EquityMarginLegBuilder, false)
    ORE_REGISTER_LEGBUILDER("FormulaBasedLegBuilder", FormulaBasedLegBuilder, false)
 
    ORE_REGISTER_AMC_ENGINE_BUILDER(CamAmcCurrencySwapEngineBuilder, false)
    ORE_REGISTER_AMC_ENGINE_BUILDER(LGMAmcSwaptionEngineBuilder, false)
    ORE_REGISTER_AMC_ENGINE_BUILDER(CamAmcSwapEngineBuilder, false)
    ORE_REGISTER_AMC_ENGINE_BUILDER(CamAmcFxOptionEngineBuilder, false)
    ORE_REGISTER_AMC_ENGINE_BUILDER(CamAmcFxForwardEngineBuilder, false)
    ORE_REGISTER_AMC_ENGINE_BUILDER(CamAmcMultiLegOptionEngineBuilder, false)
    ORE_REGISTER_AMC_ENGINE_BUILDER(ScriptedTradeEngineBuilder, false)
 
    ORE_REGISTER_AMCCG_ENGINE_BUILDER(ScriptedTradeEngineBuilder, false)
 
    ORE_REGISTER_ENGINE_BUILDER(CommoditySpreadOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CpiCapFloorEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityFutureEuropeanOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(DiscountingBondTRSEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityEuropeanAsianOptionMCDAAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityEuropeanAsianOptionMCDAASEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityEuropeanAsianOptionMCDGAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityEuropeanAsianOptionADGAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityEuropeanAsianOptionADGASEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityEuropeanAsianOptionACGAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityEuropeanAsianOptionTWEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityEuropeanOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityEuropeanForwardOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityEuropeanCSOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityAmericanOptionFDEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityAmericanOptionBAWEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CapFloorEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxDigitalOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxDigitalCSOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommoditySwaptionAnalyticalEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommoditySwaptionMonteCarloEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxDigitalBarrierOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommoditySwapEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityEuropeanCompositeEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxForwardEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(DiscountingBondRepoEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(AccrualBondRepoEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CapFlooredOvernightIndexedCouponLegEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CapFlooredCpiLegCouponEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CapFlooredCpiLegCashFlowEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxTouchOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EuropeanSwaptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(LGMGridSwaptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(LGMFDSwaptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(LGMMCSwaptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(VarSwapEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxDoubleTouchOptionAnalyticEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxDoubleBarrierOptionAnalyticEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityBarrierOptionAnalyticEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityBarrierOptionFDEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityTouchOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CapFlooredYoYLegEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityDigitalOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxEuropeanAsianOptionMCDAAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxEuropeanAsianOptionMCDAASEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxEuropeanAsianOptionMCDGAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxEuropeanAsianOptionADGAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxEuropeanAsianOptionADGASEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxEuropeanAsianOptionACGAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxEuropeanAsianOptionTWEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(SwapEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(SwapEngineBuilderOptimised, false)
    ORE_REGISTER_ENGINE_BUILDER(CrossCurrencySwapEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(MidPointIndexCdsEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(MidPointCdsMultiStateEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityForwardEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityEuropeanAsianOptionMCDAAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityEuropeanAsianOptionMCDAASEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityEuropeanAsianOptionMCDGAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityEuropeanAsianOptionADGAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityEuropeanAsianOptionADGASEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityEuropeanAsianOptionACGAPEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityEuropeanAsianOptionTWEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CmsSpreadCouponPricerBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(AnalyticHaganCmsCouponPricerBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(NumericalHaganCmsCouponPricerBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(LinearTSRCmsCouponPricerBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityForwardEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(BlackIndexCdsOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(NumericalIntegrationIndexCdsOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityApoAnalyticalEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CommodityApoMonteCarloEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(BlackCdsOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(YoYCapFloorEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CapFlooredAverageBMACouponLegEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CapFlooredAverageONIndexedCouponLegEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(DiscountingForwardBondEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityDoubleTouchOptionAnalyticEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CapFlooredIborLegEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(LinearTsrDurationAdjustedCmsCouponPricerBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(GaussCopulaBucketingCdoEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(BondDiscountingEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(BondMultiStateDiscountingEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CreditLinkedSwapEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityDoubleBarrierOptionAnalyticEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(BondOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(MidPointCdsEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxBarrierOptionAnalyticEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxBarrierOptionFDEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityEuropeanOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityEuropeanCSOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityAmericanOptionFDEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityAmericanOptionBAWEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CapFlooredNonStandardYoYLegEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(QuantoEquityEuropeanOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxEuropeanOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxEuropeanCSOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxAmericanOptionFDEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FxAmericanOptionBAWEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(AscotIntrinsicEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(ConvertibleBondFDDefaultableEquityJumpDiffusionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CboMCEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(CamMcMultiLegOptionEngineBuilder, false)
 
    ORE_REGISTER_ENGINE_BUILDER(ScriptedTradeEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(AsianOptionScriptedEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(RiskParticipationAgreementBlackEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(RiskParticipationAgreementXCcyBlackEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(RiskParticipationAgreementSwapLGMGridEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(RiskParticipationAgreementTLockLGMGridEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityCliquetOptionMcScriptEngineBuilder, false)
 
    ORE_REGISTER_ENGINE_BUILDER(FormulaBasedCouponPricerBuilder, false)
 
    ORE_REGISTER_ENGINE_BUILDER(SwapEngineBuilderDeltaGamma, false)
    ORE_REGISTER_ENGINE_BUILDER(CurrencySwapEngineBuilderDeltaGamma, false)
    ORE_REGISTER_ENGINE_BUILDER(FxEuropeanOptionEngineBuilderDeltaGamma, false)
    ORE_REGISTER_ENGINE_BUILDER(EquityEuropeanOptionEngineBuilderDeltaGamma, false)
    ORE_REGISTER_ENGINE_BUILDER(FxForwardEngineBuilderDeltaGamma, false)
 
    ORE_REGISTER_ENGINE_BUILDER(EquityOutperformanceOptionEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(PairwiseVarSwapEngineBuilder, false)
 
    ORE_REGISTER_ENGINE_BUILDER(FlexiSwapDiscountingEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(FlexiSwapLGMGridEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(BalanceGuaranteedSwapDiscountingEngineBuilder, false)
    ORE_REGISTER_ENGINE_BUILDER(BalanceGuaranteedSwapFlexiSwapLGMGridEngineBuilder, false)
 
    ORE_REGISTER_TRS_UNDERLYING_BUILDER("Bond", BondTrsUnderlyingBuilder, false)
    ORE_REGISTER_TRS_UNDERLYING_BUILDER("ForwardBond", ForwardBondTrsUnderlyingBuilder, false)
    ORE_REGISTER_TRS_UNDERLYING_BUILDER("EquityPosition", EquityPositionTrsUnderlyingBuilder, false)
    ORE_REGISTER_TRS_UNDERLYING_BUILDER("CommodityPosition", CommodityPositionTrsUnderlyingBuilder, false)
    ORE_REGISTER_TRS_UNDERLYING_BUILDER("EquityOptionPosition", EquityOptionPositionTrsUnderlyingBuilder, false)
    ORE_REGISTER_TRS_UNDERLYING_BUILDER("BondPosition", BondPositionTrsUnderlyingBuilder, false)
    ORE_REGISTER_TRS_UNDERLYING_BUILDER("Derivative", DerivativeTrsUnderlyingBuilder, false)
    ORE_REGISTER_TRS_UNDERLYING_BUILDER("ConvertibleBond", ConvertibleBondTrsUnderlyingBuilder, false)
    ORE_REGISTER_TRS_UNDERLYING_BUILDER("CBO", CBOTrsUnderlyingBuilder, false)
 
    ORE_REGISTER_COMPUTE_FRAMEWORK_CREATOR("OpenCL", QuantExt::OpenClFramework, false);
    ORE_REGISTER_COMPUTE_FRAMEWORK_CREATOR("BasicCpu", QuantExt::BasicCpuFramework, false);
}

◆ generateShiftedDateGrid()

QuantLib::ext::shared_ptr< DateGrid > generateShiftedDateGrid	(	const QuantLib::ext::shared_ptr< DateGrid > &	dg,
		const QuantLib::Period &	shift
	)

Definition at line 312 of file dategrid.cpp.

                                                                                 {
    DLOG("Building shifted date grid with shift of " << shift);
    vector<Date> defaultDates = dg->dates();
    vector<Date> closeOutDates;
    for (auto d : defaultDates) {
        Date closeOut = dg->calendar().adjust(d + shift);
        closeOutDates.push_back(closeOut);
    }
    QuantLib::ext::shared_ptr<DateGrid> newDg = QuantLib::ext::make_shared<DateGrid>(closeOutDates, dg->calendar(), dg->dayCounter());
    return newDg;
}

◆ combineDateGrids()

QuantLib::ext::shared_ptr< DateGrid > combineDateGrids	(	const QuantLib::ext::shared_ptr< DateGrid > &	dg1,
		const QuantLib::ext::shared_ptr< DateGrid > &	dg2
	)

Definition at line 325 of file dategrid.cpp.

                                                                                         {
    DLOG("Combining date grids");
    vector<Date> combinedVec;
    vector<Date> dates1 = dg1->dates();
    vector<Date> dates2 = dg2->dates();
    combinedVec.reserve(dates1.size() + dates2.size());
    combinedVec.insert(combinedVec.end(), dates1.begin(), dates1.end());
    combinedVec.insert(combinedVec.end(), dates2.begin(), dates2.end());
    std::sort(combinedVec.begin(), combinedVec.end());
    auto last = std::unique(combinedVec.begin(), combinedVec.end());
    combinedVec.erase(last, combinedVec.end());
    // FIXME: Check that grid calendars and day counters match?
    QuantLib::ext::shared_ptr<DateGrid> newDg = QuantLib::ext::make_shared<DateGrid>(combinedVec, dg1->calendar(), dg1->dayCounter());
    return newDg;
}

◆ parseFormula() [1/2]

QuantExt::CompiledFormula parseFormula	(	const std::string &	text,
		std::vector< std::string > &	variables
	)

parse formula and store it as a CompiledFormula instance, the variables vector contains the label of the variables for each index

Definition at line 24 of file formulaparser.cpp.

                                                                                             {
    variables.clear();
    auto mapping = [&variables](const std::string& s) {
        auto it = std::find(variables.begin(), variables.end(), s);
        if (it != variables.end()) {
            return QuantExt::CompiledFormula(QuantLib::Size(it - variables.begin()));
        } else {
            variables.push_back(s);
            return QuantExt::CompiledFormula(QuantLib::Size(variables.size() - 1));
        }
    };
    return parseFormula<QuantExt::CompiledFormula>(text, mapping);
} // parseFormula

Here is the caller graph for this function:

◆ parseFormula() [2/2]

T parseFormula	(	const std::string &	text,
		const std::function< T(std::string)> &	variableMapping = `{}`
	)

evaluate arithmetic expression, T must provide operators T+T, T-T, -T, T*T, T/T, abs(T), exp(T), gtZero(T), geqZero(T), log(T), max(T,T), min(T,T), pow(T,T) variables are written as "{variable}"

Definition at line 62 of file formulaparser.hpp.

                                                                                                           {
 
    namespace fusion = boost::fusion;
    namespace phoenix = boost::phoenix;
    namespace qi = boost::spirit::qi;
    namespace ascii = boost::spirit::ascii;
 
    typedef std::string::const_iterator Iterator;
 
    using ascii::alnum;
    using ascii::char_;
    using ascii::space;
    using qi::double_;
    using qi::lexeme;
    using qi::lit;
    using namespace qi::labels;
 
    qi::rule<Iterator, std::string(), ascii::space_type> variable;
    qi::rule<Iterator, ascii::space_type> factor;
    qi::rule<Iterator, ascii::space_type> term;
    qi::rule<Iterator, ascii::space_type> expression;
 
    std::stack<T> evalStack;
 
    auto pushConstant = [&evalStack](const double x) { evalStack.push(T(x)); };
    auto pushVariable = [&variableMapping, &evalStack, &text](const std::string& s) {
        QL_REQUIRE(variableMapping, "parseFormula(" << text << "): could not resolve variable \"" << s
                                                    << "\", because no variable mapping is given");
        evalStack.push(variableMapping(s));
    };
 
    struct doUnaryOp {
        doUnaryOp(std::stack<T>& evalStack, const std::function<T(T)>& op) : evalStack_(evalStack), op_(op) {}
        void operator()() const {
            QL_REQUIRE(evalStack_.size() > 0, "parseFormula(): internal error, empty stack for unary operation");
            T x = evalStack_.top();
            evalStack_.pop();
            T y = op_(x);
            evalStack_.push(y);
        }
        std::stack<T>& evalStack_;
        const std::function<T(T)> op_;
    };
 
    struct doBinaryOp {
        doBinaryOp(std::stack<T>& evalStack, const std::function<T(T, T)>& op) : evalStack_(evalStack), op_(op) {}
        void operator()() const {
            QL_REQUIRE(evalStack_.size() > 1,
                       "parseFormula(): internal error, stack size too small for binary operation");
            T rhs = evalStack_.top();
            evalStack_.pop();
            T lhs = evalStack_.top();
            evalStack_.pop();
            evalStack_.push(op_(lhs, rhs));
        }
        std::stack<T>& evalStack_;
        const std::function<T(T, T)> op_;
    };
 
    auto doNegate = doUnaryOp(evalStack, [](const T& x) { return -x; });
    auto doAbs = doUnaryOp(evalStack, [](const T& x) { return abs(x); });
    auto doGtZero = doUnaryOp(evalStack, [](const T& x) { return gtZero(x); });
    auto doGeqZero = doUnaryOp(evalStack, [](const T& x) { return geqZero(x); });
    auto doExp = doUnaryOp(evalStack, [](const T& x) { return exp(x); });
    auto doLog = doUnaryOp(evalStack, [](const T& x) { return log(x); });
    //
    auto doMultiply = doBinaryOp(evalStack, [](const T& x, const T& y) { return x * y; });
    auto doDivide = doBinaryOp(evalStack, [](const T& x, const T& y) { return x / y; });
    auto doPlus = doBinaryOp(evalStack, [](const T& x, const T& y) { return x + y; });
    auto doMinus = doBinaryOp(evalStack, [](const T& x, const T& y) { return x - y; });
    auto doMax = doBinaryOp(evalStack, [](const T& x, const T& y) { return max(x, y); });
    auto doMin = doBinaryOp(evalStack, [](const T& x, const T& y) { return min(x, y); });
    auto doPow = doBinaryOp(evalStack, [](const T& x, const T& y) { return pow(x, y); });
 
    // clang-format off
 
    variable      = '{' >> lexeme[+(char_ - '}') [_val += qi::labels::_1] ] >> '}';
    factor        =    double_    [ pushConstant ]
                     | variable   [ pushVariable ]
                     | '(' >> expression >> ')'
                     | '-' >> factor [ doNegate ]
                     | lit("abs(") >> expression [ doAbs ] >> ')'
                     | lit("exp(") >> expression [ doExp ] >> ')'
                     | lit("gtZero(") >> expression [ doGtZero ] >> ')'
                     | lit("geqZero(") >> expression [ doGeqZero ] >> ')'
                     | lit("log(") >> expression [ doLog ] >> ')'
                     | lit("max(") >> expression >> ',' >> expression [ doMax ] >> ')'
                     | lit("min(") >> expression >> ',' >> expression [ doMin ] >> ')'
                     | lit("pow(") >> expression >> ',' >> expression [ doPow ] >> ')';
    term          =     factor >> *(   ('*' >> factor) [ doMultiply ]
                                     | ('/' >> factor) [ doDivide ] );
    expression    =     term >> *(     ('+' >> term) [ doPlus ]
                                     | ('-' >> term) [ doMinus ]);
 
    // clang-format on
 
    std::string::const_iterator iter = text.begin();
    std::string::const_iterator end = text.end();
    bool r = phrase_parse(iter, end, expression, space);
 
    if (r && iter == end) {
        return evalStack.top();
    } else {
        std::string::const_iterator some = iter + 30;
        std::string context(iter, (some > end) ? end : some);
        QL_FAIL("parseFormula(" << text << "): parsing failed, stopped at \"" + context + "...\"");
    }
    return evalStack.top();
}

Here is the call graph for this function:

◆ gtZero()

double gtZero ( const double x )

Definition at line 54 of file formulaparser.hpp.

54{ return x > 0.0 && !QuantLib::close_enough(x, 0.0) ? 1.0 : 0.0; }

Here is the caller graph for this function:

◆ geqZero()

double geqZero ( const double x )

Definition at line 55 of file formulaparser.hpp.

55{ return x > 0.0 || QuantLib::close_enough(x, 0.0) ? 1.0 : 0.0; }

Here is the caller graph for this function:

◆ max() [2/2]

double max	(	const double	x,
		const double	y
	)

Definition at line 56 of file formulaparser.hpp.

56{ return std::max(x, y); }

Here is the call graph for this function:

◆ min() [2/2]

double min	(	const double	x,
		const double	y
	)

Definition at line 57 of file formulaparser.hpp.

57{ return std::min(x, y); }

◆ checkOneToOne()

void checkOneToOne	(	const map< string, QuantLib::ext::shared_ptr< OvernightIndex > > &	onIndices,
		const map< string, QuantLib::ext::shared_ptr< IborIndexParser > > &	iborIndices
	)

Definition at line 191 of file indexparser.cpp.

                                                                                           {
 
    // Should not attempt to add the same family name to the set if the provided mappings are one to one
    set<string> familyNames;
 
    for (const auto& kv : onIndices) {
        auto p = familyNames.insert(kv.second->familyName());
        QL_REQUIRE(p.second, "Duplicate mapping for overnight index family " << *p.first << " not allowed");
    }
 
    for (const auto& kv : iborIndices) {
        auto p = familyNames.insert(kv.second->family());
        QL_REQUIRE(p.second, "Duplicate mapping for ibor index family " << *p.first << " not allowed");
    }
}

Here is the caller graph for this function:

◆ parseIborIndex()

QuantLib::ext::shared_ptr< IborIndex > parseIborIndex	(	const string &	s,
		string &	tenor,
		const Handle< YieldTermStructure > &	h
	)

Definition at line 259 of file indexparser.cpp.

                                                                                                                     {
 
    // Check the index string is of the required form before doing anything
    vector<string> tokens;
    split(tokens, s, boost::is_any_of("-"));
    QL_REQUIRE(tokens.size() == 2 || tokens.size() == 3,
               "Two or three tokens required in " << s << ": CCY-INDEX or CCY-INDEX-TERM");
 
    // Variables used below
    string indexStem = tokens[0] + "-" + tokens[1];
    if (tokens.size() == 3) {
        tenor = tokens[2];
    } else {
        tenor = "";
    }
 
    const QuantLib::ext::shared_ptr<Conventions>& conventions = InstrumentConventions::instance().conventions();
    QuantLib::ext::shared_ptr<Convention> c;
    if (conventions->has(s, Convention::Type::IborIndex) || conventions->has(s, Convention::Type::OvernightIndex))
        c = conventions->get(s); 
 
    // if we have a convention given, set up the index using this convention, this overrides the parsing from
    // hardcoded strings below if there is an overlap
    if (c) {
        QL_REQUIRE(c->id() == s, "ibor index convention id ('"
                                     << c->id() << "') not matching ibor index string to parse ('" << s << "'");
        Currency ccy = parseCurrency(tokens[0]);
        if (auto conv = QuantLib::ext::dynamic_pointer_cast<OvernightIndexConvention>(c)) {
            QL_REQUIRE(tenor.empty(), "no tenor allowed for convention based overnight index ('" << s << "')");
            auto res = QuantLib::ext::make_shared<OvernightIndex>(tokens[0] + "-" + tokens[1], conv->settlementDays(), ccy,
                                                      parseCalendar(conv->fixingCalendar()),
                                                      parseDayCounter(conv->dayCounter()), h);
        IndexNameTranslator::instance().add(res->name(), s);
        return res;
        } else if (auto conv = QuantLib::ext::dynamic_pointer_cast<IborIndexConvention>(c)) {
            QL_REQUIRE(!tenor.empty(), "no tenor given for convention based Ibor index ('" << s << "'");
            auto res = QuantLib::ext::make_shared<IborIndex>(tokens[0] + "-" + tokens[1], parsePeriod(tenor),
                                                 conv->settlementDays(), ccy, parseCalendar(conv->fixingCalendar()),
                                                 parseBusinessDayConvention(conv->businessDayConvention()),
                                                 conv->endOfMonth(), parseDayCounter(conv->dayCounter()), h);
        IndexNameTranslator::instance().add(res->name(), s);
        return res;
        } else {
            QL_FAIL("invalid convention passed to parseIborIndex(): expected OvernightIndexConvention or "
                    "IborIndexConvention");
        }
    }
 
    // if we do not have a convention, look up the index in the hardcoded maps below
 
    // Map from our _unique internal name_ to an overnight index
    static map<string, QuantLib::ext::shared_ptr<OvernightIndex>> onIndices = {
        {"EUR-EONIA", QuantLib::ext::make_shared<Eonia>()},
        {"EUR-ESTER", QuantLib::ext::make_shared<Estr>()},
        {"GBP-SONIA", QuantLib::ext::make_shared<Sonia>()},
        {"JPY-TONAR", QuantLib::ext::make_shared<Tonar>()},
        {"SGD-SORA", QuantLib::ext::make_shared<Sora>()},
        {"CHF-TOIS", QuantLib::ext::make_shared<CHFTois>()},
        {"CHF-SARON", QuantLib::ext::make_shared<CHFSaron>()},
        {"USD-FedFunds", QuantLib::ext::make_shared<FedFunds>()},
        {"USD-SOFR", QuantLib::ext::make_shared<Sofr>()},
        {"USD-Prime", QuantLib::ext::make_shared<PrimeIndex>()},
        {"USD-AMERIBOR", QuantLib::ext::make_shared<USDAmeribor>()},
        {"AUD-AONIA", QuantLib::ext::make_shared<Aonia>()},
        {"CAD-CORRA", QuantLib::ext::make_shared<CORRA>()},
        {"DKK-DKKOIS", QuantLib::ext::make_shared<DKKOis>()},
        {"SEK-SIOR", QuantLib::ext::make_shared<SEKSior>()},
        {"COP-IBR", QuantLib::ext::make_shared<COPIbr>()},
        {"BRL-CDI", QuantLib::ext::make_shared<BRLCdi>()},
        {"NOK-NOWA", QuantLib::ext::make_shared<Nowa>()},
        {"CLP-CAMARA", QuantLib::ext::make_shared<CLPCamara>()},
        {"NZD-OCR", QuantLib::ext::make_shared<Nzocr>()},
        {"PLN-POLONIA", QuantLib::ext::make_shared<PLNPolonia>()},
        {"INR-MIBOROIS", QuantLib::ext::make_shared<INRMiborOis>()},
        {"GBP-BoEBase", QuantLib::ext::make_shared<BOEBaseRateIndex>()},
        {"HKD-HONIA", QuantLib::ext::make_shared<HKDHonia>()},
        {"SEK-STINA", QuantLib::ext::make_shared<SEKStina>()},
        {"DKK-CITA", QuantLib::ext::make_shared<DKKCita>()},
        {"THB-THOR", QuantLib::ext::make_shared<THBThor>()}};
 
    // Map from our _unique internal name_ to an ibor index (the period does not matter here)
    static map<string, QuantLib::ext::shared_ptr<IborIndexParser>> iborIndices = {
        {"AUD-BBSW", QuantLib::ext::make_shared<IborIndexParserWithPeriod<Bbsw>>()},
        {"AUD-LIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<AUDLibor>>()},
        {"EUR-EURIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<Euribor>>()},
        {"EUR-EURIBOR365", QuantLib::ext::make_shared<IborIndexParserWithPeriod<Euribor365>>()},
        {"CAD-CDOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<Cdor>>()},
        {"CNY-SHIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<Shibor>>()},
        {"CZK-PRIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<CZKPribor>>()},
        {"EUR-LIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<EURLibor>>()},
        {"USD-AMBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<USDAmbor>>()},
        {"USD-LIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<USDLibor>>()},
        {"GBP-LIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<GBPLibor>>()},
        {"JPY-LIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<JPYLibor>>()},
        {"JPY-TIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<Tibor>>()},
        {"JPY-EYTIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<JPYEYTIBOR>>()},
        {"CAD-LIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<CADLibor>>()},
        {"CHF-LIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<CHFLibor>>()},
        {"SEK-LIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<SEKLibor>>()},
        {"SEK-STIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<SEKStibor>>()},
        {"NOK-NIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<NOKNibor>>()},
        {"HKD-HIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<HKDHibor>>()},
        {"CNH-HIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<CNHHibor>>()},
        {"CNH-SHIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<CNHShibor>>()},
        {"SAR-SAIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<SAibor>>()},
        {"SGD-SIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<SGDSibor>>()},
        {"SGD-SOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<SGDSor>>()},
        {"DKK-CIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<DKKCibor>>()},
        {"DKK-LIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<DKKLibor>>()},
        {"HUF-BUBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<HUFBubor>>()},
        {"IDR-IDRFIX", QuantLib::ext::make_shared<IborIndexParserWithPeriod<IDRIdrfix>>()},
        {"IDR-JIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<IDRJibor>>()},
        {"ILS-TELBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<ILSTelbor>>()},
        {"INR-MIFOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<INRMifor>>()},
        {"MXN-TIIE", QuantLib::ext::make_shared<IborIndexParserWithPeriod<MXNTiie>>()},
        {"PLN-WIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<Wibor>>()},
        {"SKK-BRIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<SKKBribor>>()},
        {"NZD-BKBM", QuantLib::ext::make_shared<IborIndexParserWithPeriod<NZDBKBM>>()},
        {"TRY-TRLIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<TRLibor>>()},
        {"TWD-TAIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<TWDTaibor>>()},
        {"MYR-KLIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<MYRKlibor>>()},
        {"KRW-CD", QuantLib::ext::make_shared<IborIndexParserWithPeriod<KRWCd>>()},
        {"KRW-KORIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<KRWKoribor>>()},
        {"ZAR-JIBAR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<Jibar>>()},
        {"RUB-MOSPRIME", QuantLib::ext::make_shared<IborIndexParserWithPeriod<Mosprime>>()},
        {"RUB-KEYRATE", QuantLib::ext::make_shared<IborIndexParserWithPeriod<RUBKeyRate>>()},
        {"THB-BIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<THBBibor>>()},
        {"THB-THBFIX", QuantLib::ext::make_shared<IborIndexParserWithPeriod<THBFIX>>()},
        {"PHP-PHIREF", QuantLib::ext::make_shared<IborIndexParserWithPeriod<PHPPhiref>>()},
        {"RON-ROBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<Robor>>()},
        {"DEM-LIBOR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<DEMLibor>>()},
        {"CNY-REPOFIX", QuantLib::ext::make_shared<IborIndexParserWithPeriod<CNYRepoFix>>()},
        {"USD-SOFR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<QuantExt::SofrTerm>>()},
        {"GBP-SONIA", QuantLib::ext::make_shared<IborIndexParserWithPeriod<QuantExt::SoniaTerm>>()},
        {"JPY-TONAR", QuantLib::ext::make_shared<IborIndexParserWithPeriod<QuantExt::TonarTerm>>()},
        {"CAD-CORRA", QuantLib::ext::make_shared<IborIndexParserWithPeriod<QuantExt::CORRATerm>>()}};
 
    // Check (once) that we have a one-to-one mapping
    static bool checked = false;
    if (!checked) {
        checkOneToOne(onIndices, iborIndices);
        checked = true;
    }
 
    // Simple single case for USD-SIFMA (i.e. BMA)
    if (indexStem == "USD-SIFMA") {
        QL_REQUIRE(tenor.empty(), "A tenor is not allowed with USD-SIFMA as it is implied");
        auto res = QuantLib::ext::make_shared<BMAIndexWrapper>(QuantLib::ext::make_shared<BMAIndex>(h));
    IndexNameTranslator::instance().add(res->name(), s);
    return res;
    }
 
    // Ibor indices with a tenor, this includes OIS term rates like USD-SOFR-3M
    auto it = iborIndices.find(indexStem);
    if (it != iborIndices.end() && !tenor.empty()) {
        Period p = parsePeriod(tenor);
        auto res = it->second->build(p, h);
        IndexNameTranslator::instance().add(res->name(), s);
        return res;
    }
 
    // Overnight indices
    auto onIt = onIndices.find(indexStem);
    if (onIt != onIndices.end()) {
        QL_REQUIRE(tenor.empty(),
                   "A tenor is not allowed with the overnight index " << indexStem << " as it is implied");
        auto res = onIt->second->clone(h);
    IndexNameTranslator::instance().add(res->name(), s);
    return res;
    }
 
    // GENERIC indices
    if (tokens[1] == "GENERIC") {
        Period p = parsePeriod(tenor);
        auto ccy = parseCurrency(tokens[0]);
        auto res = QuantLib::ext::make_shared<GenericIborIndex>(p, ccy, h);
        IndexNameTranslator::instance().add(res->name(), s);
        return res;
    }
 
    QL_FAIL("parseIborIndex \"" << s << "\" not recognized");
}

Here is the call graph for this function:

◆ parseZeroInflationIndex()

QL_DEPRECATED QuantLib::ext::shared_ptr< ZeroInflationIndex > parseZeroInflationIndex	(	const string &	s,
		bool	isInterpolated,
		const Handle< ZeroInflationTermStructure > &	h
	)

Definition at line 670 of file indexparser.cpp.

                                                 {
    
    const QuantLib::ext::shared_ptr<Conventions>& conventions = InstrumentConventions::instance().conventions();
 
    // If conventions are non-null and we have provided a convention of type InflationIndex with a name equal to the 
    // string s, we use that convention to construct the inflation index.
    if (conventions) {
        pair<bool, QuantLib::ext::shared_ptr<Convention>> p = conventions->get(s, Convention::Type::ZeroInflationIndex);
        if (p.first) {
            auto c = QuantLib::ext::dynamic_pointer_cast<ZeroInflationIndexConvention>(p.second);
            auto index = QuantLib::ext::make_shared<ZeroInflationIndex>(s, c->region(), c->revised(), isInterpolated,
                c->frequency(), c->availabilityLag(), c->currency(), h);
            IndexNameTranslator::instance().add(index->name(), s);
            return index;
        }
    }
 
    static map<string, QuantLib::ext::shared_ptr<ZeroInflationIndexParserBase>> m = {
        {"AUCPI", QuantLib::ext::make_shared<ZeroInflationIndexParserWithFrequency<AUCPI>>(Quarterly)},
        {"AU CPI", QuantLib::ext::make_shared<ZeroInflationIndexParserWithFrequency<AUCPI>>(Quarterly)},
        {"BEHICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<BEHICP>>()},
        {"BE HICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<BEHICP>>()},
        {"EUHICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<EUHICP>>()},
        {"EU HICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<EUHICP>>()},
        {"EUHICPXT", QuantLib::ext::make_shared<ZeroInflationIndexParser<EUHICPXT>>()},
        {"EU HICPXT", QuantLib::ext::make_shared<ZeroInflationIndexParser<EUHICPXT>>()},
        {"FRHICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<FRHICP>>()},
        {"FR HICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<FRHICP>>()},
        {"FRCPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<FRCPI>>()},
        {"FR CPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<FRCPI>>()},
        {"UKRPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<UKRPI>>()},
        {"UK RPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<UKRPI>>()},
        {"USCPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<USCPI>>()},
        {"US CPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<USCPI>>()},
        {"ZACPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<ZACPI>>()},
        {"ZA CPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<ZACPI>>()},
        {"SECPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<SECPI>>()},
        {"DKCPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<DKCPI>>()},
        {"CACPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<CACPI>>()},
        {"ESCPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<ESCPI>>()},
        {"DECPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<DECPI>>()},
        {"DE CPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<DECPI>>()}
    };
 
    auto it = m.find(s);
    if (it != m.end()) {
        QL_DEPRECATED_DISABLE_WARNING
        auto index = it->second->build(isInterpolated, h);
        QL_DEPRECATED_ENABLE_WARNING
        IndexNameTranslator::instance().add(index->name(), s);
        return index;
    } else {
        QL_FAIL("parseZeroInflationIndex: \"" << s << "\" not recognized");
    }
}

◆ parseCommodityIndex()

QuantLib::ext::shared_ptr< QuantExt::CommodityIndex > parseCommodityIndex	(	const string &	name,
		bool	hasPrefix,
		const Handle< PriceTermStructure > &	ts,
		const Calendar &	cal,
		const bool	enforceFutureIndex
	)

Definition at line 797 of file indexparser.cpp.

                                                                                                                    {
 
    // Whether we check for "COMM-" prefix depends on hasPrefix.
    string commName = name;
    if (hasPrefix) {
        // Make sure the prefix is correct
        string prefix = name.substr(0, 5);
        QL_REQUIRE(prefix == "COMM-", "A commodity index string must start with 'COMM-' but got " << prefix);
        commName = name.substr(5);
    }
 
    // Now take the remainder of the string
    // for spot indices, this should just be the commodity name (possibly containing hyphens)
    // for future indices, this is of the form NAME-YYYY-MM or NAME-YYYY-MM-DD where NAME is the commodity name
    // (possibly containing hyphens) and YYYY-MM(-DD) is the expiry date of the futures contract
    Date expiry;
 
    // Check for form NAME-YYYY-MM-DD
    if (commName.size() > 10) {
        string test = commName.substr(commName.size() - 10);
        if (boost::regex_match(test, boost::regex("\\d{4}-\\d{2}-\\d{2}"))) {
            expiry = parseDate(test);
            commName = commName.substr(0, commName.size() - test.size() - 1);
        }
    }
 
    // Check for form NAME-YYYY-MM if NAME-YYYY-MM-DD failed
    if (expiry == Date() && commName.size() > 7) {
        string test = commName.substr(commName.size() - 7);
        if (boost::regex_match(test, boost::regex("\\d{4}-\\d{2}"))) {
            expiry = parseDate(test + "-01");
            commName = commName.substr(0, commName.size() - test.size() - 1);
        }
    }
 
    // Name to use when creating the index. This may be updated if we have a commodity future convention and IndexName 
    // is provided by the convention.
    string indexName = commName;
 
    // Do we have a commodity future convention for the commodity.
    QuantLib::ext::shared_ptr<Conventions> conventions = InstrumentConventions::instance().conventions();
    pair<bool, QuantLib::ext::shared_ptr<Convention>> p = conventions->get(commName, Convention::Type::CommodityFuture);
    QuantLib::ext::shared_ptr<CommodityFutureConvention> convention;
    if (p.first) {
 
        convention = QuantLib::ext::dynamic_pointer_cast<CommodityFutureConvention>(p.second);
 
        if (!convention->indexName().empty())
            indexName = convention->indexName();
 
        // If we have provided OffPeakPowerIndexData, we use that to construct the off peak power commodity index.
        if (convention->offPeakPowerIndexData()) {
 
            const auto& oppIdxData = *convention->offPeakPowerIndexData();
 
            if (expiry == Date()) {
                // If expiry is still not set use any date (off peak index is calendar daily)
                expiry = Settings::instance().evaluationDate();
            }
            string suffix = "-" + to_string(expiry);
 
            auto offPeakIndex = QuantLib::ext::dynamic_pointer_cast<CommodityFuturesIndex>(parseCommodityIndex(
                oppIdxData.offPeakIndex() + suffix, false));
            auto peakIndex = QuantLib::ext::dynamic_pointer_cast<CommodityFuturesIndex>(parseCommodityIndex(
                oppIdxData.peakIndex() + suffix, false));
 
            auto index = QuantLib::ext::make_shared<OffPeakPowerIndex>(indexName, expiry, offPeakIndex, peakIndex,
                oppIdxData.offPeakHours(), oppIdxData.peakCalendar(), ts);
            IndexNameTranslator::instance().add(index->name(), hasPrefix ? name : "COMM-" + name);
            DLOG("parseCommodityIndex(" << name << ") -> " << index->name() << " with expiry " << index->expiryDate());
            return index;
        }
    }
 
    // Create and return the required future index
    QuantLib::ext::shared_ptr<CommodityIndex> index;
    if (expiry != Date() || (convention && enforceFutureIndex)) {
 
        // If expiry is empty, just use any valid expiry.
        if (expiry == Date()) {
            ConventionsBasedFutureExpiry feCalc(*convention);
            expiry = feCalc.nextExpiry();
        }
 
        bool keepDays = convention && convention->contractFrequency() == Daily;
 
        Calendar cdr = cal;
        if (convention && cdr == NullCalendar()) {
            cdr = convention->calendar();
        }
 
        auto basisCurve = ts.empty() ? nullptr :
            QuantLib::ext::dynamic_pointer_cast<CommodityBasisPriceTermStructure>(*ts);
 
        if (basisCurve) {
            index = QuantLib::ext::make_shared<CommodityBasisFutureIndex>(indexName, expiry, cdr, basisCurve);       
        } else {
            index = QuantLib::ext::make_shared<CommodityFuturesIndex>(indexName, expiry, cdr, keepDays, ts);
        }
 
        
 
    } else {
        index = QuantLib::ext::make_shared<CommoditySpotIndex>(commName, cal, ts);
    }
    IndexNameTranslator::instance().add(index->name(), index->name());
    DLOG("parseCommodityIndex(" << name << ") -> " << index->name() << " with expiry " << index->expiryDate());
    return index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isFxIndex()

bool isFxIndex ( const std::string & indexName )

Check if index is an fx index

Definition at line 1027 of file indexparser.cpp.

                                           {
    std::vector<string> tokens;
    split(tokens, indexName, boost::is_any_of("-"));
    return tokens.size() == 4 && tokens[0] == "FX";
}

Here is the caller graph for this function:

◆ inverseFxIndex()

std::string inverseFxIndex ( const std::string & indexName )

Invert an fx index

Definition at line 1033 of file indexparser.cpp.

                                                     {
    std::vector<string> tokens;
    split(tokens, indexName, boost::is_any_of("-"));
    QL_REQUIRE(tokens.size() == 4 && tokens[0] == "FX", "no fx index given (" << indexName << ")");
    return "FX-" + tokens[1] + "-" + tokens[3] + "-" + tokens[2];
}

Here is the caller graph for this function:

◆ getStartAndLag()

std::pair< QuantLib::Date, QuantLib::Period > getStartAndLag	(	const QuantLib::Date &	asof,
		const InflationSwapConvention &	conv
	)

Definition at line 27 of file inflationstartdate.cpp.

                                                                                                {
 
    using IPR = InflationSwapConvention::PublicationRoll;
 
    // If no roll schedule, just return (as of, convention's obs lag).
    if (conv.publicationRoll() == IPR::None) {
        return make_pair(asof, Period());
    }
 
    // If there is a publication roll, call getStart to retrieve the date.
    Date d = getInflationSwapStart(asof, conv);
 
    // Date in inflation period related to the inflation index value.
    Date dateInPeriod = d - Period(conv.index()->frequency());
 
    // Find period between dateInPeriod and asof. This will be the inflation curve's obsLag.
    QL_REQUIRE(dateInPeriod < asof, "InflationCurve: expected date in inflation period ("
                                        << io::iso_date(dateInPeriod) << ") to be before the as of date ("
                                        << io::iso_date(asof) << ").");
    Period curveObsLag = (asof - dateInPeriod) * Days;
 
    return make_pair(d, curveObsLag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getInflationSwapStart() [2/2]

QuantLib::Date getInflationSwapStart	(	const QuantLib::Date &	asof,
		const InflationSwapConvention &	conv
	)

Definition at line 52 of file inflationstartdate.cpp.

                                                                                                  {
 
    using IPR = InflationSwapConvention::PublicationRoll;
 
    // If no roll schedule, just return (as of, convention's obs lag).
    if (conv.publicationRoll() == IPR::None) {
        return asof;
    }
 
    // Get schedule and check not empty
    const Schedule& ps = conv.publicationSchedule();
    QL_REQUIRE(!ps.empty(), "InflationCurve: roll on publication is true for "
                                << conv.id() << " but the publication schedule is empty.");
 
    // Check the schedule dates cover the as of date.
    const vector<Date>& ds = ps.dates();
    QL_REQUIRE(ds.front() < asof, "InflationCurve: first date in the publication schedule ("
                                      << io::iso_date(ds.front()) << ") should be before the as of date ("
                                      << io::iso_date(asof) << ").");
    QL_REQUIRE(asof < ds.back(), "InflationCurve: last date in the publication schedule ("
                                     << io::iso_date(ds.back()) << ") should be after the as of date ("
                                     << io::iso_date(asof) << ").");
 
    // Find d such that d_- < asof <= d. If necessary, move to the next publication schedule date. We
    // know that there is another date because asof < ds.back() is checked above.
    auto it = lower_bound(ds.begin(), ds.end(), asof);
    Date d = *it;
    if (asof == d && conv.publicationRoll() == IPR::OnPublicationDate) {
        d = *next(it);
    }
 
    // Move d back availability lag and the 15th of that month is the helper's start date.
    // Note: the 15th of the month is specific to AU CPI. We may need to generalise later.
    d -= conv.index()->availabilityLag();
 
    return Date(15, d.month(), d.year());
}

Here is the call graph for this function:

◆ operator<<() [56/73]

std::ostream & operator<<	(	std::ostream &	out,
		const StructuredMessage::Category &	category
	)

Definition at line 645 of file log.cpp.

                                                                                   {
    if (category == StructuredMessage::Category::Error)
        out << "Error";
    else if (category == StructuredMessage::Category::Warning)
        out << "Warning";
    else if (category == StructuredMessage::Category::Unknown)
        out << "UnknownType";
    else
        QL_FAIL("operator<<: Unsupported enum value for StructuredMessage::Category");
 
    return out;
}

◆ operator<<() [57/73]

std::ostream & operator<<	(	std::ostream &	out,
		const StructuredMessage::Group &	group
	)

Definition at line 658 of file log.cpp.

                                                                             {
    if (group == StructuredMessage::Group::Analytics)
        out << "Analytics";
    else if (group == StructuredMessage::Group::Configuration)
        out << "Configuration";
    else if (group == StructuredMessage::Group::Model)
        out << "Model";
    else if (group == StructuredMessage::Group::Curve)
        out << "Curve";
    else if (group == StructuredMessage::Group::Trade)
        out << "Trade";
    else if (group == StructuredMessage::Group::Fixing)
        out << "Fixing";
    else if (group == StructuredMessage::Group::Logging)
        out << "Logging";
    else if (group == StructuredMessage::Group::ReferenceData)
        out << "Reference Data";
    else if (group == StructuredMessage::Group::Unknown)
        out << "UnknownType";
    else
        QL_FAIL("operator<<: Unsupported enum value for StructuredMessage::Group");
 
    return out;
}

◆ xccyCurveName()

std::string xccyCurveName ( const std::string & ccyCode )

For a given currency code, ccyCode, return the internal name for the cross currency based yield curve.

For a given currency code, ccyCode, this function returns __XCCY__-ccyCode. This curve, if available, is currently used in special cases to allow for separate discount curves when discounting the cashflows on cross currency interest rate swaps.

Definition at line 39 of file marketdata.cpp.

39{ return xccyCurveNamePrefix + "-" + ccyCode; }

ore::data::xccyCurveNamePrefix

const string xccyCurveNamePrefix

Definition: marketdata.cpp:37

Here is the caller graph for this function:

◆ xccyYieldCurve() [1/2]

QuantLib::Handle< QuantLib::YieldTermStructure > xccyYieldCurve	(	const QuantLib::ext::shared_ptr< Market > &	market,
		const std::string &	ccyCode,
		const std::string &	configuration = `Market::defaultConfiguration`
	)

Attempt to return a yield curve from the market using the name generated by xccyCurveName(ccyCode). If no yield curve is available, return the discount curve for the given currency code, ccyCode.

Definition at line 41 of file marketdata.cpp.

                                                                       {
    bool dummy;
    return xccyYieldCurve(market, ccyCode, dummy, configuration);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xccyYieldCurve() [2/2]

QuantLib::Handle< QuantLib::YieldTermStructure > xccyYieldCurve	(	const QuantLib::ext::shared_ptr< Market > &	market,
		const std::string &	ccyCode,
		bool &	outXccyExists,
		const std::string &	configuration = `Market::defaultConfiguration`
	)

Attempt to return a yield curve from the market using the name generated by xccyCurveName(ccyCode). If no yield curve is available, return the discount curve for the given currency code, ccyCode. The parameter outXccyExists is populated with true if a yield curve was found under xccyCurveName(ccyCode) and it is populated with false if there was no such yield curve.

Definition at line 47 of file marketdata.cpp.

                                                                                            {
 
    Handle<YieldTermStructure> curve;
    string xccyCurve = xccyCurveName(ccyCode);
    outXccyExists = true;
    try {
        curve = market->yieldCurve(xccyCurve, configuration);
    } catch (const Error&) {
        DLOG("Could not link " << ccyCode << " termstructure to cross currency yield curve " << xccyCurve
                               << " so just using " << ccyCode << " discount curve.");
        curve = market->discountCurve(ccyCode, configuration);
        outXccyExists = false;
    }
 
    return curve;
}

Here is the call graph for this function:

◆ indexOrYieldCurve()

QuantLib::Handle< QuantLib::YieldTermStructure > indexOrYieldCurve	(	const QuantLib::ext::shared_ptr< Market > &	market,
		const std::string &	name,
		const std::string &	configuration = `Market::defaultConfiguration`
	)

Get a yield curve by name, where name can refer to an index or a yield curve name

Definition at line 65 of file marketdata.cpp.

                                                                             {
    try {
        return market->iborIndex(name, configuration)->forwardingTermStructure();
    } catch (...) {
    }
    try {
        return market->yieldCurve(name, configuration);
    } catch (...) {
    }
    QL_FAIL("Could not find index or yield curve with name '" << name << "' under configuration '" << configuration
                                                              << "' or default configuration.");
}

Here is the caller graph for this function:

◆ securitySpecificCreditCurveName()

std::string securitySpecificCreditCurveName	(	const std::string &	securityId,
		const std::string &	creditCurveId
	)

For a given security id and credit curve id return the internal name for a security specific copy of the credit curve. This is used to separate sensitivities on credit curves by securities.

Definition at line 79 of file marketdata.cpp.

                                                                                                       {
    auto tmp = "__SECCRCRV_" + securityId + "_&_" + creditCurveId + "_&_";
    return tmp;
}

Here is the caller graph for this function:

◆ creditCurveNameFromSecuritySpecificCreditCurveName()

std::string creditCurveNameFromSecuritySpecificCreditCurveName ( const std::string & name )

Return the credit curve id for a name generated with securitySpecificCreditCurveName(). If the name was not generated with securitySpecificCreditCurveName(), return the input name unchanged.

Definition at line 84 of file marketdata.cpp.

                                                                                    {
    if (boost::starts_with(name, "__SECCRCRV_")) {
        std::size_t pos = name.find("_&_", 11);
        if (pos != std::string::npos) {
            std::size_t pos2 = name.find("_&_", pos + 3);
            if (pos2 != std::string::npos) {
                auto tmp = name.substr(pos + 3, pos2 - (pos + 3));
                return tmp;
            }
        }
    }
    return name;
}

Here is the caller graph for this function:

◆ securitySpecificCreditCurve()

QuantLib::Handle< QuantExt::CreditCurve > securitySpecificCreditCurve	(	const QuantLib::ext::shared_ptr< Market > &	market,
		const std::string &	securityId,
		const std::string &	creditCurveId,
		const std::string &	configuration = `Market::defaultConfiguration`
	)

Attempt to return a security specific default curve using the name generated by 'securitySpecificCreditCurveName()'. If no such curve is available return the credit curve for the given creditCurveId.

Definition at line 98 of file marketdata.cpp.

                                                                                                    {
    Handle<QuantExt::CreditCurve> curve;
    std::string name = securitySpecificCreditCurveName(securityId, creditCurveId);
    try {
        curve = market->defaultCurve(name, configuration);
    } catch (const std::exception&) {
        DLOG("Could not link " << securityId << " to security specific credit curve " << name << " so just using "
                               << creditCurveId << " default curve.");
        curve = market->defaultCurve(creditCurveId, configuration);
    }
    return curve;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prettyPrintInternalCurveName()

std::string prettyPrintInternalCurveName ( std::string name )

Pretty print an internal curve name occuring (once or several times) in a string (e.g. in a risk factor name).

Definition at line 114 of file marketdata.cpp.

                                                       {
    std::size_t pos = 0;
    bool found;
    do {
        found = false;
        std::size_t pos2 = name.find("__SECCRCRV_", pos);
        if (pos2 != std::string::npos) {
            std::size_t pos3 = name.find("_&_", pos2);
            if (pos3 != std::string::npos) {
                std::size_t pos4 = name.find("_&_", pos3 + 3);
                if (pos4 != std::string::npos) {
                    name.replace(pos2, pos4 + 3 - pos2,
                                 name.substr(pos2 + 11, pos3 - (pos2 + 11)) + "(" +
                                     name.substr(pos3 + 3, pos4 - (pos3 + 3)) + ")");
                    pos = pos + (pos4 - pos2 - 12);
                    found = true;
                }
            }
        }
    } while (found);
    return name;
}

◆ buildFxIndex()

QuantLib::ext::shared_ptr< QuantExt::FxIndex > buildFxIndex	(	const string &	fxIndex,
		const string &	domestic,
		const string &	foreign,
		const QuantLib::ext::shared_ptr< Market > &	market,
		const string &	configuration,
		bool	useXbsCurves = `false`
	)

Build an Fx Index given a market. Note: sold==domestic, bought==foreign

Definition at line 137 of file marketdata.cpp.

                                                                     {
 
    auto fxInd = parseFxIndex(fxIndex);
 
    string source = fxInd->sourceCurrency().code();
    string target = fxInd->targetCurrency().code();
    string family = fxInd->familyName();
 
    fxInd = *market->fxIndex("FX-" + family + "-" + foreign + "-" + domestic);
 
    QL_REQUIRE((domestic == target && foreign == source) || (domestic == source && foreign == target),
               "buildFxIndex(): index '" << fxIndex << "' does not match given currencies " << domestic << ", "
                                         << foreign);
 
    if (!useXbsCurves)
        return fxInd;
 
    return fxInd->clone(Handle<Quote>(), xccyYieldCurve(market, foreign, configuration),
                        xccyYieldCurve(market, domestic, configuration));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getFxIndexConventions()

std::tuple< Natural, Calendar, BusinessDayConvention > getFxIndexConventions ( const string & index )

Definition at line 160 of file marketdata.cpp.

                                                                                              {
    // can take an fx index or ccy pair e.g. EURUSD
    string ccy1, ccy2;
    string fixingSource;
    if (isFxIndex(index)) {
        auto ind = parseFxIndex(index);
        ccy1 = ind->sourceCurrency().code();
        ccy2 = ind->targetCurrency().code();
        fixingSource = ind->familyName();
    } else {
        QL_REQUIRE(index.size() == 6, "getFxIndexConventions: index must be an FXIndex of form FX-ECB-EUR-USD, "
                                          << "or a currency pair e.g. EURUSD, got '" + index + "'");
        ccy1 = index.substr(0, 3);
        ccy2 = index.substr(3);
        fixingSource = "GENERIC";
    }
 
    if (ccy1 == ccy2)
        return std::make_tuple(0, NullCalendar(), Unadjusted);
 
    const QuantLib::ext::shared_ptr<Conventions>& conventions = InstrumentConventions::instance().conventions();
    QuantLib::ext::shared_ptr<Convention> con;
    // first look for the index and inverse index directly
    try {
        con = conventions->get("FX-" + fixingSource + "-" + ccy1 + "-" + ccy2);
    } catch (...) {
    }
    if (con == nullptr) {
        try {
            con = conventions->get("FX-" + fixingSource + "-" + ccy2 + "-" + ccy1);
        } catch (...) {
        }
    }
    // then by currency pair and inverse currency pair (getFxConvention() handles both)
    if (con == nullptr) {
        try {
            con = conventions->getFxConvention(ccy1, ccy2);
        } catch (...) {
        }
    }
    if (auto fxCon = QuantLib::ext::dynamic_pointer_cast<FXConvention>(con)) {
        TLOG("getFxIndexConvention(" << index << "): " << fxCon->spotDays() << " / " << fxCon->advanceCalendar().name()
                                     << " from convention.");
        return std::make_tuple(fxCon->spotDays(), fxCon->advanceCalendar(), fxCon->convention());
    } else if (auto comCon = QuantLib::ext::dynamic_pointer_cast<CommodityForwardConvention>(con); comCon !=nullptr
               && (isPseudoCurrency(ccy1) || isPseudoCurrency(ccy2))) {
        TLOG("getFxIndexConvention(" << index << "): " << fxCon->spotDays() << " / " << fxCon->advanceCalendar().name()
                                     << " from convention.");
        return std::make_tuple(0, comCon->advanceCalendar(), comCon->bdc());
    }
 
    // default calendar for pseudo currencies is USD
    if (isPseudoCurrency(ccy1))
        ccy1 = "USD";
    if (isPseudoCurrency(ccy2))
        ccy2 = "USD";
 
    try {
    Calendar cal = parseCalendar(ccy1 + "," + ccy2);
        TLOG("getFxIndexConvention(" << index << "): 2 (default) / " << cal.name()
                                     << " (from ccys), no convention found.");
        return std::make_tuple(2, cal, Following);
    } catch (const std::exception& e) {
        ALOG("could not get fx index convention for '" << index << "': " << e.what() << ", continue with 'USD'");
    }
    TLOG("getFxIndexConvention(" << index
                                 << "): 2 (default) / USD (default), no convention found, could not parse calendar '"
                                 << (ccy1 + "," + ccy2) << "'");
    return std::make_tuple(2, parseCalendar("USD"), Following);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ splitCurveIdWithTenor()

std::pair< std::string, QuantLib::Period > splitCurveIdWithTenor ( const std::string & curveId )

Split curve name NAME_5Y into (NAME, 5Y), the period can be empty if not given

Definition at line 231 of file marketdata.cpp.

                                                                                         {
    Size pos = creditCurveId.rfind("_");
    if (pos != std::string::npos) {
        Period term;
        string termString = creditCurveId.substr(pos + 1, creditCurveId.length());
        if (tryParse<Period>(termString, term, parsePeriod)) {
            return make_pair(creditCurveId.substr(0, pos), term);
        }
    }
    return make_pair(creditCurveId, 0 * Days);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ indexCdsDefaultCurve()

QuantLib::Handle< QuantExt::CreditCurve > indexCdsDefaultCurve	(	const QuantLib::ext::shared_ptr< Market > &	market,
		const std::string &	creditCurveId,
		const std::string &	config
	)

Get default curve for index cds from market:

if creditCurveId ends on _5Y (or any other term), use that to get the curve from the market
if such a curve is not available, fall back to creditCurveId without that suffix

Definition at line 243 of file marketdata.cpp.

                                                                                      {
    try {
        return market->defaultCurve(creditCurveId, config);
    } catch (...) {
        DLOG("indexCdsDefaultCurve: could not get '" << creditCurveId << "', fall back on curve id without tenor.");
    }
 
    auto p = splitCurveIdWithTenor(creditCurveId);
    return market->defaultCurve(p.first, config);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isOnePeriod()

bool isOnePeriod ( const string & s )

return true if s represents a period of the form [0-9][D|W|M|Y] (i.e. 1Y6M would return false)

Definition at line 159 of file parsers.cpp.

                                  {
    if (s.empty())
        return false;
    char c = std::toupper(s.back());
    if (!(c == 'D' || c == 'W' || c == 'M' || c == 'Y'))
        return false;
    for (auto c = s.cbegin(); c != std::next(s.end(), -1); std::advance(c, 1))
        if (*c < '0' || *c > '9')
            return false;
    return true;
}

Here is the caller graph for this function:

◆ parseDateOrPeriod()

void parseDateOrPeriod	(	const string &	s,
		Date &	d,
		Period &	p,
		bool &	isDate
	)

Definition at line 522 of file parsers.cpp.

                                                                          {
    auto r = parseDateOrPeriod(s);
    boost::apply_visitor(legacy_date_or_period_visitor(d, p, isDate), r);
}

Here is the call graph for this function:

◆ parseListOfValues()

std::vector< string > parseListOfValues	(	string	s,
		const char	escape,
		const char	delim,
		const char	quote
	)

Definition at line 639 of file parsers.cpp.

                                                                                                     {
    boost::trim(s);
    std::vector<string> vec;
    boost::escaped_list_separator<char> sep(escape, delim, quote);
    boost::tokenizer<boost::escaped_list_separator<char>> tokens(s, sep);
    for (auto r : tokens) {
        boost::trim(r);
        vec.push_back(r);
    }
    return vec;
}

Here is the caller graph for this function:

◆ parseAmortizationType()

AmortizationType parseAmortizationType ( const std::string & s )

Definition at line 651 of file parsers.cpp.

                                                           {
    static map<string, AmortizationType> type = {
        {"None", AmortizationType::None},
        {"FixedAmount", AmortizationType::FixedAmount},
        {"RelativeToInitialNotional", AmortizationType::RelativeToInitialNotional},
        {"RelativeToPreviousNotional", AmortizationType::RelativeToPreviousNotional},
        {"Annuity", AmortizationType::Annuity},
        {"LinearToMaturity", AmortizationType::LinearToMaturity}};
 
    auto it = type.find(s);
    if (it != type.end()) {
        return it->second;
    } else {
        QL_FAIL("Amortitazion type \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

◆ parseExtrapolation()

Extrapolation parseExtrapolation ( const string & s )

Parse Extrapolation from string.

Definition at line 778 of file parsers.cpp.

                                                  {
    if (s == "None") {
        return Extrapolation::None;
    } else if (s == "UseInterpolator" || s == "Linear") {
        return Extrapolation::UseInterpolator;
    } else if (s == "Flat") {
        return Extrapolation::Flat;
    } else {
        QL_FAIL("Extrapolation '" << s << "' not recognized");
    }
}

Here is the caller graph for this function:

◆ operator<<() [58/73]

std::ostream & operator<<	(	std::ostream &	os,
		Extrapolation	extrap
	)

Write Extrapolation, extrap, to stream.

Definition at line 791 of file parsers.cpp.

                                                             {
    switch (extrap) {
    case Extrapolation::None:
        return os << "None";
    case Extrapolation::UseInterpolator:
        return os << "UseInterpolator";
    case Extrapolation::Flat:
        return os << "Flat";
    default:
        QL_FAIL("Unknown Extrapolation");
    }
}

◆ parseOvernightIndexFutureNettingType()

QuantLib::RateAveraging::Type parseOvernightIndexFutureNettingType ( const std::string & s )

Convert text to QuantLib::RateAveraging::Type.

Definition at line 970 of file parsers.cpp.

                                                                                   {
    if (s == "Averaging") {
        return QuantLib::RateAveraging::Type::Simple;
    } else if (s == "Compounding") {
        return QuantLib::RateAveraging::Type::Compound;
    } else {
        QL_FAIL("Overnight Index Future Netting Type '" << s << "' not known, expected 'Averaging' or 'Compounding'");
    }
}

Here is the caller graph for this function:

◆ operator<<() [59/73]

std::ostream & operator<<	(	std::ostream &	os,
		QuantLib::RateAveraging::Type	t
	)

Write QuantLib::RateAveraging::Type to stream.

Definition at line 980 of file parsers.cpp.

                                                                    {
    if (t == QuantLib::RateAveraging::Type::Simple)
        return os << "Averaging";
    else if (t == QuantLib::RateAveraging::Type::Compound)
        return os << "Compounding";
    else {
        QL_FAIL("Internal error: unknown RateAveraging::Type - check implementation of operator<< "
                "for this enum");
    }
}

◆ parseFutureDateGenerationRule()

FutureConvention::DateGenerationRule parseFutureDateGenerationRule ( const std::string & s )

Convert text to FutureConvention::DateGeneration.

Definition at line 991 of file parsers.cpp.

                                                                                     {
    if (s == "IMM")
        return FutureConvention::DateGenerationRule::IMM;
    else if (s == "FirstDayOfMonth")
        return FutureConvention::DateGenerationRule::FirstDayOfMonth;
    else {
        QL_FAIL("FutureConvention /  DateGenerationRule '" << s << "' not known, expect 'IMM' or 'FirstDayOfMonth'");
    }
}

Here is the caller graph for this function:

◆ operator<<() [60/73]

std::ostream & operator<<	(	std::ostream &	os,
		FutureConvention::DateGenerationRule	t
	)

Write QuantLib::RateAveraging::Type to stream.

Definition at line 1001 of file parsers.cpp.

                                                                             {
    if (t == FutureConvention::DateGenerationRule::IMM)
        return os << "IMM";
    else if (t == FutureConvention::DateGenerationRule::FirstDayOfMonth)
        return os << "FirstDayOfMonth";
    else {
        QL_FAIL("Internal error: unknown FutureConvention::DateGenerationRule - check implementation of operator<< "
                "for this enum");
    }
}

◆ parseInflationSwapPublicationRoll()

InflationSwapConvention::PublicationRoll parseInflationSwapPublicationRoll ( const string & s )

Convert text to InflationSwapConvention::PublicationRoll.

Definition at line 1012 of file parsers.cpp.

                                                                                          {
    using IPR = InflationSwapConvention::PublicationRoll;
    if (s == "None") {
        return IPR::None;
    } else if (s == "OnPublicationDate") {
        return IPR::OnPublicationDate;
    } else if (s == "AfterPublicationDate") {
        return IPR::AfterPublicationDate;
    } else {
        QL_FAIL("InflationSwapConvention::PublicationRoll '"
                << s << "' not known, expect "
                << "'None', 'OnPublicationDate' or 'AfterPublicationDate'");
    }
}

Here is the caller graph for this function:

◆ operator<<() [61/73]

std::ostream & operator<<	(	ostream &	os,
		InflationSwapConvention::PublicationRoll	pr
	)

Write InflationSwapConvention::PublicationRoll to stream.

Definition at line 1077 of file parsers.cpp.

                                                                            {
    using IPR = InflationSwapConvention::PublicationRoll;
    if (pr == IPR::None) {
        return os << "None";
    } else if (pr == IPR::OnPublicationDate) {
        return os << "OnPublicationDate";
    } else if (pr == IPR::AfterPublicationDate) {
        return os << "AfterPublicationDate";
    } else {
        QL_FAIL("Unknown InflationSwapConvention::PublicationRoll.");
    }
}

◆ operator<<() [62/73]

std::ostream & operator<<	(	std::ostream &	os,
		SobolBrownianGenerator::Ordering	t
	)

Write QuantLib::SobolBrownianGenerator::Ordering to stream.

Definition at line 1090 of file parsers.cpp.

                                                                         {
    static map<SobolBrownianGenerator::Ordering, string> m = {{SobolBrownianGenerator::Ordering::Factors, "Factors"},
                                                              {SobolBrownianGenerator::Ordering::Steps, "Steps"},
                                                              {SobolBrownianGenerator::Ordering::Diagonal, "Diagonal"}};
    auto it = m.find(t);
    if (it != m.end()) {
        return os << it->second;
    } else {
        QL_FAIL("Internal error: unknown SobolBrownianGenerator::Ordering - check implementation of operator<< "
                "for this enum");
    }
}

◆ operator<<() [63/73]

std::ostream & operator<<	(	std::ostream &	os,
		SobolRsg::DirectionIntegers	t
	)

Write QuantLib::SobolRsg::DirectionIntegers to stream.

Definition at line 1103 of file parsers.cpp.

                                                                    {
    static map<SobolRsg::DirectionIntegers, string> m = {
        {SobolRsg::DirectionIntegers::Unit, "Unit"},
        {SobolRsg::DirectionIntegers::Jaeckel, "Jaeckel"},
        {SobolRsg::DirectionIntegers::SobolLevitan, "SobolLevitan"},
        {SobolRsg::DirectionIntegers::SobolLevitanLemieux, "SobolLevitanLemieux"},
        {SobolRsg::DirectionIntegers::JoeKuoD5, "JoeKuoD5"},
        {SobolRsg::DirectionIntegers::JoeKuoD6, "JoeKuoD6"},
        {SobolRsg::DirectionIntegers::JoeKuoD7, "JoeKuoD7"},
        {SobolRsg::DirectionIntegers::Kuo, "Kuo"},
        {SobolRsg::DirectionIntegers::Kuo2, "Kuo2"},
        {SobolRsg::DirectionIntegers::Kuo3, "Kuo3"}};
    auto it = m.find(t);
    if (it != m.end()) {
        return os << it->second;
    } else {
        QL_FAIL("Internal error: unknown SobolRsg::DirectionIntegers - check implementation of operator<< "
                "for this enum");
    }
}

◆ operator<<() [64/73]

std::ostream & operator<<	(	std::ostream &	out,
		QuantExt::CrossAssetModel::Discretization	dis
	)

Enum to string used in ScenarioGeneratorData's toXML.

Definition at line 1124 of file parsers.cpp.

                                                                                   {
    switch (dis) {
    case QuantExt::CrossAssetModel::Discretization::Exact:
        return out << "Exact";
    case QuantExt::CrossAssetModel::Discretization::Euler:
        return out << "Euler";
    default:
        return out << "?";
    }
}

◆ parseAveragingDataPeriod()

CommodityFutureConvention::AveragingData::CalculationPeriod parseAveragingDataPeriod ( const string & s )

Convert text to CommodityFutureConvention::AveragingData::CalculationPeriod.

Definition at line 1136 of file parsers.cpp.

                                               {
    if (s == "PreviousMonth") {
        return ADCP::PreviousMonth;
    } else if (s == "ExpiryToExpiry") {
        return ADCP::ExpiryToExpiry;
    } else {
        QL_FAIL("AveragingData::CalculationPeriod '" << s << "' not known, expect "
                                                     << "'PreviousMonth' or 'ExpiryToExpiry'");
    }
}

Here is the caller graph for this function:

◆ operator<<() [65/73]

std::ostream & operator<<	(	ostream &	os,
		ADCP	cp
	)

Write CommodityFutureConvention::AveragingData::CalculationPeriod to stream.

Definition at line 1147 of file parsers.cpp.

                                          {
    if (cp == ADCP::PreviousMonth) {
        return os << "PreviousMonth";
    } else if (cp == ADCP::ExpiryToExpiry) {
        return os << "ExpiryToExpiry";
    } else {
        QL_FAIL("Unknown AveragingData::CalculationPeriod.");
    }
}

◆ parsePriceSegmentType()

PriceSegment::Type parsePriceSegmentType ( const string & s )

Convert text to PriceSegment::Type.

Definition at line 1158 of file parsers.cpp.

                                                        {
    if (s == "Future") {
        return PST::Future;
    } else if (s == "AveragingFuture") {
        return PST::AveragingFuture;
    } else if (s == "AveragingSpot") {
        return PST::AveragingSpot;
    } else if (s == "AveragingOffPeakPower") {
        return PST::AveragingOffPeakPower;
    } else if (s == "OffPeakPowerDaily") {
        return PST::OffPeakPowerDaily;
    } else {
        QL_FAIL("PriceSegment::Type '" << s << "' not known, expect "
                                       << "'Future', 'AveragingFuture' or 'AveragingSpot'");
    }
}

Here is the caller graph for this function:

◆ operator<<() [66/73]

std::ostream & operator<<	(	ostream &	os,
		PriceSegment::Type	pst
	)

Write PriceSegment::Type to stream.

Definition at line 1175 of file parsers.cpp.

                                                       {
    if (pst == PST::Future) {
        return os << "Future";
    } else if (pst == PST::AveragingFuture) {
        return os << "AveragingFuture";
    } else if (pst == PST::AveragingSpot) {
        return os << "AveragingSpot";
    } else if (pst == PST::AveragingOffPeakPower) {
        return os << "AveragingOffPeakPower";
    } else if (pst == PST::OffPeakPowerDaily) {
        return os << "OffPeakPowerDaily";
    } else {
        QL_FAIL("Unknown PriceSegment::Type.");
    }
}

◆ parseCommodityQuantityFrequency()

QuantExt::CommodityQuantityFrequency parseCommodityQuantityFrequency ( const string & s )

Convert text to QuantExt::CommodityQuantityFrequency.

Definition at line 1192 of file parsers.cpp.

                                                                            {
    if (iequals(s, "PerCalculationPeriod")) {
        return CQF::PerCalculationPeriod;
    } else if (iequals(s, "PerCalendarDay")) {
        return CQF::PerCalendarDay;
    } else if (iequals(s, "PerPricingDay")) {
        return CQF::PerPricingDay;
    } else if (iequals(s, "PerHour")) {
        return CQF::PerHour;
    } else if (iequals(s, "PerHourAndCalendarDay")) {
        return CQF::PerHourAndCalendarDay;
    } else {
        QL_FAIL("Could not parse " << s << " to CommodityQuantityFrequency");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator<<() [67/73]

std::ostream & operator<<	(	ostream &	os,
		CommodityQuantityFrequency	cqf
	)

Write QuantExt::CommodityQuantityFrequency to stream.

Definition at line 1208 of file parsers.cpp.

                                                                 {
    if (cqf == CQF::PerCalculationPeriod) {
        return os << "PerCalculationPeriod";
    } else if (cqf == CQF::PerCalendarDay) {
        return os << "PerCalendarDay";
    } else if (cqf == CQF::PerPricingDay) {
        return os << "PerPricingDay";
    } else if (cqf == CQF::PerHour) {
        return os << "PerHour";
    } else if (cqf == CQF::PerHourAndCalendarDay) {
        return os << "PerHourAndCalendarDay";
    } else {
        QL_FAIL("Do not recognise CommodityQuantityFrequency " << static_cast<int>(cqf));
    }
}

◆ operator<<() [68/73]

ostream & operator<<	(	ostream &	os,
		Rounding::Type	t
	)

Definition at line 1224 of file parsers.cpp.

                                                 {
    static map<Rounding::Type, string> m = {{Rounding::Type::Up, "Up"},
                                            {Rounding::Type::Down, "Down"},
                                            {Rounding::Type::Closest, "Closest"},
                                            {Rounding::Type::Floor, "Floor"},
                                            {Rounding::Type::Ceiling, "Ceiling"}};
    auto it = m.find(t);
    if (it != m.end()) {
        return os << it->second;
    } else {
        QL_FAIL("Internal error: unknown Rounding::Type - check implementation of operator<< "
                "for this enum");
    }
}

◆ operator<<() [69/73]

std::ostream & operator<<	(	std::ostream &	os,
		QuantExt::BondIndex::PriceQuoteMethod	p
	)

Write PriceQuoteMethod to stream.

Definition at line 1271 of file parsers.cpp.

                                                                            {
    if (p == QuantExt::BondIndex::PriceQuoteMethod::PercentageOfPar)
        os << "PercentageOfPar";
    else if (p == QuantExt::BondIndex::PriceQuoteMethod::CurrencyPerUnit)
        os << "CurrencyPerUnit";
    else
        os << "Unknown PriceQuoteMethod (" << static_cast<int>(p) << ")";
    return os;
}

◆ getCorrelationTokens()

std::vector< std::string > getCorrelationTokens ( const std::string & name )

Helper function to get the two tokens in a correlation name Index2:Index1.

Definition at line 1281 of file parsers.cpp.

                                                                 {
    // Look for & first as it avoids collisions with : which can be used in an index name
    // if it is not there we fall back on the old behaviour
    string delim;
    if (name.find('&') != std::string::npos)
        delim = "&";
    else
        delim = "/:,";
    vector<string> tokens;
    boost::split(tokens, name, boost::is_any_of(delim));
    QL_REQUIRE(tokens.size() == 2,
               "invalid correlation name '" << name << "', expected Index2:Index1 or Index2/Index1 or Index2&Index1");
    return tokens;
}

Here is the caller graph for this function:

◆ normaliseFxIndex()

string normaliseFxIndex ( const std::string & indexName )

Convert FX index name to market standard dominance.

Definition at line 1351 of file parsers.cpp.

                                                    {
    auto fx = ore::data::parseFxIndex(indexName);
    std::string ccy1 = fx->sourceCurrency().code();
    std::string ccy2 = fx->targetCurrency().code();
    if (ore::data::fxDominance(ccy1, ccy2) != ccy1 + ccy2)
        return ore::data::inverseFxIndex(indexName);
    else
        return indexName;
}

Here is the call graph for this function:

◆ parseCreditPortfolioSensitivityDecomposition()

CreditPortfolioSensitivityDecomposition parseCreditPortfolioSensitivityDecomposition ( const std::string & s )

Convert text to CreditPortfolioSensitivitiyDecomposition.

Definition at line 1374 of file parsers.cpp.

                                                                                                         {
    if (s == "Underlying") {
        return CreditPortfolioSensitivityDecomposition::Underlying;
    } else if (s == "NotionalWeighted") {
        return CreditPortfolioSensitivityDecomposition::NotionalWeighted;
    } else if (s == "LossWeighted") {
        return CreditPortfolioSensitivityDecomposition::LossWeighted;
    } else if (s == "DeltaWeighted") {
        return CreditPortfolioSensitivityDecomposition::DeltaWeighted;
    } else {
        QL_FAIL("CreditPortfolioSensitivityDecomposition '"
                << s << "' invalid, expected Underlying, NotionalWeighted, LossWeighted, DeltaWeighted");
    }
}

Here is the caller graph for this function:

◆ operator<<() [70/73]

std::ostream & operator<<	(	std::ostream &	os,
		const CreditPortfolioSensitivityDecomposition	d
	)

Output operator for CreditPortfolioSensitivityDecomposition.

Definition at line 1389 of file parsers.cpp.

                                                                                        {
    if (d == CreditPortfolioSensitivityDecomposition::Underlying) {
        return os << "Underlying";
    } else if (d == CreditPortfolioSensitivityDecomposition::NotionalWeighted) {
        return os << "NotionalWeighted";
    } else if (d == CreditPortfolioSensitivityDecomposition::LossWeighted) {
        return os << "LossWeighted";
    } else if (d == CreditPortfolioSensitivityDecomposition::DeltaWeighted) {
        return os << "DeltaWeighted";
    } else {
        QL_FAIL("Unknonw CreditPortfolioSensitivitiyDecomposition value " << static_cast<std::size_t>(d));
    }
}

◆ operator<<() [71/73]

std::ostream & operator<<	(	std::ostream &	out,
		SabrParametricVolatility::ModelVariant	m
	)

Definition at line 1478 of file parsers.cpp.

                                                                                {
    if (m == SabrParametricVolatility::ModelVariant::Hagan2002Lognormal) {
        out << "Hagan2002Lognormal";
    } else if (m == SabrParametricVolatility::ModelVariant::Hagan2002Normal) {
        out << "Hagan2002Normal";
    } else if (m == SabrParametricVolatility::ModelVariant::Hagan2002NormalZeroBeta) {
        out << "Hagan200NormalZeroBeta";
    } else if (m == SabrParametricVolatility::ModelVariant::Antonov2015FreeBoundaryNormal) {
        out << "AntonovNormalZeroBeta";
    } else if (m == SabrParametricVolatility::ModelVariant::KienitzLawsonSwaynePde) {
        out << "KienitzLawsonSwaynePde";
    } else if (m == SabrParametricVolatility::ModelVariant::FlochKennedy) {
        out << "FlochKennedy";
    } else {
        QL_FAIL("SabrParametricVolatility::ModelVariant (" << static_cast<int>(m)
                                                           << ") not recognized. This is an internal error.");
    }
    return out;
}

◆ operator<<() [72/73]

std::ostream & operator<<	(	std::ostream &	os,
		Exercise::Type	type
	)

Definition at line 1498 of file parsers.cpp.

                                                          {
    if (type == Exercise::European) {
        os << "European";
    } else if (type == Exercise::Bermudan) {
        os << "Bermudan";
    } else if (type == Exercise::American) {
        os << "American";
    } else {
        QL_FAIL("Exercise::Type (" << static_cast<int>(type)
                                   << " not recognized. Expected 'European', 'Bermudan', or 'American'.");
    }
 
    return os;
}

◆ parseVectorOfValues()

std::vector< T > parseVectorOfValues	(	std::vector< std::string >	str,
		std::function< T(string)>	parser
	)

Definition at line 335 of file parsers.hpp.

                                                                                                             {
    std::vector<T> vec;
    for (auto s : str) {
        vec.push_back(parser(s));
    }
    return vec;
}

◆ tryParseCurrency()

bool tryParseCurrency	(	const std::string &	str,
		Currency &	obj
	)

Definition at line 438 of file parsers.hpp.

                                                                  {
    DLOG("tryParse: attempting to parse currency from " << str);
    try {
        obj = parseCurrency(str);
    } catch (...) {
        TLOG("String " << str << " could not be parsed");
        return false;
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator<<() [73/73]

std::ostream & operator<<	(	std::ostream &	out,
		const TimePeriod &	t
	)

Definition at line 50 of file timeperiod.cpp.

                                                             {
    for (Size i = 0; i < t.numberOfContiguousParts(); ++i) {
        out << QuantLib::io::iso_date(t.startDates()[i]) << " to " << QuantLib::io::iso_date(t.endDates()[i]);
        if (i < t.numberOfContiguousParts() - 1)
            out << " + ";
    }
    return out;
}

Here is the call graph for this function:

◆ totalTimePeriod()

TimePeriod totalTimePeriod	(	std::vector< std::string >	timePeriods,
		Size	mporDays,
		const QuantLib::Calendar &	calendar
	)

Definition at line 59 of file timeperiod.cpp.

                                                                                                              {
    vector<Date> allDates;
    for (const string& s : timePeriods) {
        auto dates = parseListOfValues<Date>(s, &parseDate);
        for (const auto& d : dates)
            allDates.push_back(d);
    }
 
    TimePeriod period(allDates);
 
    Date minDate = *std::min_element(period.startDates().begin(), period.startDates().end());
    Date maxDate = *std::max_element(period.endDates().begin(), period.endDates().end());
 
    vector<Date> finalDates;
    finalDates.push_back(minDate);
    finalDates.push_back(maxDate);
 
    TimePeriod totalPeriod(finalDates, mporDays, calendar);
    return totalPeriod;
}

Here is the call graph for this function:

◆ to_string() [3/4]

std::string to_string ( const Date & date )

Definition at line 43 of file to_string.cpp.

                                      {
    if (date == Date())
        return "1901-01-01";
 
    char buf[11];
    int y = date.year();
    int m = static_cast<int>(date.month());
    int d = date.dayOfMonth();
 
    int n = snprintf(buf, sizeof(buf), "%04d-%02d-%02d", y, m, d);
    QL_REQUIRE(n == 10, "Failed to convert date " << date << " to_string() n:" << n);
    return std::string(buf);
}

Here is the call graph for this function:

◆ to_string() [4/4]

std::string to_string ( const Period & period )

Definition at line 59 of file to_string.cpp.

                                          {
    Integer n = period.length();
    Integer m = 0;
    std::ostringstream o;
    switch (period.units()) {
    case Days:
        if (n>=7) {
        m = n/7;
        o << m << "W";
        n = n%7;
    }
    if (n != 0 || m == 0) {
        o << n << "D";
        return o.str();
    }
    else {
        return o.str();
    }
    case Weeks: {
        o << n << "W";
    return o.str();
    }
    case Months:
        if (n>=12) {
        m = n/12;
        o << n/12 << "Y";
        n = n%12;
    }
    if (n != 0 || m == 0) {
        o << n << "M";
        return o.str();
    }
    else {
        return o.str();
    }
    case Years: {
        o << n << "Y";
    return o.str();
    }
    default:
        ALOG("unknown time unit (" << Integer(period.units()) << ")");
    o << period;
    return o.str();
    }
}

Here is the call graph for this function:

◆ partitionQuotes() [1/2]

void partitionQuotes	(	const set< string > &	quoteNames,
		set< string > &	names,
		set< string > &	regexes
	)

Definition at line 96 of file wildcard.cpp.

                                                                                              {
 
    for (const string& n : quoteNames) {
        ore::data::Wildcard w(n, false);
        if (w.hasWildcard())
            regexes.insert(w.regex());
        else
            names.insert(n);
    }
}

Here is the call graph for this function:

◆ partitionQuotes() [2/2]

void partitionQuotes	(	const set< string > &	quoteNames,
		set< string > &	names,
		set< string > &	regexes,
		std::set< std::string > &	prefixes,
		const bool	aggressivePrefixes
	)

Definition at line 107 of file wildcard.cpp.

                                                                                 {
 
    for (const string& n : quoteNames) {
        ore::data::Wildcard w(n, true, aggressivePrefixes);
        if (w.hasWildcard()) {
            if (w.isPrefix())
                prefixes.insert(w.prefix());
            else
                regexes.insert(w.regex());
        } else
            names.insert(n);
    }
}

Here is the call graph for this function:

◆ getUniqueWildcard()

boost::optional< Wildcard > getUniqueWildcard ( const C & c )

checks if at most one element in C has a wild card and returns it in this case

Definition at line 65 of file wildcard.hpp.

                                                                         {
    for (auto const& a : c) {
        Wildcard w(a);
        if (w.hasWildcard()) {
            QL_REQUIRE(c.size() == 1, "If wild cards are used, only one entry should exist.");
            return w;
        }
    }
    return boost::none;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ volatilityTypeMap

const BmType volatilityTypeMap

Initial value:

=
    list_of<BmType::value_type>("Normal", CapFloorVolatilityCurveConfig::VolatilityType::Normal)(
        "Lognormal", CapFloorVolatilityCurveConfig::VolatilityType::Lognormal)(
        "ShiftedLognormal", CapFloorVolatilityCurveConfig::VolatilityType::ShiftedLognormal)

Definition at line 45 of file capfloorvolcurveconfig.cpp.

◆ validInterps

const set<string> validInterps = {"Linear", "LinearFlat", "BackwardFlat", "Cubic", "CubicFlat"}

Definition at line 52 of file capfloorvolcurveconfig.cpp.

◆ types

boost::bimap<std::string, TRS::FundingData::NotionalType> types

Initial value:

= boost::assign::list_of<boost::bimap<std::string, TRS::FundingData::NotionalType>::relation>
    ("PeriodReset", TRS::FundingData::NotionalType::PeriodReset)
    ("DailyReset", TRS::FundingData::NotionalType::DailyReset)
    ("Fixed", TRS::FundingData::NotionalType::Fixed)

Definition at line 783 of file trs.cpp.

◆ xccyCurveNamePrefix

const std::string xccyCurveNamePrefix = "__XCCY__"

Definition at line 37 of file marketdata.cpp.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Compare <code>CorrelationFactor</code>s.

Detailed Description

Typedef Documentation

◆ BmType

◆ YieldCurveConfigMap

◆ Crv

◆ BS

◆ Helpers

◆ CachingPricingEngineBuilder

◆ CachingCouponPricerBuilder

◆ CachingInflationCouponPricerBuilder

◆ CachingInflationCashFlowPricerBuilder

◆ ASI

◆ EquityPositionTrsUnderlyingBuilder

◆ CommodityPositionTrsUnderlyingBuilder

◆ PaymentLag

◆ ASTNodePtr

◆ ScriptGrammarIterator

◆ ValueType

◆ CorrelationKey

◆ file_sink

◆ text_sink

◆ ADCP

◆ PST

◆ CQF

◆ XMLNode

Enumeration Type Documentation

◆ YieldCurveType

◆ MarketObject

◆ ParamType

◆ CalibrationType

◆ CalibrationStrategy

◆ CommodityPayRelativeTo

◆ CommodityPriceType

◆ CommodityPricingDateRule

◆ CdsTier

◆ CdsDocClause

◆ IsdaRulesDefinitions

◆ CreditEventType

◆ CreditEventTiers

◆ MarketContext

◆ AmortizationType

◆ AssetClass

◆ Extrapolation

◆ MomentType

◆ CreditPortfolioSensitivityDecomposition

◆ MporCashFlowMode

Function Documentation

◆ volatilityType()

◆ operator<() [1/14]

◆ operator<<() [1/73]

◆ operator<<() [2/73]

◆ operator<<() [3/73]

◆ indexNameLessThan()

◆ addMinimalCurves()

◆ operator<<() [4/73]

◆ parseEquityCurveConfigType()

◆ operator<<() [5/73]

◆ operator<<() [6/73]

◆ operator<<() [7/73]

◆ effectiveReportConfig()

◆ operator<() [2/14]

◆ parseYieldCurveSegment()

◆ interpOnOpt()

◆ makeDummyMarketDatum()

◆ operator<() [3/14]

◆ operator==() [1/13]

◆ operator<() [4/14]

◆ operator==() [2/13]

◆ operator<<() [8/73]

◆ operator<<() [9/73]

◆ operator==() [3/13]

◆ operator<<() [10/73]

◆ parseExpiry()