All Classes (finmath lib 5.0.0 API)

Class	Description
AbstractAnalyticProduct
AbstractAnalyticProduct
AbstractAnalyticVolatilityCubeProduct	Abstract layer between interface and implementation, which ensures compatibility of model and product.
AbstractAssetMonteCarloProduct	Base class for products requiring an AssetModelMonteCarloSimulationModel for valuation.
AbstractBusinessdayCalendar	Base class for all business day calendars.
AbstractCubeCalibration	Abstract class providing a default method of calibrating a parametric cube to market data, which can be implemented quickly for any cube by implementing the methods: `buildCube` `initializeParameters` `applyParameterBounds`
AbstractCurve	Abstract base class for a curve.
AbstractCurve	Abstract base class for a curve.
AbstractForwardCurve	Abstract base class for a forward curve, extending a curve object It stores the maturity of the underlying index (paymentOffset) and the associated discount curve.
AbstractForwardCurve	Abstract base class for a forward curve, extending a curve object It stores the maturity of the underlying index (paymentOffset) and the associated discount curve.
AbstractFourierTransformProduct
AbstractIndex	Base class for indices.
AbstractLIBORCovarianceModel	A base class and interface description for the instantaneous covariance of an forward rate interest rate model.
AbstractLIBORCovarianceModelParametric	Base class for parametric covariance models, see also `AbstractLIBORCovarianceModel`.
AbstractLIBORMonteCarloProduct	Base class for products requiring an LIBORModelMonteCarloSimulationModel as base class
AbstractMonteCarloProduct	Base class for products requiring an MonteCarloSimulationModel for valuation.
AbstractPeriod	Base class for a period.
AbstractProcessModel	This class is an abstract base class to implement a model provided to an MonteCarloProcessFromProcessModel.
AbstractProductComponent	Base class for product components.
AbstractRandomVariableDifferentiableFactory	A random variable factory extending `AbstractRandomVariableFactory` providing random variables implementing `RandomVariableDifferentiable`.
AbstractRandomVariableFactory
AbstractRealIntegral	A real integral with lower and upper integration bounds.
AbstractShortRateVolatilityModel	A base class and interface description for the instantaneous volatility of an short rate model.
AbstractShortRateVolatilityModelParametric	Base class for parametric volatility models, see also `AbstractShortRateVolatilityModel`.
AbstractSingleSwapRateProduct	An abstract class providing valuation methods for single swap rate products.
AbstractVolatilitySurface	Abstract base class for a volatility surface.
AbstractVolatilitySurface	Abstract base class for a volatility surface.
AbstractVolatilitySurfaceParametric	Base class for parametric volatility surfaces, implementing a generic calibration algorithm.
AcceptanceRejectionRandomNumberGenerator	Class implementing `RandomNumberGenerator` by the acceptance rejection method.
AccrualAccount	Implementation of a general accrual account.
AccruedInterest	An accrued interest index.
AccruingNotional
AnalyticFormulas	This class implements some functions as static class methods.
AnalyticModel	A collection of objects representing analytic valuations, i.e., curves and volatility surfaces.
AnalyticModel	A collection of objects representing analytic valuations, i.e., curves and volatility surfaces.
AnalyticModelDescriptor
AnalyticModelFactory	Factory to build an described analytic model from a descriptor.
AnalyticModelFactory.DescribedAnalyticModel	Class extending `AnalyticModelFromCurvesAndVols` with the funtionality of a described model.
AnalyticModelForwardCurveIndex	An index which is given by a name referencing a curve of an analytic model.
AnalyticModelFromCurvesAndVols	Implements a collection of market data objects (e.g., discount curves, forward curve) which provide interpolation of market data or other derived quantities ("calibrated curves").
AnalyticModelFromCurvesAndVols	Implements a collection of market data objects (e.g., discount curves, forward curve) which provide interpolation of market data or other derived quantities ("calibrated curves").
AnalyticModelIndex	An index which is given by a name referencing a curve of an analytic model.
AnalyticModelWithVolatilityCubes	Implementation of `VolatilityCubeModel` based on `AnalyticModelFromCurvesAndVols`.
AnalyticProduct	The interface which has to be implemented by a product which may be evaluated using an `AnalyticModelFromCuvesAndVols`.
AnalyticProduct	The interface which has to be implemented by a product which may be evaluated using an `AnalyticModelFromCuvesAndVols`.
AnalyticVolatilityCubeProduct	The interface which has to be implemented by a product which may be evaluated using an `AnalyticModelFromCuvesAndVols`.
AnnuityDummyProduct	A dummy product that only evaluates the value of a `AnnuityMapping`.
AnnuityMapping	An interface for calsses providing annuity mappings.
AnnuityMapping.AnnuityMappingType	Implemented types of annuity mappings.
AnnuityMappingFactory	Provides factories to build annuity mappings from uniform input.
ARMAGARCH	Lognormal process with ARMAGARCH(1,1) volatility.
AsianOption	Implements the valuation of an Asian option.
AssetModelDescriptor	Marker interface for descriptors describing an asset model.
AssetModelFourierMethodFactory	Constructs asset models, which evaluate products via Monte-Carlo method.
AssetModelMonteCarloFactory	Constructs asset models, which evaluate products via Monte-Carlo method.
AssetModelMonteCarloSimulationModel	Basic interface which has to be implemented by Monte Carlo models for asset processes.
AssetMonteCarloProduct	Interface for products requiring an AssetModelMonteCarloSimulationModel for valuation.
BachelierModel	This class implements some functions as static class methods related to the Bachelier model.
BachelierModel	This class implements a (variant of the) Bachelier model, that is, it provides the drift and volatility specification and performs the calculation of the numeraire (consistent with the dynamics, i.e. the drift).
Barrier	The interface describes how an barrier has to be specified for the generation of a process (see LogNormalProcessWithBarrierStrategy).
BarrierOptions	This class implements the valuation of barrier options.
BarrierOptions.BarrierType
BasicPiterbargAnnuityMapping	Implements an annuity mapping following Vladimir Piterbarg's approach.
BasketOption	Implements valuation of a European option on a basket of asset.
BatesModel	Implements the characteristic function of a Bates model.
BermudanDigitalOption	This class implements the valuation of a Bermudan digital option paying \( N_{i} \cdot \mathbb{1}(S(T_{i}) - K_{i}) \) at \( T_{i} \), when exercised in \( T_{i} \), where \( N_{i} \) is the notional, \( \mathbb{1} \) is the indicator function, \( S \) is the underlying, \( K_{i} \) is the strike and \( T_{i} \) the exercise date.
BermudanDigitalOption.ExerciseMethod
BermudanOption	This class implements the valuation of a Bermudan option paying N(i) (S(T(i)) - K(i))* at T(i), when exercised in T(i), where N(i) is the notional, S is the underlying, K(i) is the strike and T(i) the exercise date.
BermudanOption.ExerciseMethod
BermudanSwaption	Implements the valuation of a Bermudan swaption under a `LIBORModelMonteCarloSimulationModel`
BermudanSwaptionFromSwapSchedules	Implements the valuation of a Bermudan swaption under a `LIBORModelMonteCarloSimulationModel`
BermudanSwaptionFromSwapSchedules.SwaptionType
BiLinearInterpolation	Simple bi-linear interpolation of data points \( z_{i,j} \) over a Cartesian grid \( (x_{i},y_{j}) \).
BlackScholesDeltaHedgedPortfolio	This class implements a delta hedged portfolio of an European option (a hedge simulator).
BlackScholesHedgedPortfolio	This class implements a delta and delta-gamma hedged portfolio of an European option (a hedge simulator).
BlackScholesHedgedPortfolio.HedgeStrategy
BlackScholesModel	Implements the characteristic function of a Black Scholes model.
BlackScholesModel	This class implements a Black Scholes Model, that is, it provides the drift and volatility specification and performs the calculation of the numeraire (consistent with the dynamics, i.e. the drift).
BlackScholesModelDescriptor
BlackScholesModelMonteCarloFactory
BlackScholesModelMonteCarloFiniteDifference1D
BlackScholesModelWithCurves	This class implements a Black Scholes Model, that is, it provides the drift and volatility specification and performs the calculation of the numeraire (consistent with the dynamics, i.e. the drift).
BlackScholesTheta	Implementation of the theta schemes for the Black-Scholes model (still experimental).
BlendedLocalVolatilityModel	Blended model (or displaced diffusion model) build on top of a standard covariance model.
Bond	Implements the valuation of a bond (zero-coupon, fixed coupon or floating coupon) with unit notional of 1 using curves: a forward curve, if the bond has floating rate coupons a discount curve as a base curve for discounting a survival probability curve for additional credit risk related discount factor a basis factor curve for additional bond related discount factor Support for day counting is provided via the class implementing `Schedule`.
Bond	This class implements the valuation of a zero coupon bond.
Bond	This class implements the valuation of a zero coupon bond.
BondCurve	Implements the bond curve as a curve object, see `Curve`.
BondCurve.Type	Possible curve types, where the first term stands for the reference discount curve and the second term stands for the spread curve.
BondWithForeignNumeraire	This class implements the valuation of a zero coupon bond.
BoundConstraint	A class applying a bound constraint to a parameter.
BrownianBridge	This class implements a Brownian bridge, i.e., samples of realizations of a Brownian motion conditional to a given start and end value.
BrownianMotion	Interface description of a time-discrete n-dimensional Brownian motion W = (W₁,...
BrownianMotionFromMersenneRandomNumbers	Implementation of a time-discrete n-dimensional Brownian motion W = (W₁,...
BrownianMotionFromRandomNumberGenerator	Implementation of a time-discrete n-dimensional Brownian motion W = (W₁,...
BrownianMotionLazyInit	Deprecated. Refactor rename.
BrownianMotionView	A Brownian motion which is defined by some factors of a given Brownian motion, i.e., for a given multi-factorial Brownian motion W, this Brownian motion is given by ( W(i[0]), W(i[1]) W(i[2]), ..., W(i[n-1]) ) where i is a given array of integers.
BrownianMotionWithControlVariate	Provides a Brownian motion from given (independent) increments and performs a control of the expectation and the standard deviation.
BusinessdayCalendar
BusinessdayCalendar.DateOffsetUnit
BusinessdayCalendar.DateRollConvention
BusinessdayCalendarAny	A business day calendar, where every day is a business day.
BusinessdayCalendarExcludingGivenHolidays	An abstract base class for a business day calendar, where every day is a business day, except weekends days provided by a `Set` provided by the method `getHolidays`.
BusinessdayCalendarExcludingGivenSetOfHolidays	A class for a business day calendar, where every day is a business day, except weekends days provided by a `Set`.
BusinessdayCalendarExcludingLONHolidays	A business day calendar, where every day is a business day, except for weekends and London holidays
BusinessdayCalendarExcludingNYCHolidays	A business day calendar, where every day is a business day, except for weekends and New York holidays
BusinessdayCalendarExcludingTARGETHolidays	A business day calendar, where every day is a business day, expect the TARGET holidays.
BusinessdayCalendarExcludingWeekends	A business day calendar, where every day is a business day, expect SATURDAY and SUNDAY.
CalculationException
CalibratableHestonModel	This class is creates new instances of HestonModel and communicates with the optimization algorithm.
CalibratableMertonModel	This class is creates new instances of MertonModel and communicates with the optimization algorithm.
CalibratableProcess	Every class implementing this interface communicates with the calibration routine by providing clones of the model with changed parameters.
CalibratableVarianceGammaModel	This class is creates new instances of VarianceGammaModel and communicates with the optimization algorithm.
CalibratedCurves	Generate a collection of calibrated curves (discount curves, forward curves) from a vector of calibration products.
CalibratedCurves	Generate a collection of calibrated curves (discount curves, forward curves) from a vector of calibration products.
CalibratedCurves.CalibrationSpec	Specification of calibration product.
CalibratedCurves.CalibrationSpec	Specification of calibration product.
CalibratedModel	This class solves a calibration problem.
CalibrationProduct	A class for calibration products, that is a triple (P,V,w) where P is a product, V is a target value and w is a weight.
CancelableSwap	Implements the pricing of a cancelable swap under a `LIBORModelMonteCarloSimulationModel`
Cap	Implements the valuation of a cap via an analytic model, i.e. the specification of a forward curve, discount curve and volatility surface.
Caplet	Implements the pricing of a Caplet using a given `AbstractLIBORMarketModel`.
Caplet.ValueUnit
CapletVolatilities	A very simple container for Caplet volatilities.
CapletVolatilitiesParametric	A parametric caplet volatility surface created form the four parameter model for the instantaneous forward rate lognormal volatility given by \( \sigma(t) = (a + b t) \exp(- c t) + d \).
CapletVolatilitiesParametricDisplacedFourParameterAnalytic	A parametric caplet volatility surface created form the four parameter model for the instantaneous displaced forward rate lognormal volatility given by \( \sigma(t) = (a + b t) \exp(- c t) + d \).
CapletVolatilitiesParametricFourParameterPicewiseConstant	A parametric caplet volatility surface created form the picewise constant (numerical integration) of the four parameter model for the instantaneous forward rate volatility given by \( \sigma(t) = (a + b t) \exp(- c t) + d \).
CapletVolatilitySurface	This class implements a caplet volatility surface.
CapletVolBootstrapping	This class implements a caplet volatility bootstrapper.
CappedFlooredIndex	An capped and floored index paying min(max(index(t),floor(t)),cap(t)), where index, floor and cap are indices, i.e., objects implementing `AbstractIndex`.
CapShiftedVol	Implements the valuation of a cap via an analytic model, i.e. the specification of a forward curve, discount curve and volatility surface.
CapTenorStructure	Enum determining the currency of the observed cap or caplet prices.
CapVolMarketData	This class is a container for all the cap data needed to perform the caplet bootstrapping.
Cashflow	Implements the valuation of a single cashflow by a discount curve.
Cashflow	Implements the valuation of a single cashflow by a discount curve.
Cashflow	A single deterministic cashflow at a fixed time
CashSettledPayerSwaption	A European cash settled payer swaption.
CashSettledReceiverSwaption	A European cash settled receiver swaption.
CharacteristicFunction	Interface which has to be implemented by characteristic functions of random variables, e.g., Fourier transforms of values (payoffs).
CharacteristicFunctionModel	Interface which has to be implemented by models providing the characteristic functions of stochastic processes.
Choice	An right to choose between two underlyings.
CMSOption	Implements the valuation of an option on a CMS rate.
ConditionalExpectationEstimator	The interface which has to be implemented by a fixed conditional expectation operator, i.e., E( · \| Z ) for a fixed Z.
ConstantMaturitySwap	A constant maturity swap.
ConstantMaturitySwaprate	An idealized (single curve) CMS index with given maturity and given period length.
ConstantNormalizer	Constant normalizer returning the value one.
Constraint	Constraint base interface (scalar and multivariate)
ConvexityAdjustedModel	A general convexity adjustment for models.
CorrelatedBrownianMotion	Provides a correlated Brownian motion from given (independent) increments and a given matrix of factor loadings.
CorrelationProvider	Interface for a correlation provider for forward curves.
CorrelationProviderTenorBasis	This class implements a correlation provider based on iCap market data.
CrossCurrencyLIBORMarketModelFromModels	Cross Currency LIBOR Market Model with Black-Scholes FX Model.
CrossCurrencyTermStructureMonteCarloSimulationModel	Interface for cross currency term structure models.
CSVCurveParser	Provides options to parse curves.
CSVSwaptionParser	Provides options to parse `SwaptionDataLattice` from csv files.
Curve	The interface which is implemented by a general curve.
Curve	The interface which is implemented by a general curve.
CurveBuilder	Interface of builders which allow to build curve objects by successively adding points.
CurveBuilder	Interface of builders which allow to build curve objects by successively adding points.
CurveEstimation	This class implements the method of local linear regression with discrete kernel function, see see https://ssrn.com/abstract=3073942 In particular it represents the implementation of proposition 2 and 3 of the paper.
CurveEstimation.Distribution	Possible kernel types.
CurveFactory	A collection of convenient methods constructing some more specialized curves.
CurveFromProductOfCurves	A curve derived from other curves by multiplying the values.
CurveInterpolation	This class represents a curve build from a set of points in 2D.
CurveInterpolation	This class represents a curveFromInterpolationPoints build from a set of points in 2D.
CurveInterpolation.Builder	A builder (following the builder pattern) for CurveFromInterpolationPoints objects.
CurveInterpolation.Builder	A builder (following the builder pattern) for CurveFromInterpolationPoints objects.
CurveInterpolation.ExtrapolationMethod	Possible extrapolation methods.
CurveInterpolation.ExtrapolationMethod	Possible extrapolation methods.
CurveInterpolation.InterpolationEntity	Possible interpolation entities.
CurveInterpolation.InterpolationEntity	Possible interpolation entities.
CurveInterpolation.InterpolationMethod	Possible interpolation methods.
CurveInterpolation.InterpolationMethod	Possible interpolation methods.
CurveInterpolation.Point	Representation of a 2D curve point including the boolean property if the point is fixed or calibrateable.
DataTable	An interface for storing double values in a tenor grid.
DataTable.TableConvention	Possible conventions for the table.
DataTableBasic	A basic implementation of `DataTable`, which provides no means of inter- or extrapolation.
DataTableExtrapolated	Extends `DataTableBasic` with the capacity to inter- and extrapolate values off the tenor grid.
DataTableInterpolated	Extends `DataTableBasic` with the capacity to interpolate values between tenor grid nodes.
DataTableLight	A basic implementation of DataTable, which only allows access to data via int and provides no means of inter- or extrapolation.
DataTableLinear	Extends `DataTableBasic` with the capacity to interpolate values between tenor grid nodes, using `BiLinearInterpolation` Note that the interpolation is done to the accuracy of the table convention.
DateIndex	An index whose value is a function of the fixing date, for example the DAY, MONTH or NUMBER_OF_DAYS_IN_MONTH.
DateIndex.DateIndexType
DayCountConvention	Interface for various day count conventions.
DayCountConvention_30E_360	Implementation of 30E/360 and 30E+/360.
DayCountConvention_30E_360_ISDA	Implementation of 30E/360 ISDA.
DayCountConvention_30U_360	Calculates the day count using the US 30/360 adjusted method.
DayCountConvention_ACT	Base class which calculates the day count by calculating the actual number of days between startDate and endDate.
DayCountConvention_ACT_360	Implementation of ACT/360.
DayCountConvention_ACT_365	Implementation of ACT/365.
DayCountConvention_ACT_365A	Implementation of ACT/365A.
DayCountConvention_ACT_365L	Implementation of ACT/365L.
DayCountConvention_ACT_ACT_AFB	Implementation of ACT/ACT AFB.
DayCountConvention_ACT_ACT_ICMA	Implementation of ACT/ACT ICMA.
DayCountConvention_ACT_ACT_ISDA	Implementation of ACT/ACT ISDA.
DayCountConvention_ACT_ACT_YEARFRAC	Implementation of ACT/ACT as in Excel (2013).
DayCountConvention_NL_365	Implementation of NL/365.
DayCountConvention_NONE	This is a special day count convention, where the day count between two dates is always 0.0 and the year fraction for an interval is always 1.0.
DayCountConvention_UNKNOWN	Implements a placeholder object for an unknown day count convention, throwing an exception, whenever a day count or day count fraction is requested.
DayCountConventionFactory	Factory methods for day count conventions.
DeltaHedgedPortfolioWithAAD	This class implements a delta hedged portfolio (a hedge simulator).
Deposit	Implements the valuation of the (overnight) deposit (maturity t+1 or t+2).
Deposit	Implements the valuation of the (overnight) deposit (maturity t+1 or t+2).
DescribedModel<M extends ModelDescriptor>	Interface for models which can provide a complete description of their model parameters (independent of the implementation of the numerical method).
DescribedProduct<T extends ProductDescriptor>	Interface for products which can provide a complete description of themself, i.e. the model parameters (independent of the implementation of the numerical method).
DigitalCaplet	Implements the valuation of a digital caplet using a given `LIBORModelMonteCarloSimulationModel`.
DigitalFloorlet	Implements the pricing of a digtal floorlet using a given `LIBORModelMonteCarloSimulationModel`.
DigitalOption	Implements valuation of a European option on a single asset.
DigitalOption	Implements the valuation of a digital option on a single asset.
DigitalOptionDeltaLikelihood	Implements calculation of the delta of a digital option.
DiscountCurve	The interface which is implemented by discount curves.
DiscountCurveFromForwardCurve	A discount curve derived from a given forward curve.
DiscountCurveFromForwardCurve	A discount curve derived from a given forward curve.
DiscountCurveFromProductOfCurves	A discount curve derived from other discount curves by multiplying the discount factors.
DiscountCurveInterface	The interface which is implemented by discount curves.
DiscountCurveInterpolation	Implementation of a discount factor curve based on `CurveInterpolation`.
DiscountCurveInterpolation	Implementation of a discount factor curve based on `CurveInterpolation`.
DiscountCurveNelsonSiegelSvensson	Implementation of a discount factor curve given by a Nelson-Siegel-Svensson (NSS) parameterization.
DiscountCurveRenormalized	A discount curve \( t \mapsto df(t) \) with property \( df(t_{0}) = 1 \) for a given \( t_{0} \) derived from a base discount curve by a constant skaling.
DisplacedLocalVolatilityModel	Displaced model build on top of a standard covariance model.
DisplacedLognomalModel	This class implements a displaced lognormal model, that is, it provides the drift and volatility specification and performs the calculation of the numeraire (consistent with the dynamics, i.e. the drift).
DisplacedLognormal	Displaced log-normal process with constanst volatility.
DisplacedLognormalARMAGARCH	Displaced log-normal process with ARMAGARCH(1,1) volatility.
DisplacedLognormalGARCH	Displaced log-normal process with GARCH(1,1) volatility.
DisplacedLognormalGJRGARCH	Displaced log-normal process with GJR-GARCH(1,1) volatility.
DoubleTernaryOperator	Functional interface for functions mapping (double,double,double) to double.
ErrorEstimation	Provides several error estimates between values taken from market data and values taken from a model.
EulerSchemeFromProcessModel	This class implements some numerical schemes for multi-dimensional multi-factor Ito process.
EulerSchemeFromProcessModel.Scheme
EuropeanOption	Implements valuation of a European option on a single asset.
EuropeanOption	Implements the valuation of a European option on a single asset.
EuropeanOptionDeltaLikelihood	Implements calculation of the delta of a European option using the likelihood ratio method.
EuropeanOptionDeltaPathwise	Implements calculation of the delta of a European option using the path-wise method, assuming that the underlying follows a model where d S(T)/d S(0) = S(T)/S(0), e.g., Black-Scholes.
EuropeanOptionDeltaPathwiseForGeometricModel	Implements calculation of the delta of a European option using the path-wise method, assuming that the underlying follows a model where d S(T)/d S(0) = S(T)/S(0), e.g., Black-Scholes.
EuropeanOptionGammaLikelihood	Implements calculation of the delta of a European option.
EuropeanOptionGammaPathwise	Implements calculation of the delta of a European option using the pathwise method.
EuropeanOptionRhoLikelihood	Implements calculation of the delta of a European option.
EuropeanOptionRhoPathwise	Implements calculation of the delta of a European option using the pathwise method.
EuropeanOptionSmile	This is an abstract base class for Fourier-based methodologies for the valuation of a smile of options.
EuropeanOptionSmileByCarrMadan	This class computes the prices of a collection of call options for a fixed maturity and a family of strikes.
EuropeanOptionThetaPathwise	Implements calculation of the theta of a European option using the pathwise method.
EuropeanOptionVegaLikelihood	Implements calculation of the delta of a European option.
EuropeanOptionVegaPathwise	Implements calculation of the vega of a European option using the pathwise method.
EuropeanOptionWithBoundary	Implements pricing of a European stock option.
ExpectedTailLoss	The expected tail loss.
ExponentialCorrelationCurve	A curve, which models exponential decay of correlation from one point in time to another, according to \[ \max\{e^{c(t-T)}, 1\} \,
ExponentialDecayLocalVolatilityModel	Exponential decay model build on top of a given covariance model.
ExponentialNormalizer	An exponential normalizing function following \[ c e^{-(x / S)^2} \] where S is the swap rate and c is some scaling factor.
ExposureEstimator	Implements (a numerical approximation of) the function \( (t,V) \mapsto E( V(t) \vert \mathcal{F}_t ) \) where \( V(t) \) is the (sum of) discounted future value(s) of an underlying \( V \), discounted to \( t \) and \( t \) is a given evaluation time.
FactorDrift
FDMBlackScholesModel	Black Scholes model using finite difference method.
FDMConstantElasticityOfVarianceModel	CEV model using finite difference method.
FDMEuropeanCallOption	Implementation of a European option to be valued by a the finite difference method.
FDMEuropeanPutOption	Implementation of a European option to be valued by a the finite difference method.
FDMThetaMethod	One dimensional finite difference solver.
FileUtilities	Provides utility method to write an object to a file and read an object from a file.
FiniteDifference1DBoundary	Interface for boundaries conditions provided to one dimensional finite difference solvers.
FiniteDifference1DModel	Interface one dimensional finite difference models.
FiniteDifference1DProduct	Interface one dimensional finite difference products.
FiniteDifferenceDeltaHedgedPortfolio	This class implements a delta hedged portfolio of a given product (a hedge simulator).
FiniteDifferenceHedgedPortfolio	This class implements a delta and delta-gamma hedged portfolio of an European option (a hedge simulator).
FiniteDifferenceHedgedPortfolio.HedgeStrategy
FIPXMLParser	Class for parsing trades saved in FIPXML to product descriptors.
FixedCoupon	A fixed coupon index paying constant coupon..
FlexiCap	This class implements the valuation of a Flexi Cap (aka Auto Cap).
FloatingpointDate	This class provides the library wide conversion from a floating point number to a LocalDate.
Forward	Implements the valuation of a forward using curves (discount curve, forward curve).
Forward	Implements the valuation of a forward using curves (discount curve, forward curve).
ForwardCurve	The interface which is implemented by forward curves.
ForwardCurveFromDiscountCurve	A forward curve derived from a given discount curve.
ForwardCurveFromDiscountCurve	A forward curve derived from a given discount curve.
ForwardCurveIndex	A fixed coupon index paying coupon calculated from a forward curve.
ForwardCurveInterface	The interface which is implemented by forward curves.
ForwardCurveInterpolation	A container for a forward (rate) curve.
ForwardCurveInterpolation	A container for a forward (rate) curve.
ForwardCurveInterpolation.InterpolationEntityForward	Additional choice of interpolation entities for forward curves.
ForwardCurveInterpolation.InterpolationEntityForward	Additional choice of interpolation entities for forward curves.
ForwardCurveNelsonSiegelSvensson	Implementation of a forward given by a Nelson-Siegel-Svensson (NSS) parameterization.
ForwardCurveWithFixings
ForwardRateAgreement	Implements the valuation of a FRA in multi-curve setting.
ForwardRateAgreement	Implements the valuation of a FRA in multi-curve setting.
ForwardRateAgreementGeneralized	This class implements the valuation of a zero coupon bond.
ForwardRateVolatilitySurfaceCurvature	This class implements the calculation of the curvature of the volatility surface of the forward rates.
FourierTransformProduct
FPMLParser	Class for parsing trades saved in FpML to product descriptors.
FutureWrapper<V>	Implementation of the Future interface, without any concurrent execution.
GammaDistribution
GammaProcess	Implementation of a time-discrete n-dimensional Gamma process \( \Gamma = (\Gamma_{1},\ldots,\Gamma_{n}) \), where \( \Gamma_{i} \) is a Gamma process and \( \Gamma_{i} \), \( \Gamma_{j} \) are independent for i not equal j.
GARCH	Log-normal process with GARCH(1,1) volatility.
GoldenSectionSearch	This class implements a Golden Section search algorithm, i.e., a minimization, implemented as a question-and-answer search algorithm.
HaltonSequence	Implements a multi-dimensional Halton sequence (quasi random numbers) with the given bases.
HestonModel	Implements the characteristic function of a Heston model.
HestonModel	This class implements a Heston Model, that is, it provides the drift and volatility specification and performs the calculation of the numeraire (consistent with the dynamics, i.e. the drift).
HestonModel.Scheme	Truncation schemes to be used in the calculation of drift and diffusion coefficients.
HestonModelDescriptor
HestonModelMonteCarloFactory
HistoricalSimulationModel	A parametric time series model based on a given times series.
HullWhiteLocalVolatilityModel	Special variant of a blended model (or displaced diffusion model) build on top of a standard covariance model using the special function corresponding to the Hull-White local volatility.
HullWhiteModel	Implements a Hull-White model with time dependent mean reversion speed and time dependent short rate volatility.
HullWhiteModelWithConstantCoeff	Implements a Hull-White model with constant coefficients.
HullWhiteModelWithDirectSimulation	Implements a Hull-White model with time dependent mean reversion speed and time dependent short rate volatility.
HullWhiteModelWithShiftExtension	Implements a Hull-White model with time dependent mean reversion speed and time dependent short rate volatility.
HybridAssetLIBORModelMonteCarloSimulation	Basic interface which has to be implemented by Monte Carlo models for hybrid processes.
HybridAssetLIBORModelMonteCarloSimulationFromModels	An Equity Hybrid LIBOR Market Model composed of an object implementing `LIBORModelMonteCarloSimulationModel` providing the interest rate simulation and the numeraire and an object implementing `AssetModelMonteCarloSimulationModel` providing the asset simulation.
HybridAssetMonteCarloProduct	Base class for product that need an HybridAssetLIBORModelMonteCarloSimulationInterface in their valuation.
HybridAssetMonteCarloSimulation	Basic interface which has to be implemented by Monte Carlo models for hybrid processes.
IndependentIncrements	Interface description of a time-discrete n-dimensional stochastic process \( X = (X_{1},\ldots,X_{n}) \) provided by independent increments \( \Delta X(t_{i}) = X(t_{i+1})-X(t_{i}) \).
IndependentIncrementsFromICDF	Implementation of a time-discrete n-dimensional sequence of independent increments W = (W₁,...
IndependentModelParameterProvider	Interface implemented by model which can provide their independent model parameters.
IndexCurveFromDiscountCurve	An index curve there the value at time t is given by indexValue / discountCurve.getValue(t).
IndexedValue	An indexed value.
InhomogeneousDisplacedLognomalModel	This class implements an inhomogeneous displaced log-normal model, that is, it provides the drift and volatility specification and performs the calculation of the numeraire (consistent with the dynamics, i.e. the drift).
InhomogenousBachelierModel	This class implements a (variant of the) Bachelier model, that is, it provides the drift and volatility specification and performs the calculation of the numeraire (consistent with the dynamics, i.e. the drift).
InterestRateAnalyticProductFactory	Product factory of interest rate derivatives for use with an analytic model.
InterestRateModelDescriptor	Marker interface for descriptors describing an interest rate model.
InterestRateMonteCarloProductFactory	Product factory of interest rate derivatives for use with a Monte-Carlo method based model.
InterestRateMonteCarloProductFactory.SwapLegMonteCarlo	Monte-Carlo method based implementation of a interest rate swap leg from a product descriptor.
InterestRateMonteCarloProductFactory.SwapMonteCarlo	Monte-Carlo method based implementation of a interest rate swap from a product descriptor.
InterestRateMonteCarloProductFactory.SwaptionPhysicalMonteCarlo	Monte-Carlo method based implementation of a physically settled interest rate swaption from a product descriptor.
InterestRateProductDescriptor	Marker interface for interest rate product descriptors.
InterestRateSwapLegProductDescriptor	Product descriptor for an interest rate swap leg.
InterestRateSwapProductDescriptor	Product descriptor for an interest rate swap.
InterestRateSwaptionProductDescriptor	Product descriptor for an interest rate swaption.
JarqueBeraTest	Class providing the test statistic of the Jarque-Bera test.
JNumberField	A Java swing bean to represent a number field in a GUI.
JumpProcessIncrements	Implementation of a time-discrete n-dimensional jump process J = (J₁,...
LaggedIndex	A time-lagged index paying index(t+fixingOffset)
LevenbergMarquardt	This class implements a parallel Levenberg-Marquardt non-linear least-squares fit algorithm.
LevenbergMarquardt.RegularizationMethod	The regularization method used to invert the approximation of the Hessian matrix.
LIBORBond	This class implements the valuation of a zero (forward) bond on the models forward rate curve.
LIBORCorrelationModel	Abstract base class and interface description of a correlation model (as it is used in `LIBORCovarianceModelFromVolatilityAndCorrelation`).
LIBORCorrelationModelExponentialDecay	Simple correlation model given by R, where R is a factor reduced matrix (see `LinearAlgebra.factorReduction(double[][], int)`) created from the \( n \) Eigenvectors of \( \tilde{R} \) belonging to the \( n \) largest non-negative Eigenvalues, where \( \tilde{R} = \tilde{\rho}_{i,j} \) and \[ \tilde{\rho}_{i,j} = \exp( -\max(a,0) \| T_{i}-T_{j} \| ) \] For a more general model featuring three parameters see `LIBORCorrelationModelThreeParameterExponentialDecay`.
LIBORCorrelationModelThreeParameterExponentialDecay	Simple correlation model given by R, where R is a factor reduced matrix (see `LinearAlgebra.factorReduction(double[][], int)`) created from the \( n \) Eigenvectors of \( \tilde{R} \) belonging to the \( n \) largest non-negative Eigenvalues, where \( \tilde{R} = \tilde{\rho}_{i,j} \) and \[ \tilde{\rho}_{i,j} = b + (1-b) * \exp(-a \|T_{i} - T_{j}\| - c \max(T_{i},T_{j}))
LIBORCovarianceModel	Interface for covariance models providing a vector of (possibly stochastic) factor loadings.
LIBORCovarianceModelBH	A five parameter covariance model corresponding.
LIBORCovarianceModelCalibrateable	Interface for covariance models which may perform a calibration by providing the corresponding `getCloneCalibrated`-method.
LIBORCovarianceModelExponentialForm5Param	The five parameter covariance model consisting of an `LIBORVolatilityModelMaturityDependentFourParameterExponentialForm` and an `LIBORCorrelationModelExponentialDecay`.
LIBORCovarianceModelExponentialForm7Param
LIBORCovarianceModelFromVolatilityAndCorrelation	A covariance model build from a volatility model implementing `LIBORVolatilityModel` and a correlation model implementing `LIBORCorrelationModel`.
LIBORCovarianceModelStochasticHestonVolatility	As Heston like stochastic volatility model, using a process \( \lambda(t) = \sqrt(V(t)) \) \[ dV(t) = \kappa ( \theta - V(t) ) dt + \xi \sqrt{V(t)} dW_{1}(t), \quad V(0) = 1.0, \] where \( \lambda(0) = 1 \) to scale all factor loadings \( f_{i} \) returned by a given covariance model.
LIBORCovarianceModelStochasticVolatility	Simple stochastic volatility model, using a process \[ d\lambda(t) = \nu \lambda(t) \left( \rho \mathrm{d} W_{1}(t) + \sqrt{1-\rho^{2}} \mathrm{d} W_{2}(t) \right) \text{,} \] where \( \lambda(0) = 1 \) to scale all factor loadings \( f_{i} \) returned by a given covariance model.
LIBORIndex	A (floating) forward rate index for a given period start offset (offset from fixing) and period length.
LIBORMarketModel	Interface for LIBOR Market Models which are determined by a covariance structure defined on discrete forward rates.
LIBORMarketModelFromCovarianceModel	Implements a (generalized) LIBOR market model with generic covariance structure (lognormal, normal, displaced or stochastic volatility) with some drift approximation methods.
LIBORMarketModelFromCovarianceModel.Driftapproximation
LIBORMarketModelFromCovarianceModel.InterpolationMethod
LIBORMarketModelFromCovarianceModel.Measure
LIBORMarketModelFromCovarianceModel.StateSpace
LIBORMarketModelStandard	Implements a basic LIBOR market model with some drift approximation methods.
LIBORMarketModelStandard.Driftapproximation
LIBORMarketModelStandard.Measure
LIBORMarketModelWithTenorRefinement	Implements a discretized Heath-Jarrow-Morton model / LIBOR market model with dynamic tenor refinement, see https://papers.ssrn.com/sol3/papers.cfm?
LIBORMarketModelWithTenorRefinement.Driftapproximation
LIBORModel
LIBORModelMonteCarloSimulationModel	Basic interface which has to be implemented by Monte Carlo models for LIBOR processes.
LIBORMonteCarloSimulationFromLIBORModel	Implements convenient methods for a LIBOR market model, based on a given `LIBORModel` model (e.g. implemented by `LIBORMarketModelFromCovarianceModel`) and `MonteCarloProcess` process (e.g. implemented by `EulerSchemeFromProcessModel`
LIBORMonteCarloSimulationFromTermStructureModel	Implements convenient methods for a LIBOR market model, based on a given `LIBORMarketModelFromCovarianceModel` model and `AbstractLogNormalProcess` process.
LIBORVolatilityModel	Abstract base class and interface description of a volatility model (as it is used in `LIBORCovarianceModelFromVolatilityAndCorrelation`).
LIBORVolatilityModelFourParameterExponentialForm	Implements the volatility model \[ \sigma_{i}(t_{j}) = ( a + b (T_{i}-t_{j}) ) exp(-c (T_{i}-t_{j})) + d \text{
LIBORVolatilityModelFourParameterExponentialFormIntegrated	Implements the volatility model \[ \sigma_{i}(t_{j}) = \sqrt{ \frac{1}{t_{j+1}-t_{j}} \int_{t_{j}}^{t_{j+1}} \left( ( a + b (T_{i}-t) ) exp(-c (T_{i}-t)) + d \right)^{2} \ \mathrm{d}t } \text{
LIBORVolatilityModelFromGivenMatrix	Implements a simple volatility model using given piece-wise constant values on a given discretization grid.
LIBORVolatilityModelMaturityDependentFourParameterExponentialForm
LIBORVolatilityModelPiecewiseConstant
LIBORVolatilityModelTimeHomogenousPiecewiseConstant	Implements a piecewise constant volatility model, where \( \sigma(t,T) = sigma_{i} \) where \( i = \max \{ j : \tau_{j} \leq T-t \} \) and \( \tau_{0}, \tau_{1}, \ldots, \tau_{n-1} \) is a given time discretization.
LIBORVolatilityModelTwoParameterExponentialForm	Implements the volatility model σ_i(t_j) = a * exp(-b (T_i-t_j))
Library	Provides information on the finmath-lib library, e.g., the version.
LinearAlgebra	This class implements some methods from linear algebra (e.g. solution of a linear equation, PCA).
LinearCombinationIndex	A linear combination index paying scaling1 * index1(t) + scaling2 * index2(t)
LinearInterpolatedTimeDiscreteProcess	A linear interpolated time discrete process, that is, given a collection of tuples (Double, RandomVariableFromDoubleArray) representing realizations \( X(t_{i}) \) this class implements the `Process` and creates a stochastic process \( t \mapsto X(t) \) where \[ X(t) = \frac{t_{i+1} - t}{t_{i+1}-t_{i}} X(t_{i}) + \frac{t - t_{i}}{t_{i+1}-t_{i}} X(t_{i+1}) \] with \( t_{i} \leq t \leq t_{i+1} \).
LinearRegression	Performs a linear regression on random variables implementing RandomVariable.
LinearSmileInterpolater	This class implements the smile linearly and extrapolates piecewise constant.
LocalRiskMinimizingHedgePortfolio	This class implements a mean variance hedged portfolio of a given product (a hedge simulator).
LogNormalProcess	This class is an abstract base class to implement an Euler scheme of a multi-dimensional multi-factor log-normal Ito process.
LogNormalProcess.Scheme
MarketData	A set of raw data associated with a given date.
MarketForwardRateAgreement	Implements the valuation of a market forward rate agreement using curves (discount curve, forward curve).
MarketForwardRateAgreement	Implements the valuation of a market forward rate agreement using curves (discount curve, forward curve).
MaxIndex	A maximum index.
MersenneTwister	Mersenne Twister random number generator.
MertonJumpProcess	Implementation of the compound Poisson process for the Merton jump diffusion model.
MertonModel	Implements the characteristic function of a Merton jump diffusion model.
MertonModel	This class implements a Merton Model, that is, it provides the drift and volatility specification and performs the calculation of the numeraire (consistent with the dynamics, i.e. the drift).
MertonModelDescriptor	Descriptor for the Merton Jump Diffusion Model.
MinIndex	A minumum index.
Model	Interface to be implemented by all model.
ModelDescriptor	Interface for a model descriptor.
ModelFactory<T extends ModelDescriptor>	A factory to instantiate a model from a given descriptor.
ModelFactory	Helper factory to create a simple equity hybrid LIBOR market model.
MoneyMarketAccount	Implements the valuation of a money market account.
MonteCarloAssetModel	This class glues together an `AbstractProcessModel` and a Monte-Carlo implementation of a `MonteCarloProcessFromProcessModel` and implements `AssetModelMonteCarloSimulationModel`.
MonteCarloBlackScholesModel	This class glues together a `BlackScholeModel` and a Monte-Carlo implementation of a `MonteCarloProcessFromProcessModel` and forms a Monte-Carlo implementation of the Black-Scholes Model by implementing `AssetModelMonteCarloSimulationModel`.
MonteCarloBlackScholesModel2	Monte Carlo simulation of a simple Black-Scholes model for a stock generated discrete process
MonteCarloConditionalExpectationLinearRegressionFactory	Provides a linear regression for a vector of regression basis functions.
MonteCarloConditionalExpectationLocalizedOnDependentRegressionFactory	Provides a localized linear regression with an indicator function as localization weight for a vector of regression basis functions.
MonteCarloConditionalExpectationRegression	A service that allows to estimate conditional expectation via regression.
MonteCarloConditionalExpectationRegression.RegressionBasisFunctions	Interface for objects specifying regression basis functions (a vector of random variables).
MonteCarloConditionalExpectationRegressionFactory	Interface implemented by classes providing a `ConditionalExpectationEstimator` for conditional expectation estimation.
MonteCarloConditionalExpectationRegressionLocalizedOnDependents	A service that allows to estimate conditional expectation via regression.
MonteCarloIntegrator	A simple integrator using Monte-Carlo integration.
MonteCarloMertonModel	This class glues together a `MertonModel` and a Monte-Carlo implementation of a `MonteCarloProcessFromProcessModel`, namely `EulerSchemeFromProcessModel`, and forms a Monte-Carlo implementation of the Merton model by implementing `AssetModelMonteCarloSimulationModel`.
MonteCarloMultiAssetBlackScholesModel	This class glues together a `BlackScholeModel` and a Monte-Carlo implementation of a `MonteCarloProcessFromProcessModel` and forms a Monte-Carlo implementation of the Black-Scholes Model by implementing `AssetModelMonteCarloSimulationModel`.
MonteCarloProcess	The interface for a process (numerical scheme) of a stochastic process X where X = f(Y) and Y is an Itô process \[ dY_{j} = \mu_{j} dt + \lambda_{1,j} dW_{1} + \ldots + \lambda_{m,j} dW_{m} \] The parameters are provided by a model implementing `ProcessModel`: The value of Y(0) is provided by the method `ProcessModel.getInitialState(net.finmath.montecarlo.process.MonteCarloProcess)`.
MonteCarloProcessFromProcessModel	This class is an abstract base class to implement a multi-dimensional multi-factor Ito process.
MonteCarloProduct	Interface for products requiring an MonteCarloSimulationModel for valuation.
MonteCarloSimulationModel	The interface implemented by a simulation of an SDE.
MonteCarloVarianceGammaModel	This class glues together a `VarianceGammaModel` and a Monte-Carlo implementation of a `MonteCarloProcessFromProcessModel` and forms a Monte-Carlo implementation of the Variance Gamma Model by implementing `AssetModelMonteCarloSimulationModel`.
MultiPiterbargAnnuityMapping	Implements an annuity mapping following Vladimir Piterbarg's approach.
NegativityConstraint	Negativity constraint for calibration parameters.
NonCentralChiSquaredDistribution	Implementation of the cumulative distribution function of the non-central Χ² distribution.
NormalDistribution
NormalizingDummyProduct	A dummy product that only evaluates the value of a `NormalizingFunction`.
NormalizingFunction	Interface for a normalizing function which is to ensure the no-arbitrage requirements of a Piterbarg annuity mapping.
Notional	Base class for notional classes.
NotionalFromComponent	A stochastic notional derived from the valuation of a component.
NotionalFromConstant	A constant (non-stochastic) notional.
Numeraire	A single deterministic cashflow at a fixed time
NumerairePerformanceIndex	A (floating) rate index representing the performance of the numeraire asset for a given period start offset (offset from fixing) and period length.
NumerairePerformanceOnScheduleIndex	A (floating) rate index representing the performance of the numeraire asset.
Optimizer	Interface for numerical optimizers.
Optimizer.ObjectiveFunction	Interface for the objective function.
OptimizerFactory
OptimizerFactoryCMAES
OptimizerFactoryLevenbergMarquardt
Option	An option.
OptionData	An Equity option quote is a function of strike and maturity.
OptionSmileData	A collection of option prices or implied volatilities for a given maturity.
OptionSurfaceData	An option quote surface with the ability to query option quotes for different strikes and maturities.
ParameterAggregation<E extends ParameterObject>	Combine a set of parameter vectors to a single parameter vector.
ParameterAggregation<E extends ParameterObject>	Combine a set of parameter vectors to a single parameter vector.
ParameterInformation	A generic interface for scalar or multivariate parameters.
ParameterObject	An objects having a dependence on a parameter (double[]).
ParameterObject	An objects having a dependence on a parameter (double[]).
ParameterTransformation	Interface for parameter transformation.
ParameterTransformation	Interface for parameter transformation.
Partition	This class represents a set of discrete points in time with weighted interval reference points.
Performance	Implements an analytic product given by the ratio of two analytic products.
Performance	Implements an analytic product given by the ratio of two analytic products.
PerformanceIndex	A performance index being numeratorIndex(t) / denominatorIndex(t)
Period	A period.
Period	A period, i.e. a time interval suitable for securities with regular payment schedules.
PiecewiseCurve	A piecewise curve.
PiecewiseCurve.Builder	A builder (following the builder pattern) for PiecewiseCurve objects.
PoissonDistribution
Portfolio	Implements the valuation of a portfolio of products implementing `AnalyticProductInterface`.
Portfolio	Implements the valuation of a portfolio of products implementing `AnalyticProductInterface`.
Portfolio	Implements the pricing of a portfolio of AbstractLIBORMonteCarloProduct products under a AbstractLIBORMarketModel.
PortfolioMonteCarloProduct	A portfolio of products, each product being of AbstractMonteCarloProduct type.
PositivityConstraint	Positivity constraint for calibration parameters
PowIndex	A power index.
Process	The interface for a stochastic process X.
ProcessModel	The interface for a model of a stochastic process X where X(t) = f(t,Y(t)) and \[ dY_{j} = \mu_{j} dt + \lambda_{1,j} dW_{1} + \ldots + \lambda_{m,j} dW_{m} \] The value of Y(0) is provided by the method `ProcessModel.getInitialState(net.finmath.montecarlo.process.MonteCarloProcess)`.
ProcessTimeDiscretizationProvider	An object implementing this interfaces provides a suggestion for an optimal time-discretization associated with this object.
ProcessWithBarrier
Product	Interface implemented by all financial product which may be valued by a model.
ProductCollection	A collection of product components (like periods, options, etc.) paying the sum of their payouts.
ProductDescriptor	Interface for a product descriptor.
ProductFactory<P extends ProductDescriptor>
ProductFactoryCascade<T extends ProductDescriptor>	Implements a product factory based on a cascade of given factories.
ProductIndex	A product index being index1(t) * index2(t)
RandomNumberGenerator	Interface for an n-dimensional random number generator generating a sequence of vectors sampling the space [0,1]^{n}
RandomNumberGenerator1D	Interface for a 1-dimensional random number generator generating a sequence of vectors sampling the space [0,1]
RandomOperator
RandomVariable	This interface describes the methods implemented by an immutable random variable.
RandomVariableAccumulator	The interface implemented by a mutable random variable accumulator.
RandomVariableArray	An array of `RandomVariable` objects, implementing the `RandomVariable` interface.
RandomVariableArrayImplementation	An implementation of `RandomVariableArray` implementing an array of `RandomVariable` objects, implementing the `RandomVariable` interface.
RandomVariableDifferentiable	Interface providing additional methods for random variable implementing `RandomVariable` allowing automatic differentiation.
RandomVariableDifferentiableAAD	Implementation of `RandomVariableDifferentiable` using the backward algorithmic differentiation (adjoint algorithmic differentiation, AAD).
RandomVariableDifferentiableAADFactory
RandomVariableDifferentiableAADFactory.DiracDeltaApproximationMethod
RandomVariableDifferentiableAD	Implementation of `RandomVariableDifferentiable` using the forward algorithmic differentiation (AD).
RandomVariableDifferentiableADFactory
RandomVariableDifferentiableFactory	A factory for creating objects implementing `net.finmath.montecarlo.automaticdifferentiation.RandomVariableDifferentiable`.
RandomVariableFactory	A factory for creating objects implementing `net.finmath.stochastic.RandomVariable`.
RandomVariableFloatFactory
RandomVariableFromArrayFactory	A factory (helper class) to create random variables.
RandomVariableFromDoubleArray	The class RandomVariableFromDoubleArray represents a random variable being the evaluation of a stochastic process at a certain time within a Monte-Carlo simulation.
RandomVariableFromFloatArray	The class RandomVariableFromFloatArray represents a random variable being the evaluation of a stochastic process at a certain time within a Monte-Carlo simulation.
RandomVariableLazyEvaluation	Implements a Monte-Carlo random variable (like `RandomVariableFromDoubleArray` using late evaluation of Java 8 streams Accesses performed exclusively through the interface `RandomVariable` is thread safe (and does not mutate the class).
RandomVariableLazyEvaluationFactory
RationalFunctionInterpolation	This class provides methodologies to interpolate given sample points by rational functions, that is, given interpolation points (x_i,y_i) the class provides a continuous function y = f(x) where f(x_i) = y_i and for x_i < x < x_i+1 the function is a fraction of two polynomes f(x) = (sum a_j x^j) / (sum b_k x^k).
RationalFunctionInterpolation	This class provides methodologies to interpolate given sample points by rational functions, that is, given interpolation points (x_i,y_i) the class provides a continuous function y = f(x) where f(x_i) = y_i and for x_i < x < x_i+1 the function is a fraction of two polynomes f(x) = (sum a_j x^j) / (sum b_k x^k).
RationalFunctionInterpolation.ExtrapolationMethod
RationalFunctionInterpolation.ExtrapolationMethod
RationalFunctionInterpolation.InterpolationMethod
RationalFunctionInterpolation.InterpolationMethod
RealIntegral	Interface for real integral.
RegressionBasisFunctionsFromProducts	An implementation of an RegressionBasisFunctionsProvider using a list of AbstractMonteCarloProduct-s.
RegressionBasisFunctionsProvider	Interfaces for object providing regression basis functions.
RegularSchedule	Simple schedule generated from `TimeDiscretization`
RiskFactorForwardRate
RiskFactorFX
RiskFactorID
RombergRealIntegration	Implements a Romberg integrator.
SABRCubeCalibration	Calibration of `SABRVolatilityCube` using custom optimization.
SABRCubeParallelCalibration	Calibrates a `SABRVolatilityCubeParallel`.
SABRModel
SABRShiftedSmileCalibration	Calibration of a `SABRVolatilityCube` by shifting increments in the market data of cash settled swaptions onto physically settled swaptions and calibrating a SABR model on the resulting smiles.
SABRVolatilityCube	A volatility cube that uses a grid of SABR models for the calculation of the volatility with different strikes.
SABRVolatilityCubeParallel	A volatility cube that uses a grid of SABR models for the calculation of the volatility with different strikes.
SABRVolatilityCubeParallelFactory	Build a `SABRVolatilityCubeParallel` from given shared parameters and marketdata.
SABRVolatilityCubeSingleSmile	A simplified volatility cube that provides a volatility smile in strike for all possible maturities and terminations, based on a single set of SABR parameters.
Scalar	A scalar value implementing the RandomVariable.
ScalarConstraint	Base interface for scalar parameter constraints.
ScalarParameterInformation	An interface representing a scalar parameter.
ScalarParameterInformationImplementation	This class tells us if a parameter has to be calibrated and if it is constrained.
ScaledVolatilityCube	A volatility cube that always returns a multiple of the value an underlying cube would return.
Schedule	Interface of a schedule of interest rate periods with a fixing and payment.
ScheduleDescriptor	Descriptor for a schedule.
ScheduleFromPeriods	A schedule of interest rate periods with a fixing and payment.
ScheduleGenerator	Generates a schedule based on some meta data (frequency, maturity, date roll convention, etc.).
ScheduleGenerator.DaycountConvention	Possible day count conventions supported by `ScheduleGenerator.DaycountConvention`.
ScheduleGenerator.Frequency	Possible frequencies supported by `ScheduleGenerator`.
ScheduleGenerator.ShortPeriodConvention	Possible stub period conventions supported.
ScheduleMetaData	Deprecated.
SchedulePrototype	Class to store any relevant information to generate schedules, which have different period structure but otherwise follow the same conventions.
SeasonalCurve	The curve returns a value depending on the month of the time argument, that is, a call `getValue(model, time)` will map time to a 30/360 value using the day and month only and delegate the call to a given base curve.
SeasonalCurve.Builder	A builder (following the builder pattern) for SeasonalCurve objects.
Selector	A selection of a value on another component.
ShortRateModel	Interface for Short Rate models which are determined by a ShortRateVolatilityModelInterface.
ShortRateVolatilityModel	Interface for piecewise constant short rate volatility models with piecewise constant instantaneous short rate volatility \( t \mapsto \sigma(t) \) and piecewise constant short rate mean reversion speed \( t \mapsto a(t) \).
ShortRateVolatilityModelAsGiven	A short rate volatility model from given volatility and mean reversion.
ShortRateVolatilityModelCalibrateable	Interface for covariance models which may perform a calibration by providing the corresponding `getCloneCalibrated`-method.
ShortRateVolatilityModelHoLee
ShortRateVolatilityModelParametric	Interface for short rate volatility models which are determined by a vector of parameter.
ShortRateVolatilityModelPiecewiseConstant	Short rate volatility model with a piecewise constant volatility and a piecewise constant mean reversion.
SimpleCappedFlooredFloatingRateBond
SimpleHistroricalSimulation	Implementation of standard historical simulation.
SimpleSwap	Implements the valuation of a swap under a LIBORModelMonteCarloSimulationModel
SimpleZeroSwap	Implements the valuation of a zero swap under a LIBORModelMonteCarloSimulationModel.
SimplifiedLinearAnnuityMapping	Provides a light-weight linear annuity mapping.
SimpsonRealIntegrator	A simple integrator using Simpson's rule.
SingleAssetDigitalOptionProductDescriptor	Describes a European digital option.
SingleAssetEuropeanOptionProductDescriptor	Describes a European option.
SingleAssetFourierProductFactory	Product factory of single asset derivatives for use with a Fourier method based model.
SingleAssetFourierProductFactory.EuropeanOptionFourierMethod	Fourier method based implementation of a European option from a product descriptor.
SingleAssetMonteCarloProductFactory	Product factory of single asset derivatives for use with a Monte-Carlo method based model.
SingleAssetProductDescriptor	Interface for a product descriptor.
SmileByIntegralTransform	Base interface for Fourier-based valuations.
SmileInterpolationExtrapolationMethod	Interface for a Smile inter and extrapolation.
Solver	Generates a calibrated model for a given set of `calibrationProducts` with respect to given `CurveFromInterpolationPoints`s.
Solver	Generates a calibrated model for a given set of `calibrationProducts` with respect to given `CurveFromInterpolationPoints`s.
SolverException	Exception thrown by solvers `net.finmath.rootfinder` or `net.finmath.optimizer`.
StaticCubeCalibration	Calibration for a simple cube that only provides a single value at all coordinates.
StaticVolatilityCube	A volatility cube that always returns the given value.
StochasticLevenbergMarquardt	This class implements a stochastic Levenberg Marquardt non-linear least-squares fit algorithm.
StochasticLevenbergMarquardt.RegularizationMethod	The regularization method used to invert the approximation of the Hessian matrix.
StochasticLevenbergMarquardtAD	This class implements a stochastic Levenberg Marquardt non-linear least-squares fit algorithm.
StochasticOptimizer
StochasticOptimizer.ObjectiveFunction	The interface describing the objective function of a `StochasticOptimizer`.
StochasticOptimizerFactory
StochasticOptimizerFactoryLevenbergMarquardt
StochasticOptimizerFactoryLevenbergMarquardtAD
StochasticOptimizerFactoryPathwiseLevenbergMarquardtAD
StochasticPathwiseLevenbergMarquardt	This class implements a stochastic Levenberg Marquardt non-linear least-squares fit algorithm.
StochasticPathwiseLevenbergMarquardtAD	This class implements a stochastic Levenberg Marquardt non-linear least-squares fit algorithm.
StochasticPathwiseOptimizerFactoryLevenbergMarquardt
Swap	Implements the valuation of a swap using curves (discount curve, forward curve).
Swap	Implements the valuation of a swap using curves (discount curve, forward curve).
Swap	Create a swap from schedules, notional, indices and spreads (fixed coupons).
SwapAnnuity	Implements the valuation of a swap annuity using curves (discount curve).
SwapAnnuity	Implements the valuation of a swap annuity using curves (discount curve).
SwapLeg	Implements the valuation of a swap leg with unit notional of 1 using curves (discount curve, forward curve).
SwapLeg	Implements the valuation of a swap leg with unit notional of 1 using curves (discount curve, forward curve).
SwapLeg
SwaprateCovarianceAnalyticApproximation	This class implements an analytic approximation of the integrated instantaneous covariance of two swap rates under a LIBOR market model.
Swaption	A market interface for all swaption implementations and a holder for some product specific definitions.
Swaption	Implements the Monte-Carlo valuation of a swaption under a LIBORModelMonteCarloSimulationModel.
Swaption.ValueUnit	Swaptions specific value units, like swaption implied volatilities.
SwaptionAnalyticApproximation	This class implements an analytic swaption valuation formula under a LIBOR market model.
SwaptionAnalyticApproximationRebonato	This class implements an analytic swaption valuation formula under a LIBOR market model.
SwaptionATM	A lightweight ATM swaption product used for calibration.
SwaptionATMMarketDataFromArray	Simple swaption market data class.
SwaptionDataLattice	Saves market data of swaption on a lattice of option maturity x swap tenor x option moneyness.
SwaptionDataLattice.QuotingConvention	Quoting convention for swaption data in a lattice.
SwaptionFactory	A factory (helper class) to create swaptions extending `AbstractLIBORMonteCarloProduct` according to some (simplified) specifications.
SwaptionFromSwapSchedules	Implementation of a Monte-Carlo valuation of a swaption valuation being compatible with AAD.
SwaptionFromSwapSchedules.SwaptionType
SwaptionGeneralizedAnalyticApproximation	This class implements an analytic swaption valuation formula under a LIBOR market model.
SwaptionGeneralizedAnalyticApproximation.StateSpace
SwaptionGeneralizedAnalyticApproximation.ValueUnit
SwaptionMarketData	Basic interface to be implemented by classes providing swaption market data.
SwaptionSimple	Implements the valuation of a simplified (idealized) swaption under a LIBORModelMonteCarloSimulationModel
SwaptionSingleCurve	Implements the valuation of a swaption under a LIBORModelMonteCarloSimulationModel Important: If the LIBOR Market Model is a multi-curve model in the sense that the numeraire is not calculated from the forward curve, then this valuation does not result in the valuation of a collaterlized option on a collateralized swap.
SwaptionSingleCurveAnalyticApproximation	This class implements an analytic swaption valuation formula under a LIBOR market model.
SwaptionWithComponents	Implements the pricing of a swap under a AbstractLIBORMarketModel
SwapWithComponents	Implements the pricing of a swap under a AbstractLIBORMarketModel
Tenor
TenorConverter	This class implements a caplet volatility tenor converter.
TenorFromArray	Implements a time discretization based on dates using a reference date and an daycount convention / year fraction.
TermStructCovarianceModelFromLIBORCovarianceModel
TermStructCovarianceModelFromLIBORCovarianceModelParametric
TermStructureCovarianceModelInterface	A base class and interface description for the instantaneous covariance of an forward rate interest rate model.
TermStructureCovarianceModelParametric	A base class and interface description for the instantaneous covariance of an forward rate interest rate model.
TermStructureFactorLoadingsModelInterface	A base class and interface description for the instantaneous covariance of an forward rate interest rate model.
TermStructureFactorLoadingsModelParametricInterface	A base class and interface description for the instantaneous covariance of an forward rate interest rate model.
TermStructureModel
TermStructureMonteCarloProduct	Interface for products requiring an LIBORModelMonteCarloSimulationModel as base class
TermStructureMonteCarloSimulationModel
TermStructureTenorTimeScalingInterface
TermStructureTenorTimeScalingPicewiseConstant
TimeDiscreteEndOfMonthIndex	An index which maps is evaluation point to a fixed discrete point, the end of the month, then takes the value of a given base index at this point.
TimeDiscretization
TimeDiscretizationFromArray	This class represents a set of discrete points in time.
TimeDiscretizationFromArray.ShortPeriodLocation
TimeSeries	Interface to be implemented by finite time series.
TimeSeriesFromArray	A discrete time series.
TimeSeriesModelParametric	A parametric time series model
TimeSeriesView	A time series created from a sup-interval of another time series.
TrapezoidalRealIntegrator	A simple integrator using the trapezoidal rule.
TriggerIndex	A trigger index.
Unconstrained	Absence of constraints.
UnsupportedIndex	An index throwing an exception if his `getValue` method is called.
UnsupportedProduct	A product throwing an exception if its `getValue` method is called.
Utils	A collection of utility methods for dealing with the `net.finmath.singleswaprate` package.
VarianceGammaModel	Implements the characteristic function of a Variance Gamma model.
VarianceGammaModel	This class implements a Variance Gamma Model, that is, it provides the drift and volatility specification and performs the calculation of the numeraire (consistent with the dynamics, i.e. the drift).
VarianceGammaModelDescriptor
VarianceGammaProcess	Implementation of a time-discrete n-dimensional Variance Gamma process via Brownian subordination through a Gamma Process.
VolatilityCube	Interface to be implemented by classes providing a volatility cube for a `VolatilityCubeModel`.
VolatilityCubeFactory	A factory for all volatility cubes, based on common input.
VolatilityCubeModel	A collection of objects representing analytic valuations.
VolatilitySurface	Interface for classes representing a volatility surface, i.e.
VolatilitySurface	Interface for classes representing a volatility surface, i.e.
VolatilitySurface.QuotingConvention	Quoting conventions.
VolatilitySurface.QuotingConvention	Quoting conventions.
VolVolCube	This cube provides the volatility of the stochastic driver for each sub-tenor of the swap rate's schedule in the Piterbarg model of the annuity mapping.
WorstOfExpressCertificate
XMLParser	Interface for XML parsers creating a product descriptor from an XML file.