QuantLib
A free/open-source library for quantitative finance
Reference manual - version 1.12
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234567]
 CBoundaryCondition< FdmLinearOp >
 ▶CBoundaryCondition< TridiagonalOperator >
 CClone< ExerciseStrategy< QuantLib::CurveState > >
 CClone< MarketModelBasisSystem >
 CClone< MarketModelExerciseValue >
 CClone< MarketModelParametricExercise >
 CClone< QuantLib::FittedBondDiscountCurve::FittingMethod >
 CClone< QuantLib::MarketModelMultiProduct >
 CClone< QuantLib::MarketModelPathwiseMultiProduct >
 ▶CCuriouslyRecurringTemplate< AdditiveEQPBinomialTree >
 ▶CCuriouslyRecurringTemplate< Bisection >
 ▶CCuriouslyRecurringTemplate< BlackScholesLattice< T > >
 ▶CCuriouslyRecurringTemplate< Brent >
 ▶CCuriouslyRecurringTemplate< CoxRossRubinstein >
 ▶CCuriouslyRecurringTemplate< ExtendedAdditiveEQPBinomialTree >
 ▶CCuriouslyRecurringTemplate< ExtendedCoxRossRubinstein >
 ▶CCuriouslyRecurringTemplate< ExtendedJarrowRudd >
 ▶CCuriouslyRecurringTemplate< ExtendedJoshi4 >
 ▶CCuriouslyRecurringTemplate< ExtendedLeisenReimer >
 ▶CCuriouslyRecurringTemplate< ExtendedTian >
 ▶CCuriouslyRecurringTemplate< ExtendedTrigeorgis >
 ▶CCuriouslyRecurringTemplate< FalsePosition >
 ▶CCuriouslyRecurringTemplate< FiniteDifferenceNewtonSafe >
 ▶CCuriouslyRecurringTemplate< JarrowRudd >
 ▶CCuriouslyRecurringTemplate< Joshi4 >
 ▶CCuriouslyRecurringTemplate< LeisenReimer >
 ▶CCuriouslyRecurringTemplate< Newton >
 ▶CCuriouslyRecurringTemplate< NewtonSafe >
 ▶CCuriouslyRecurringTemplate< OneFactorModel::ShortRateTree >
 ▶CCuriouslyRecurringTemplate< Ridder >
 ▶CCuriouslyRecurringTemplate< Secant >
 ▶CCuriouslyRecurringTemplate< T >
 ▶CCuriouslyRecurringTemplate< Tian >
 ▶CCuriouslyRecurringTemplate< Trigeorgis >
 ▶CCuriouslyRecurringTemplate< TrinomialTree >
 ▶CCuriouslyRecurringTemplate< TwoFactorModel::ShortRateTree >
 CEarlyExercisePathPricer< MultiPath >
 CEarlyExercisePathPricer< Path >
 CForwardOptionArguments< VanillaOption::arguments >
 CHandle< AffineModel >
 CHandle< BatesModel >
 CHandle< FdmQuantoHelper >
 CHandle< G2 >
 CHandle< Gaussian1dModel >
 CHandle< GJRGARCHModel >
 CHandle< HestonModel >
 CHandle< HullWhite >
 CHandle< LiborForwardModel >
 CHandle< ModelType >
 CHandle< OneFactorAffineModel >
 CHandle< PiecewiseTimeDependentHestonModel >
 CHandle< QuantLib::AbcdAtmVolCurve >
 CHandle< QuantLib::BaseCorrelationTermStructure< Corr2DInt_T > >
 ▶CHandle< QuantLib::Basket >
 CHandle< QuantLib::BatesProcess >
 CHandle< QuantLib::BlackAtmVolCurve >
 CHandle< QuantLib::BlackVarianceCurve >
 CHandle< QuantLib::BlackVolTermStructure >
 CHandle< QuantLib::CallableBondVolatilityStructure >
 CHandle< QuantLib::CapFloorTermVolCurve >
 CHandle< QuantLib::CPICapFloorTermPriceSurface >
 CHandle< QuantLib::CPIVolatilitySurface >
 ▶CHandle< QuantLib::DefaultProbabilityTermStructure >
 CHandle< QuantLib::DeltaVolQuote >
 CHandle< QuantLib::ExtendedOrnsteinUhlenbeckProcess >
 CHandle< QuantLib::ExtOUWithJumpsProcess >
 CHandle< QuantLib::G2 >
 CHandle< QuantLib::GeneralizedBlackScholesProcess >
 CHandle< QuantLib::HestonModel >
 CHandle< QuantLib::HestonProcess >
 CHandle< QuantLib::HullWhite >
 CHandle< QuantLib::HullWhiteProcess >
 CHandle< QuantLib::InterestRateVolSurface >
 CHandle< QuantLib::KlugeExtOUProcess >
 ▶CHandle< QuantLib::LocalVolTermStructure >
 CHandle< QuantLib::OneFactorCopula >
 CHandle< QuantLib::OptionletVolatilityStructure >
 CHandle< QuantLib::PricingEngine >
 ▶CHandle< QuantLib::Quote >
 CHandle< QuantLib::RecoveryRateQuote >
 CHandle< QuantLib::SwaptionVolatilityStructure >
 ▶CHandle< QuantLib::YieldTermStructure >
 CHandle< QuantLib::YoYInflationTermStructure >
 CHandle< QuantLib::YoYOptionletVolatilitySurface >
 CHandle< QuantLib::ZeroInflationIndex >
 CHandle< QuantLib::ZeroInflationTermStructure >
 CHandle< ShortRateModel >
 CHandle< YieldTermStructure >
 ▶CInterpolatedCurve< Interpolator1D >
 CInverseCumulativeRsg< QuantLib::SobolRsg, QuantLib::InverseCumulativeNormal >
 ▶CMcSimulation< MultiVariate, RNG, S >
 ▶CMcSimulation< MultiVariate, RNG, Statistics >
 ▶CMcSimulation< SingleVariate, RNG, S >
 CObservableValue< Date >
 CObservableValue< TimeSeries< Real > >
 ▶CPathPricer< MultiPath >
 CPathPricer< Path >
 ▶CPathPricer< PathType >
 CAbcdAbcd interpolation factory and traits
 ▶CAbcdMathFunctionAbcd functional form
 CAccountingEngineEngine collecting cash flows along a market-model simulation
 CAcyclicVisitorDegenerate base class for the Acyclic Visitor pattern
 CAffineHazardRate
 CAliMikhailHaqCopulaAli-Mikhail-Haq copula
 CAmericanConditionAmerican exercise condition
 CAmericanPayoffAtExpiryAnalytic formula for American exercise payoff at-expiry options
 CAmericanPayoffAtHitAnalytic formula for American exercise payoff at-hit options
 ▶CAnalyticDigitalAmericanEngineAnalytic pricing engine for American vanilla options with digital payoff
 CAnalyticEuropeanEnginePricing engine for European vanilla options using analytical formulae
 CAnalyticTwoAssetCorrelationEngineAnalytic two-asset correlation option engine
 CAoniaAonia index
 CArray1-D array used in linear algebra
 CAssetSwap::argumentsArguments for asset swap calculation
 CAssetSwap::resultsResults from simple swap calculation
 CASXMain cycle of the Australian Securities Exchange (a.k.a. ASX) months
 CAtomicDefaultAtomic (single contractual event) default events
 CAveragePlaceholder for enumerated averaging types
 CAverageBMALegHelper class building a sequence of average BMA coupons
 CBackwardFlatBackward-flat interpolation factory and traits
 CBaroneAdesiWhaleyApproximationEngineBarone-Adesi and Whaley pricing engine for American options (1987)
 CBarrierPlaceholder for enumerated barrier types
 ▶CBarrierOption::argumentsArguments for barrier option calculation
 CBernsteinPolynomialClass of Bernstein polynomials
 CBFGSBroyden-Fletcher-Goldfarb-Shanno algorithm
 CBicubicBicubic-spline-interpolation factory
 CBilinearBilinear-interpolation factory
 CBinomialConvertibleEngine< T >Binomial Tsiveriotis-Fernandes engine for convertible bonds
 CBinomialDistributionBinomial probability distribution function
 CBinomialProbabilityOfAtLeastNEventsProbability of at least N events
 CBinomialVanillaEngine< T >Pricing engine for vanilla options using binomial trees
 CBivariateCumulativeNormalDistributionDr78Cumulative bivariate normal distribution function
 CBivariateCumulativeNormalDistributionWe04DPCumulative bivariate normal distibution function (West 2004)
 CBivariateCumulativeStudentDistributionCumulative Student t-distribution
 CBjerksundStenslandApproximationEngineBjerksund and Stensland pricing engine for American options (1993)
 ▶CBlackCalculatorBlack 1976 calculator class
 CBlackDeltaCalculatorBlack delta calculator class
 CBondFunctionsBond adapters of CashFlows functions
 CBootstrapError< Curve >Bootstrap error
 CBoundaryCondition< Operator >Abstract boundary condition class for finite difference problems
 CBoxMullerGaussianRng< RNG >Gaussian random number generator
 CBrownianBridgeBuilds Wiener process paths using Gaussian variates
 CBSplineB-spline basis functions
 ▶CCalendarcalendar class
 ▶CCalendar::ImplAbstract base class for calendar implementations
 CCallability::PriceAmount to be paid upon callability
 CCallableBond::resultsResults for a callable bond calculation
 CCapFloor::argumentsArguments for cap/floor calculation
 CCapPseudoDerivative
 CCashFlowscashflow-analysis functions
 CCatBond::resultsResults for a cat bond calculation
 CCdsOption::resultsResults from CDS-option calculation
 CClaytonCopulaClayton copula
 CClaytonCopulaRng< RNG >Clayton copula random-number generator
 CCLGaussianRng< RNG >Gaussian random number generator
 CClone< T >Cloning proxy to an underlying object
 CCmsLegHelper class building a sequence of capped/floored cms-rate coupons
 CCMSMMDriftCalculatorDrift computation for CMS market models
 CCmsSpreadLegHelper class building a sequence of capped/floored cms-spread-rate coupons
 CCommodityPricingHelperCommodity index helper
 CCommodityTypeCommodity type
 CComposite< T >Composite pattern
 CConjugateGradientMulti-dimensional Conjugate Gradient class
 CConstantEstimatorConstant-estimator volatility model
 ▶CConstraintBase constraint class
 CConstraint::ImplBase class for constraint implementations
 CContinuousAveragingAsianOption::argumentsExtra arguments for single-asset continuous-average Asian option
 ▶CContinuousFixedLookbackOption::argumentsArguments for continuous fixed lookback option calculation
 ▶CContinuousFloatingLookbackOption::argumentsArguments for continuous floating lookback option calculation
 CConvergenceStatistics< T, U >Statistics class with convergence table
 CConvexMonotoneConvex-monotone interpolation factory and traits
 ▶CCostFunctionCost function abstract class for optimization problem
 CCounterpartyAdjSwapEngine
 CCovarianceDecompositionCovariance decomposition into correlation and variances
 CCPILegHelper class building a sequence of capped/floored CPI coupons
 CCPISwap::argumentsArguments for swap calculation
 CCPISwap::resultsResults from swap calculation
 CCreditRiskPlus
 CCubicCubic interpolation factory and traits
 CCumulativeBehrensFisherCumulative (generalized) BehrensFisher distribution
 CCumulativeBinomialDistributionCumulative binomial distribution function
 CCumulativeNormalDistributionCumulative normal distribution function
 CCumulativePoissonDistributionCumulative Poisson distribution function
 CCumulativeStudentDistributionCumulative Student t-distribution
 ▶CCuriouslyRecurringTemplate< Impl >Support for the curiously recurring template pattern
 ▶CCurrencyCurrency specification
 CCurveAbstract curve class
 ▶CCurveStateCurve state for market-model simulations
 CDateConcrete date class
 CDateGenerationDate-generation rule
 ▶CDateIntervalDate interval described by a number of a given time unit
 ▶CDayCounterDay counter class
 CDayCounter::ImplAbstract base class for day counter implementations
 CDefaultDensityDefault-density-curve traits
 ▶CDefaultProbKey
 ▶CDefaultTypeAtomic credit-event type
 CImpliedVolatilityHelperHelper class for one-asset implied-volatility calculation
 CRootUtility for the numerical time solver
 CDigitalCmsLegHelper class building a sequence of digital ibor-rate coupons
 CDigitalCmsSpreadLegHelper class building a sequence of digital ibor-rate coupons
 CDigitalIborLegHelper class building a sequence of digital ibor-rate coupons
 CDiscountDiscount-curve traits
 CDiscreteAveragingAsianOption::argumentsExtra arguments for single-asset discrete-average Asian option
 CDiscreteTrapezoidIntegral
 ▶CDiscretizedAssetDiscretized asset class used by numerical methods
 CDisposable< T >Generic disposable object with move semantics
 CDividendVanillaOption::argumentsArguments for dividend vanilla option calculation
 CDoubleBarrierPlaceholder for enumerated barrier types
 CDoubleBarrierOption::argumentsArguments for double barrier option calculation
 CDurationduration type
 Cearlier_than< T >Compare two objects by date
 CEarlyExercisePathPricer< PathType, TimeType, ValueType >Base class for early exercise path pricers
 CECBEuropean Central Bank reserve maintenance dates
 CEndCriteriaCriteria to end optimization process:
 CEnergyBasisSwapEnergy basis swap
 CEnergyVanillaSwapVanilla energy swap
 CEoniaEonia (Euro Overnight Index Average) rate fixed by the ECB
 CErrorFunctionError function
 CEvolutionDescriptionMarket-model evolution description
 CExchangeRateExchange rate between two currencies
 ▶CExerciseBase exercise class
 CExponentialJump1dMesher
 ▶CExtrapolatorBase class for classes possibly allowing extrapolation
 CFactorialFactorial numbers calculator
 CFarlieGumbelMorgensternCopulaFarlie-Gumbel-Morgenstern copula
 CFarlieGumbelMorgensternCopulaRng< RNG >Farlie-Gumbel-Morgenstern copula random-number generator
 CFastFourierTransformFFT implementation
 CFaureRsgFaure low-discrepancy sequence generator
 CFDAmericanEngine< Scheme >Finite-differences pricing engine for American one asset options
 CFDBermudanEngine< Scheme >Finite-differences Bermudan engine
 CFDDividendAmericanEngine< Scheme >Finite-differences pricing engine for dividend American options
 ▶CFDDividendEngineBase< Scheme >Abstract base class for dividend engines
 CFDDividendEuropeanEngine< Scheme >Finite-differences pricing engine for dividend European options
 CFDDividendShoutEngine< Scheme >Finite-differences shout engine with dividends
 CFdmExtOUJumpOp
 CFdmKlugeExtOUOp
 CFDShoutEngine< Scheme >Finite-differences pricing engine for shout vanilla options
 ▶CFDVanillaEngineFinite-differences pricing engine for BSM one asset options
 CFedFundsFed Funds rate fixed by the FED
 ▶CFFTEngineBase class for FFT pricing engines for European vanilla options
 CFilonIntegralIntegral of a one-dimensional function
 CFiniteDifferenceModel< Evolver >Generic finite difference model
 ▶CFittedBondDiscountCurve::FittingMethodBase fitting method used to construct a fitted bond discount curve
 CFixedRateLegHelper class building a sequence of fixed rate coupons
 ▶CFloatFloatSwap::argumentsArguments for float float swap calculation
 CFloatFloatSwap::resultsResults from float float swap calculation
 CFloatingCatBondFloating-rate cat bond (possibly capped and/or floored)
 CForwardFlatForward-flat interpolation factory and traits
 CForwardOptionArguments< ArgumentsType >Arguments for forward (strike-resetting) option calculation
 CForwardRateForward-curve traits
 CFrankCopulaFrank copula
 CFrankCopulaRng< RNG >Frank copula random-number generator
 CGalambosCopulaGalambos copula
 CGammaFunctionGamma function class
 CGarch11GARCH volatility model
 CGarmanKlassAbstractGarman-Klass volatility model
 CGaussianCopulaGaussian copula
 CGaussianCopulaPolicy
 ▶CGaussianOrthogonalPolynomialOrthogonal polynomial for Gaussian quadratures
 CGaussianQuadMultidimIntegratorIntegrates a vector or scalar function of vector domain
 ▶CGaussianQuadratureIntegral of a 1-dimensional function using the Gauss quadratures method
 CGaussKronrodAdaptiveIntegral of a 1-dimensional function using the Gauss-Kronrod methods
 CGaussKronrodNonAdaptiveIntegral of a 1-dimensional function using the Gauss-Kronrod methods
 CGaussLobattoIntegralIntegral of a one-dimensional function
 CGeneralizedHullWhite::DynamicsShort-rate dynamics in the generalized Hull-White model
 CGeneralLinearLeastSquaresGeneral linear least squares regression
 CGeneralStatisticsStatistics tool
 CGenericGaussianStatistics< Stat >Statistics tool for gaussian-assumption risk measures
 CGenericRiskStatistics< S >Empirical-distribution risk measures
 ▶CGenericSequenceStatistics< StatisticsType >Statistics analysis of N-dimensional (sequence) data
 CGMRESResult
 ▶CGreeksAdditional option results
 CGumbelCopulaGumbel copula
 CHaltonRsgHalton low-discrepancy sequence generator
 ▶CHandle< T >Shared handle to an observable
 CHazardRateHazard-rate-curve traits
 ▶CHestonExpansion
 CHestonRNDCalculatorRisk neutral terminal probability density for the Heston model
 CHistogramHistogram class
 CHistoricalForwardRatesAnalysisImpl< Traits, Interpolator >Historical correlation class
 CHistoricalRatesAnalysisHistorical rate analysis class
 CHuslerReissCopulaHusler-Reiss copula
 CIborLegHelper class building a sequence of capped/floored ibor-rate coupons
 CIMMMain cycle of the International Money Market (a.k.a. IMM) months
 CIncrementalStatisticsStatistics tool based on incremental accumulation
 CIndependentCopulaIndependent copula
 CIntegralEnginePricing engine for European vanilla options using integral approach
 CInterestRateConcrete interest rate class
 ▶CInterpolatedCurve< Interpolator >Helper class to build interpolated term structures
 CInterpolatingCPICapFloorEngine
 ▶CInterpolation2D::ImplAbstract base class for 2-D interpolation implementations
 ▶CInterpolation::ImplAbstract base class for interpolation implementations
 CIntervalPriceInterval price
 CInverseCumulativeBehrensFisherInverse of the cumulative of the convolution of odd-T distributions
 CInverseCumulativeNormalInverse cumulative normal distribution function
 CInverseCumulativePoissonInverse cumulative Poisson distribution function
 CInverseCumulativeRng< RNG, IC >Inverse cumulative random number generator
 CInverseCumulativeRsg< USG, IC >Inverse cumulative random sequence generator
 CInverseCumulativeStudentInverse cumulative Student t-distribution
 CIrregularSettlementsettlement information
 ▶CIrregularSwap::argumentsArguments for irregular-swap calculation
 CIrregularSwap::resultsResults from irregular-swap calculation
 CIsdaCdsEngine
 CIsotropicRandomWalk< Distribution, Engine >Isotropic random walk
 CIterativeBootstrap< Curve >Universal piecewise-term-structure boostrapper
 CJumpDiffusionEngineJump-diffusion engine for vanilla options
 CJuQuadraticApproximationEnginePricing engine for American options with Ju quadratic approximation
 ▶CKernelFunction
 CKnuthUniformRngUniform random number generator
 CLatentModel< copulaPolicyImpl >::FactorSampler< USNG, bool >
 ▶CLatticeLattice (tree, finite-differences) base class
 CLeastSquareProblemBase class for least square problem
 CLecuyerUniformRngUniform random number generator
 CLexicographicalView< RandomAccessIterator >Lexicographical 2-D view of a contiguous set of data
 ▶CLfmCovarianceParameterizationLibor market model parameterization
 CLinearLinear-interpolation factory and traits
 ▶CLineSearchBase class for line search
 ▶CLmCorrelationModellibor forward correlation model
 CLMMDriftCalculatorDrift computation for log-normal Libor market models
 CLMMNormalDriftCalculatorDrift computation for normal Libor market models
 ▶CLmVolatilityModelCaplet volatility model
 CLocalBootstrap< Curve >Localised-term-structure bootstrapper for most curve types
 CLogCubicLog-cubic interpolation factory and traits
 CLogLinearLog-linear interpolation factory and traits
 CLogMixedLinearCubicLog-cubic interpolation factory and traits
 ▶CLossDistProbability formulas and algorithms
 CMaddockCumulativeNormalMaddock's cumulative normal distribution class
 CMaddockInverseCumulativeNormalMaddock's Inverse cumulative normal distribution class
 CMakeArithmeticAverageOISHelper class
 CMakeCapFloorHelper class
 CMakeCmsHelper class for instantiating CMS
 CMakeCreditDefaultSwapHelper class
 CMakeMCAmericanBasketEngine< RNG >Monte Carlo American basket-option engine factory
 CMakeMCAmericanEngine< RNG, S, RNG_Calibration >Monte Carlo American engine factory
 CMakeMCAmericanPathEngine< RNG >Monte Carlo American basket-option engine factory
 CMakeMCBarrierEngine< RNG, S >Monte Carlo barrier-option engine factory
 CMakeMCDigitalEngine< RNG, S >Monte Carlo digital engine factory
 CMakeMCEuropeanBasketEngine< RNG, S >Monte Carlo basket-option engine factory
 CMakeMCEuropeanEngine< RNG, S >Monte Carlo European engine factory
 CMakeMCEuropeanGJRGARCHEngine< RNG, S >Monte Carlo GJR-GARCH European engine factory
 CMakeMCEuropeanHestonEngine< RNG, S, P >Monte Carlo Heston European engine factory
 CMakeMCEverestEngine< RNG, S >Monte Carlo Everest-option engine factory
 CMakeMCHestonHullWhiteEngine< RNG, S >Monte Carlo Heston/Hull-White engine factory
 CMakeMCHimalayaEngine< RNG, S >Monte Carlo Himalaya-option engine factory
 CMakeMCHullWhiteCapFloorEngine< RNG, S >Monte Carlo Hull-White cap-floor engine factory
 CMakeMCPagodaEngine< RNG, S >Monte Carlo pagoda-option engine factory
 CMakeMCPathBasketEngine< RNG, S >Monte Carlo Path Basket engine factory
 CMakeMCPerformanceEngine< RNG, S >Monte Carlo performance-option engine factory
 CMakeMCVarianceSwapEngine< RNG, S >Monte Carlo variance-swap engine factory
 CMakeOISHelper class
 CMakeScheduleHelper class
 CMakeSwaptionHelper class
 CMakeVanillaSwapHelper class
 CMakeYoYInflationCapFloorHelper class
 ▶CMarketModelBase class for market models
 ▶CMarketModelEvolverMarket-model evolver
 ▶CMarketModelMultiProductMarket-model product
 CMarketModelPathwiseDiscounter
 ▶CMarketModelPathwiseMultiProductMarket-model pathwise product
 ▶CMarketModelVolProcess
 CMarshallOlkinCopulaMarshall-Olkin copula
 ▶CMatrixMatrix used in linear algebra
 CMaxCopulaMax copula
 ▶CMcSimulation< MC, RNG, S >Base class for Monte Carlo engines
 ▶CMeanRevertingPricer
 CMersenneTwisterUniformRngUniform random number generator
 CMinCopulaMin copula
 CMixedLinearCubicMixed linear/cubic interpolation factory and traits
 ▶CMixedScheme< Operator >Mixed (explicit/implicit) scheme for finite difference methods
 CModifiedCraigSneydSchemeModified Craig-Sneyd scheme
 CMoneyAmount of cash
 CMonteCarloModel< MC, RNG, S >General-purpose Monte Carlo model for path samples
 ▶CMoreGreeksMore additional option results
 CMoroInverseCumulativeNormalMoro Inverse cumulative normal distribution class
 CMTBrownianGeneratorMersenne-twister Brownian generator for market-model simulations
 CMultiCubicSpline< i >N-dimensional cubic spline interpolation between discrete points
 CMultidimIntegralIntegrates a vector or scalar function of vector domain
 CMultiPathCorrelated multiple asset paths
 CMultiPathGenerator< GSG >Generates a multipath from a random number generator
 CMultiVariate< RNG >Default Monte Carlo traits for multi-variate models
 CNoArbSabrNo arbtrage sabr interpolation factory and traits
 CNonLinearLeastSquareNon-linear least-square method
 ▶CNonstandardSwap::argumentsArguments for nonstandard swap calculation
 CNonstandardSwap::resultsResults from nonstandard swap calculation
 CNormalDistributionNormal distribution function
 CNull< T >Template class providing a null value for a given type
 CNull< Array >Specialization of null template for this class
 CNull< Date >Specialization of Null template for the Date class
 CNumericalDifferentiationNumerical Differentiation on arbitrarily spaced grids
 CNzocrNzocr index
 ▶CObservableObject that notifies its changes to a set of observers
 CObservableValue< T >observable and assignable proxy to concrete value
 ▶CObserverObject that gets notified when a given observable changes
 ▶COneFactorModel::ShortRateDynamicsBase class describing the short-rate dynamics
 COperatorFactoryBlack-Scholes-Merton differential operator
 ▶COptimizationMethodAbstract class for constrained optimization method
 ▶COption::argumentsBasic option arguments
 COrthogonalizedBumpFinder
 COrthogonalProjections
 COvernightLegHelper class building a sequence of overnight coupons
 ▶CParameterBase class for model arguments
 CParameter::ImplBase class for model parameter implementation
 CPartialTimeBarrierOption::argumentsArguments for barrier option calculation
 CPascalTrianglePascal triangle coefficients calculator
 CPathSingle-factor random walk
 CPathGenerator< GSG >Generates random paths using a sequence generator
 CPathMultiAssetOption::argumentsArguments for multi-asset option calculation
 CPathMultiAssetOption::resultsResults from multi-asset option calculation
 CPathPayoffAbstract base class for path-dependent option payoffs
 CPathPricer< PathType, ValueType >Base class for path pricers
 CPathwiseAccountingEngineEngine collecting cash flows along a market-model simulation for doing pathwise computation of Deltas
 CPathwiseVegasAccountingEngineEngine collecting cash flows along a market-model simulation for doing pathwise computation of Deltas and vegas
 CPathwiseVegasOuterAccountingEngineEngine collecting cash flows along a market-model simulation for doing pathwise computation of Deltas and vegas
 ▶CPayoffAbstract base class for option payoffs
 CPeriod
 CPlackettCopulaPlackett copula
 CPoissonDistributionPoisson distribution function
 CPolarStudentTRng< URNG >Student t random number generator
 CPolynomialPolynomial2D-spline-interpolation factory
 CPolynomialFunctionCubic functional form
 CPrimeNumbersPrime numbers calculator
 CProbabilityAlwaysDownhillAlways Downhill Probability
 CProbabilityBoltzmannBoltzmann Probability
 CProbabilityBoltzmannDownhillBoltzmann Downhill Probability
 CProbabilityOfAtLeastNEventsProbability of at least N events
 CProbabilityOfNEventsProbability of N events
 CProblemConstrained optimization problem
 CProtectionInformation on a default-protection contract
 CQuantityAmount of a commodity
 CQuantoOptionResults< ResultsType >Results from quanto option calculation
 CRandomizedLDS< LDS, PRS >Randomized (random shift) low-discrepancy sequence
 CRandomSequenceGenerator< RNG >Random sequence generator based on a pseudo-random number generator
 CRangeAccrualLegHelper class building a sequence of range-accrual floating-rate coupons
 CRanlux3UniformRngUniform random number generator
 CReannealingFiniteDifferencesReannealing Finite Difference
 CReannealingTrivialReannealing Trivial
 ▶CRegionRegion class, used for inflation applicability
 CReplicationDigital option replication strategy
 CRestructuringRestructuring type
 CRichardsonExtrapolationRichardson Extrapolation
 ▶CRoundingBasic rounding class
 CSABRSABR interpolation factory and traits
 CSalvagingAlgorithmAlgorithm used for matricial pseudo square root
 CSample< T >Weighted sample
 CSampledCurveThis class contains a sampled curve
 CSamplerCauchyCauchy Sampler
 CSamplerGaussianGaussian Sampler
 CSamplerLogNormalLognormal Sampler
 CSamplerMirrorGaussianGaussian Mirror Sampler
 CSamplerRingGaussianGaussian Ring Sampler
 CSamplerVeryFastAnnealingVery Fast Annealing Sampler
 CSchedulePayment schedule
 ▶CSeasonalityA transformation of an existing inflation swap rate
 CSegmentIntegralIntegral of a one-dimensional function
 CSettlementsettlement information
 CShoutConditionShout option condition
 CsimEvent< simEventOwner >
 CSimpleChooserOption::argumentsExtra arguments for single chooser option
 CSimpleLocalEstimatorLocal-estimator volatility model
 CSingleton< T >Basic support for the singleton pattern
 CSingleVariate< RNG >Default Monte Carlo traits for single-variate models
 CSmileSectionUtilsSmile-section utilities
 CSMMDriftCalculatorDrift computation for coterminal swap market models
 CSobolBrownianGeneratorSobol Brownian generator for market-model simulations
 CSobolRsgSobol low-discrepancy sequence generator
 CSoniaSonia (Sterling Overnight Index Average) rate
 CSparseILUPreconditioner
 CSphereCylinderOptimizer
 CStatsHolderHelper class for precomputed distributions
 CSteepestDescentMulti-dimensional steepest-descent class
 Cstep_iterator< Iterator >Iterator advancing in constant steps
 ▶CStepCondition< array_type >Condition to be applied at every time step
 CStepConditionSet< array_type >Parallel evolver for multiple arrays
 CStochasticCollocationInvCDFStochastic collocation inverse cumulative distribution function
 ▶CStochasticProcess1D::discretizationDiscretization of a 1-D stochastic process
 ▶CStochasticProcess::discretizationDiscretization of a stochastic process over a given time interval
 CStudentDistributionStudent t-distribution
 CSurvivalProbabilitySurvival-Probability-curve traits
 CSVDSingular value decomposition
 CSviSvi interpolation factory and traits
 CSwaptionVolatilityCubeSwaption-volatility cube
 CSwaptionVolatilityMatrixAt-the-money swaption-volatility matrix
 CSymmetricSchurDecompositionSymmetric threshold Jacobi algorithm
 CTabulatedGaussLegendreTabulated Gauss-Legendre quadratures
 CTCopulaPolicyStudent-T Latent Model's copula policy
 CTCopulaPolicy::initTraits
 CTemperatureBoltzmannTemperature Boltzmann
 CTemperatureCauchyTemperature Cauchy
 CTemperatureVeryFastAnnealingTemperature Very Fast Annealing
 CTimeGridTime grid class
 CTimeSeries< T, Container >Container for historical data
 CTqrEigenDecompositionTridiag. QR eigen decomposition with explicite shift aka Wilkinson
 CTransformedGridTransformed grid
 CTrapezoidIntegral< IntegrationPolicy >Integral of a one-dimensional function
 CTRBDF2< Operator >TR-BDF2 scheme for finite difference methods
 ▶CTridiagonalOperatorBase implementation for tridiagonal operator
 CTridiagonalOperator::TimeSetterEncapsulation of time-setting logic
 CTwoDimensionalIntegralIntegral of a two-dimensional function
 CTwoFactorModel::ShortRateDynamicsClass describing the dynamics of the two state variables
 CUnitOfMeasureUnit of measure specification
 CUpperBoundEngineMarket-model engine for upper-bound estimation
 ▶CVanillaSwap::argumentsArguments for simple swap calculation
 CVanillaSwap::resultsResults from simple swap calculation
 CVannaVolgaVannaVolga-interpolation factory and traits
 CVarianceGammaEngineVariance Gamma Pricing engine for European vanilla options using integral approach
 CVarianceOption::argumentsArguments for forward fair-variance calculation
 CVarianceOption::resultsResults from variance-option calculation
 CVarianceSwap::argumentsArguments for forward fair-variance calculation
 CVarianceSwap::resultsResults from variance-swap calculation
 CVegaBumpCollection
 CVisitor< T >Visitor for a specific class
 CYearOnYearInflationSwap::argumentsArguments for YoY swap calculation
 CYearOnYearInflationSwap::resultsResults from YoY swap calculation
 CYoYInflationCapFloor::argumentsArguments for YoY Inflation cap/floor calculation
 CyoyInflationLeg
 CYoYInflationTraitsBootstrap traits to use for PiecewiseZeroInflationCurve
 CYoYInflationVolatilityTraitsTraits for inflation-volatility bootstrap
 ▶CYoYOptionletStripperInterface for inflation cap stripping, i.e. from price surfaces
 CZabr< Evaluation >No arbtrage sabr interpolation factory and traits
 CZeroInflationTraitsBootstrap traits to use for PiecewiseZeroInflationCurve
 CZeroYieldZero-curve traits
 CZigguratRngZiggurat random-number generator
 CQuantoOptionResults< Instr::results >
 CRandomSequenceGenerator< QuantLib::MersenneTwisterUniformRng >
 CSample< MultiPath >
 CSample< Path >
 CSample< std::vector< Real > >
 ▶CSingleton< CommoditySettings >
 ▶CSingleton< ExchangeRateManager >
 ▶CSingleton< IndexManager >
 ▶CSingleton< ObservableSettings >
 ▶CSingleton< SeedGenerator >
 ▶CSingleton< Settings >
 CSingleton< Tracing >
 ▶CSingleton< UnitOfMeasureConversionManager >
 ▶CexceptionSTL class
 ▶Cmap< K, T >STL class
 CStepCondition< Array >
 CTimeSeries< Real >
 ▶CTrapezoidIntegral< Default >