LIBORMarketModel (finmath lib 1.3.4 API)

java.lang.Object
- net.finmath.montecarlo.model.AbstractModel
- - net.finmath.montecarlo.interestrate.LIBORMarketModel

All Implemented Interfaces:

LIBORMarketModelInterface, AbstractModelInterface
```
public class LIBORMarketModel
extends AbstractModel
implements LIBORMarketModelInterface
```
Implements a (generalized) LIBOR market model with some drift approximation methods.

In its default case the class specifies a multi-factor LIBOR market model in its log-normal formulation, that is L_j = exp(Y_j) where \[ dY_{j} = \mu_{j} dt + \lambda_{1,j} dW_{1} + \ldots + \lambda_{m,j} dW_{m} \]
The model uses an AbstractLIBORCovarianceModel for the specification of (λ_1,j,...,λ_m,j) as a covariance model. See AbstractModelInterface for details on the implemented interface

However, the class is more general:
- The model may be log-normal or normal specification with a given local volatility.
- The class implements different measure(drift) / numeraire pairs: terminal measure and spot measure.
- The class allows to configure a discounting curve (e.g. for "OIS discounting") using a simple deterministic zero spread. In this case, the numeraire \( N(t) \) is adjusted by \( \exp( \int_0^t -\lambda(\tau) d\tau ) \).
The class specifies a LIBOR market model, that is L_j = f(Y_j) where
- f is f(x) = exp(x) (default, log-normal LIBOR Market Model) or
- f is f(x) = x (normal model, used if property.set("stateSpace","NORMAL"))
and
dY_j = μ_j dt + λ_1,j dW₁ + ... + λ_m,j dW_m

see AbstractModelInterface for details on the implemented interface.
The model uses an AbstractLIBORCovarianceModel as a covariance model. If the covariance model is of type AbstractLIBORCovarianceModelParametric a calibration to swaptions can be performed.
Note that λ may still depend on L, hence generating a log-normal dynamic for L even if the stateSpace property has been set to NORMAL.
The map properties allows to configure the model. The following keys may be used:
- measure: Possible values:
  - SPOT: Simulate under spot measure. In this case, the single curve numeraire is \( N(T_{i}) = \prod_{j=0}^{i-1} (1 + L(T_{j},T_{j+1};T_{j}) (T_{j+1}-T_{j})) \).
  - TERMINAL: Simulate under terminal measure. In this case, the single curve numeraire is \( N(T_{i}) = P(T_{n};T_{i}) = \prod_{j=i}^{n-1} (1 + L(T_{j},T_{j+1};T_{i}) (T_{j+1}-T_{j}))^{-1} \).
- stateSpace: Possible values:
  - LOGNORMAL: The state space transform is set to exp, i.e., L = exp(Y). When the covariance model is deterministic, then this is the classical lognormal LIBOR market model. Note that the covariance model may still provide a local volatility function.
  - NORMAL: The state space transform is set to identity, i.e., L = Y. When the covariance model is deterministic, then this is a normal LIBOR market model. Note that the covariance model may still provide a local volatility function.
- liborCap: An optional Double value applied as a cap to the LIBOR rates. May be used to limit the simulated valued to prevent values attaining POSITIVE_INFINITY and numerical problems. To disable the cap, set liborCap to Double.POSITIVE_INFINITY.
The main task of this class is to calculate the risk-neutral drift and the corresponding numeraire given the covariance model. The calibration of the covariance structure is not part of this class. For the calibration of parametric models of the instantaneous covariance see AbstractLIBORCovarianceModelParametric.getCloneCalibrated(LIBORMarketModelInterface, AbstractLIBORMonteCarloProduct[], double[], double[], Map).
Version:

1.2

Author:

Christian Fries

See Also:

The interface for numerical schemes., The interface for models provinding parameters to numerical schemes., The abstract covariance model plug ins., A parametic covariance model including a generic calibration algorithm.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`LIBORMarketModel.CalibrationItem`
`static class`	`LIBORMarketModel.Driftapproximation`
`static class`	`LIBORMarketModel.Measure`
`static class`	`LIBORMarketModel.StateSpace`

Constructor Summary

Constructors
Constructor and Description
`LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization, AnalyticModelInterface analyticModel, ForwardCurveInterface forwardRateCurve, DiscountCurveInterface discountCurve, AbstractLIBORCovarianceModel covarianceModel, LIBORMarketModel.CalibrationItem[] calibrationItems, Map<String,?> properties)` Creates a LIBOR Market Model for given covariance.
`LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization, ForwardCurveInterface forwardRateCurve, AbstractLIBORCovarianceModel covarianceModel)` Creates a LIBOR Market Model for given covariance.
`LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization, ForwardCurveInterface forwardRateCurve, AbstractLIBORCovarianceModel covarianceModel, AbstractSwaptionMarketData swaptionMarketData)` Creates a LIBOR Market Model using a given covariance model and calibrating this model to given swaption volatility data.
`LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization, ForwardCurveInterface forwardRateCurve, DiscountCurveInterface discountCurve, AbstractLIBORCovarianceModel covarianceModel)` Creates a LIBOR Market Model for given covariance.
`LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization, ForwardCurveInterface forwardRateCurve, DiscountCurveInterface discountCurve, AbstractLIBORCovarianceModel covarianceModel, AbstractSwaptionMarketData swaptionMarketData)` Creates a LIBOR Market Model for given covariance.
`LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization, ForwardCurveInterface forwardRateCurve, DiscountCurveInterface discountCurve, AbstractLIBORCovarianceModel covarianceModel, AbstractSwaptionMarketData swaptionMarketData, Map<String,?> properties)` Creates a LIBOR Market Model for given covariance.
`LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization, ForwardCurveInterface forwardRateCurve, DiscountCurveInterface discountCurve, AbstractLIBORCovarianceModel covarianceModel, LIBORMarketModel.CalibrationItem[] calibrationItems, Map<String,?> properties)` Creates a LIBOR Market Model for given covariance.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`RandomVariableInterface`	`applyStateSpaceTransform(int componentIndex, RandomVariableInterface randomVariable)` Applied the state space transform f_i to the given state random variable such that Y_i → f_i(Y_i) =: X_i.
`Object`	`clone()`
`AnalyticModelInterface`	`getAnalyticModel()` Return the associated analytic model, a collection of market date object like discount curve, forward curve and volatility surfaces.
`LIBORMarketModel`	`getCloneWithModifiedCovarianceModel(AbstractLIBORCovarianceModel covarianceModel)` Create a new object implementing LIBORMarketModelInterface, using the new covariance model.
`LIBORMarketModel`	`getCloneWithModifiedData(Map<String,Object> dataModified)` Create a new object implementing LIBORMarketModelInterface, using the new data.
`AbstractLIBORCovarianceModel`	`getCovarianceModel()` Return the covariance model.
`DiscountCurveInterface`	`getDiscountCurve()` Return the discount curve associated the forwards.
`RandomVariableInterface[]`	`getDrift(int timeIndex, RandomVariableInterface[] realizationAtTimeIndex, RandomVariableInterface[] realizationPredictor)` Return the complete vector of the drift for the time index timeIndex, given that current state is realizationAtTimeIndex.
`LIBORMarketModel.Driftapproximation`	`getDriftApproximationMethod()`
`RandomVariableInterface[]`	`getFactorLoading(int timeIndex, int componentIndex, RandomVariableInterface[] realizationAtTimeIndex)` This method has to be implemented to return the factor loadings, i.e.
`ForwardCurveInterface`	`getForwardRateCurve()` Return the initial forward rate curve.
`RandomVariableInterface[]`	`getInitialState()` Returns the initial value of the state variable of the process Y, not to be confused with the initial value of the model X (which is the state space transform applied to this state value.
`double[][][]`	`getIntegratedLIBORCovariance()` Returns the integrated instantaneous log-forward rate covariance, i.e., \int_0^t_i d log(L_j) d log(L_k) dt.
`RandomVariableInterface`	`getLIBOR(int timeIndex, int liborIndex)`
`double`	`getLiborPeriod(int timeIndex)` The period start corresponding to a given forward rate discretization index.
`TimeDiscretizationInterface`	`getLiborPeriodDiscretization()` The tenor time discretization of the forward rate curve.
`int`	`getLiborPeriodIndex(double time)` Same as java.util.Arrays.binarySearch(liborPeriodDiscretization,time).
`LIBORMarketModel.Measure`	`getMeasure()`
`int`	`getNumberOfComponents()` Returns the number of components
`int`	`getNumberOfLibors()` Get the number of LIBORs in the LIBOR discretization.
`RandomVariableInterface`	`getNumeraire(double time)` Return the numeraire at a given time.
`AbstractSwaptionMarketData`	`getSwaptionMarketData()` Return the swaption market data used for calibration (if any, may be null).
`String`	`toString()`

Methods inherited from class net.finmath.montecarlo.model.AbstractModel
getInitialValue, getMonteCarloWeights, getNumberOfFactors, getProcess, getProcessValue, getTime, getTimeDiscretization, getTimeIndex, setProcess

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface net.finmath.montecarlo.model.AbstractModelInterface
getNumberOfFactors, getProcess, getTimeDiscretization, setProcess

- Constructor Detail
  - LIBORMarketModel
```
public LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization,
                        AnalyticModelInterface analyticModel,
                        ForwardCurveInterface forwardRateCurve,
                        DiscountCurveInterface discountCurve,
                        AbstractLIBORCovarianceModel covarianceModel,
                        LIBORMarketModel.CalibrationItem[] calibrationItems,
                        Map<String,?> properties)
                 throws CalculationException
```
    Creates a LIBOR Market Model for given covariance.
    If calibrationItems in non-empty and the covariance model is a parametric model, the covariance will be replaced by a calibrate version of the same model, i.e., the LIBOR Market Model will be calibrated.
    The map properties allows to configure the model. The following keys may be used:
    - measure: Possible values:
      
      SPOT (String): Simulate under spot measure.
      
      TERMINAL (String): Simulate under terminal measure.
    - stateSpace: Possible values:
      
      LOGNORMAL (String): Simulate L = exp(Y).
      
      NORMAL (String): Simulate L = Y.
    - liborCap: An optional Double value applied as a cap to the LIBOR rates. May be used to limit the simulated valued to prevent values attaining POSITIVE_INFINITY and numerical problems. To disable the cap, set liborCap to Double.POSITIVE_INFINITY.
    - calibrationParameters: Possible values:
      
      Map<String,Object> a parameter map with the following key/value pairs:
      
      accuracy: Double specifying the required solver accuracy.
      
      maxIterations: Integer specifying the maximum iterations for the solver.
    Parameters:
    
    liborPeriodDiscretization - The discretization of the interest rate curve into forward rates (tenor structure).
    
    analyticModel - The associated analytic model of this model (containing the associated market data objects like curve).
    
    forwardRateCurve - The initial values for the forward rates.
    
    discountCurve - The discount curve to use. This will create an LMM model with a deterministic zero-spread discounting adjustment.
    
    covarianceModel - The covariance model to use.
    
    calibrationItems - The vector of calibration items (a union of a product, target value and weight) for the objective function sum weight(i) * (modelValue(i)-targetValue(i).
    
    properties - Key value map specifying properties like measure and stateSpace.
    
    Throws:
    
    CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.
  - LIBORMarketModel
```
public LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization,
                        ForwardCurveInterface forwardRateCurve,
                        AbstractLIBORCovarianceModel covarianceModel)
                 throws CalculationException
```
    Creates a LIBOR Market Model for given covariance.
    
    Parameters:
    
    liborPeriodDiscretization - The discretization of the interest rate curve into forward rates (tenor structure).
    
    forwardRateCurve - The initial values for the forward rates.
    
    covarianceModel - The covariance model to use.
    
    Throws:
    
    CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.
  - LIBORMarketModel
```
public LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization,
                        ForwardCurveInterface forwardRateCurve,
                        DiscountCurveInterface discountCurve,
                        AbstractLIBORCovarianceModel covarianceModel)
                 throws CalculationException
```
    Creates a LIBOR Market Model for given covariance.
    
    Parameters:
    
    liborPeriodDiscretization - The discretization of the interest rate curve into forward rates (tenor structure).
    
    forwardRateCurve - The initial values for the forward rates.
    
    discountCurve - The discount curve to use. This will create an LMM model with a deterministic zero-spread discounting adjustment.
    
    covarianceModel - The covariance model to use.
    
    Throws:
    
    CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.
  - LIBORMarketModel
```
public LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization,
                        ForwardCurveInterface forwardRateCurve,
                        AbstractLIBORCovarianceModel covarianceModel,
                        AbstractSwaptionMarketData swaptionMarketData)
                 throws CalculationException
```
    Creates a LIBOR Market Model using a given covariance model and calibrating this model to given swaption volatility data.
    
    Parameters:
    
    liborPeriodDiscretization - The discretization of the interest rate curve into forward rates (tenor structure).
    
    forwardRateCurve - The initial values for the forward rates.
    
    covarianceModel - The covariance model to use.
    
    swaptionMarketData - The set of swaption values to calibrate to.
    
    Throws:
    
    CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.
  - LIBORMarketModel
```
public LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization,
                        ForwardCurveInterface forwardRateCurve,
                        DiscountCurveInterface discountCurve,
                        AbstractLIBORCovarianceModel covarianceModel,
                        AbstractSwaptionMarketData swaptionMarketData)
                 throws CalculationException
```
    Creates a LIBOR Market Model for given covariance.
    
    Parameters:
    
    liborPeriodDiscretization - The discretization of the interest rate curve into forward rates (tenor structure).
    
    forwardRateCurve - The initial values for the forward rates.
    
    discountCurve - The discount curve to use. This will create an LMM model with a deterministic zero-spread discounting adjustment.
    
    covarianceModel - The covariance model to use.
    
    swaptionMarketData - The set of swaption values to calibrate to.
    
    Throws:
    
    CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.
  - LIBORMarketModel
```
public LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization,
                        ForwardCurveInterface forwardRateCurve,
                        DiscountCurveInterface discountCurve,
                        AbstractLIBORCovarianceModel covarianceModel,
                        AbstractSwaptionMarketData swaptionMarketData,
                        Map<String,?> properties)
                 throws CalculationException
```
    Creates a LIBOR Market Model for given covariance.
    
    Parameters:
    
    liborPeriodDiscretization - The discretization of the interest rate curve into forward rates (tenor structure).
    
    forwardRateCurve - The initial values for the forward rates.
    
    discountCurve - The discount curve to use. This will create an LMM model with a deterministic zero-spread discounting adjustment.
    
    covarianceModel - The covariance model to use.
    
    swaptionMarketData - The set of swaption values to calibrate to.
    
    properties - Key value map specifying properties like measure and stateSpace.
    
    Throws:
    
    CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.
  - LIBORMarketModel
```
public LIBORMarketModel(TimeDiscretizationInterface liborPeriodDiscretization,
                        ForwardCurveInterface forwardRateCurve,
                        DiscountCurveInterface discountCurve,
                        AbstractLIBORCovarianceModel covarianceModel,
                        LIBORMarketModel.CalibrationItem[] calibrationItems,
                        Map<String,?> properties)
                 throws CalculationException
```
    Creates a LIBOR Market Model for given covariance.
    If calibrationItems in non-empty and the covariance model is a parametric model, the covariance will be replaced by a calibrate version of the same model, i.e., the LIBOR Market Model will be calibrated.
    The map properties allows to configure the model. The following keys may be used:
    - measure: Possible values:
      
      SPOT (String): Simulate under spot measure.
      
      TERMINAL (String): Simulate under terminal measure.
    - stateSpace: Possible values:
      
      LOGNORMAL (String): Simulate L = exp(Y).
      
      NORMAL (String): Simulate L = Y.
    - calibrationParameters: Possible values:
      
      Map<String,Object> a parameter map with the following key/value pairs:
      
      accuracy: Double specifying the required solver accuracy.
      
      maxIterations: Integer specifying the maximum iterations for the solver.
    Parameters:
    
    liborPeriodDiscretization - The discretization of the interest rate curve into forward rates (tenor structure).
    
    forwardRateCurve - The initial values for the forward rates.
    
    discountCurve - The discount curve to use. This will create an LMM model with a deterministic zero-spread discounting adjustment.
    
    covarianceModel - The covariance model to use.
    
    calibrationItems - The vector of calibration items (a union of a product, target value and weight) for the objective function sum weight(i) * (modelValue(i)-targetValue(i).
    
    properties - Key value map specifying properties like measure and stateSpace.
    
    Throws:
    
    CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.
- Method Detail
  - getNumeraire
```
public RandomVariableInterface getNumeraire(double time)
                                     throws CalculationException
```
    Return the numeraire at a given time. The numeraire is provided for interpolated points. If requested on points which are not part of the tenor discretization, the numeraire uses a linear interpolation of the reciprocal value. See ISBN 0470047224 for details.
    
    Specified by:
    
    getNumeraire in interface AbstractModelInterface
    
    Parameters:
    
    time - Time time t for which the numeraire should be returned N(t).
    
    Returns:
    
    The numeraire at the specified time as RandomVariableInterface
    
    Throws:
    
    CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.
  - getInitialState
```
public RandomVariableInterface[] getInitialState()
```
    Description copied from interface: AbstractModelInterface
    
    Returns the initial value of the state variable of the process Y, not to be confused with the initial value of the model X (which is the state space transform applied to this state value.
    
    Specified by:
    
    getInitialState in interface AbstractModelInterface
    
    Returns:
    
    The initial value of the state variable of the process Y(t=0).
  - getDrift
```
public RandomVariableInterface[] getDrift(int timeIndex,
                                          RandomVariableInterface[] realizationAtTimeIndex,
                                          RandomVariableInterface[] realizationPredictor)
```
    Return the complete vector of the drift for the time index timeIndex, given that current state is realizationAtTimeIndex. Note: The random variable returned is a defensive copy and may be modified. The drift will be zero for rates being already fixed.
    
    Specified by:
    
    getDrift in interface AbstractModelInterface
    
    Parameters:
    
    timeIndex - Time index i for which the drift should be returned μ(t_i).
    
    realizationAtTimeIndex - Time current forward rate vector at time index i which should be used in the calculation.
    
    realizationPredictor - The given realization at timeIndex+1 or null of no predictor is available.
    
    Returns:
    
    The drift vector μ(t_i) as RandomVariable[]
    
    See Also:
    
    The calculation of the drift is consistent with the calculation of the numeraire in getNumeraire.
  - getFactorLoading
```
public RandomVariableInterface[] getFactorLoading(int timeIndex,
                                                  int componentIndex,
                                                  RandomVariableInterface[] realizationAtTimeIndex)
```
    Description copied from interface: AbstractModelInterface
    
    This method has to be implemented to return the factor loadings, i.e. the coefficient vector
    λ_j = (λ_1,j, ..., λ_m,j) such that X = f(Y) and
    dY_j = μ_j dt + λ_1,j dW₁ + ... + λ_m,j dW_m
    in an m-factor model. Here j denotes index of the component of the resulting process.
    
    Specified by:
    
    getFactorLoading in interface AbstractModelInterface
    
    Parameters:
    
    timeIndex - The time index (related to the model times discretization).
    
    componentIndex - The index j of the driven component.
    
    realizationAtTimeIndex - The realization of X at the time corresponding to timeIndex (in order to implement local and stochastic volatlity models).
    
    Returns:
    
    The factor loading for given factor and component.
  - applyStateSpaceTransform
```
public RandomVariableInterface applyStateSpaceTransform(int componentIndex,
                                                        RandomVariableInterface randomVariable)
```
    Description copied from interface: AbstractModelInterface
    
    Applied the state space transform f_i to the given state random variable such that Y_i → f_i(Y_i) =: X_i.
    
    Specified by:
    
    applyStateSpaceTransform in interface AbstractModelInterface
    
    Parameters:
    
    componentIndex - The component index i.
    
    randomVariable - The state random variable Y_i.
    
    Returns:
    
    New random variable holding the result of the state space transformation.
  - getDriftApproximationMethod
```
public LIBORMarketModel.Driftapproximation getDriftApproximationMethod()
```
    Returns:
    
    Returns the driftApproximationMethod.
  - getLIBOR
```
public RandomVariableInterface getLIBOR(int timeIndex,
                                        int liborIndex)
                                 throws CalculationException
```
    Specified by:
    
    getLIBOR in interface LIBORMarketModelInterface
    
    Throws:
    
    CalculationException
  - getNumberOfComponents
```
public int getNumberOfComponents()
```
    Description copied from interface: AbstractModelInterface
    
    Returns the number of components
    
    Specified by:
    
    getNumberOfComponents in interface AbstractModelInterface
    
    Returns:
    
    The number of components
  - getNumberOfLibors
```
public int getNumberOfLibors()
```
    Description copied from interface: LIBORMarketModelInterface
    
    Get the number of LIBORs in the LIBOR discretization.
    
    Specified by:
    
    getNumberOfLibors in interface LIBORMarketModelInterface
    
    Returns:
    
    The number of LIBORs in the LIBOR discretization
  - getLiborPeriod
```
public double getLiborPeriod(int timeIndex)
```
    Description copied from interface: LIBORMarketModelInterface
    
    The period start corresponding to a given forward rate discretization index.
    
    Specified by:
    
    getLiborPeriod in interface LIBORMarketModelInterface
    
    Parameters:
    
    timeIndex - The index corresponding to a given time (interpretation is start of period)
    
    Returns:
    
    The period start corresponding to a given forward rate discretization index.
  - getLiborPeriodIndex
```
public int getLiborPeriodIndex(double time)
```
    Description copied from interface: LIBORMarketModelInterface
    
    Same as java.util.Arrays.binarySearch(liborPeriodDiscretization,time). Will return a negative value if the time is not found, but then -index-1 corresponds to the index of the smallest time greater than the given one.
    
    Specified by:
    
    getLiborPeriodIndex in interface LIBORMarketModelInterface
    
    Parameters:
    
    time - The period start.
    
    Returns:
    
    The index corresponding to a given time (interpretation is start of period)
  - getLiborPeriodDiscretization
```
public TimeDiscretizationInterface getLiborPeriodDiscretization()
```
    Description copied from interface: LIBORMarketModelInterface
    
    The tenor time discretization of the forward rate curve.
    
    Specified by:
    
    getLiborPeriodDiscretization in interface LIBORMarketModelInterface
    
    Returns:
    
    The tenor time discretization of the forward rate curve.
  - getMeasure
```
public LIBORMarketModel.Measure getMeasure()
```
    Returns:
    
    Returns the measure.
  - getIntegratedLIBORCovariance
```
public double[][][] getIntegratedLIBORCovariance()
```
    Description copied from interface: LIBORMarketModelInterface
    
    Returns the integrated instantaneous log-forward rate covariance, i.e., \int_0^t_i d log(L_j) d log(L_k) dt. The array returned has the parametrization [i][j][k], i.e., integratedLIBORCovariance[timeIndex][componentIndex1][componentIndex2].
    
    Specified by:
    
    getIntegratedLIBORCovariance in interface LIBORMarketModelInterface
    
    Returns:
    
    The integrated instantaneous log-LIBOR covariance.
  - clone
```
public Object clone()
```
    Overrides:
    
    clone in class Object
  - getAnalyticModel
```
public AnalyticModelInterface getAnalyticModel()
```
    Description copied from interface: LIBORMarketModelInterface
    
    Return the associated analytic model, a collection of market date object like discount curve, forward curve and volatility surfaces.
    
    Specified by:
    
    getAnalyticModel in interface LIBORMarketModelInterface
    
    Returns:
    
    The associated analytic model.
  - getDiscountCurve
```
public DiscountCurveInterface getDiscountCurve()
```
    Description copied from interface: LIBORMarketModelInterface
    
    Return the discount curve associated the forwards.
    
    Specified by:
    
    getDiscountCurve in interface LIBORMarketModelInterface
    
    Returns:
    
    the discount curve associated the forwards.
  - getForwardRateCurve
```
public ForwardCurveInterface getForwardRateCurve()
```
    Description copied from interface: LIBORMarketModelInterface
    
    Return the initial forward rate curve.
    
    Specified by:
    
    getForwardRateCurve in interface LIBORMarketModelInterface
    
    Returns:
    
    the forward rate curve
  - getSwaptionMarketData
```
public AbstractSwaptionMarketData getSwaptionMarketData()
```
    Return the swaption market data used for calibration (if any, may be null).
    
    Returns:
    
    The swaption market data used for calibration (if any, may be null).
  - getCovarianceModel
```
public AbstractLIBORCovarianceModel getCovarianceModel()
```
    Description copied from interface: LIBORMarketModelInterface
    
    Return the covariance model.
    
    Specified by:
    
    getCovarianceModel in interface LIBORMarketModelInterface
    
    Returns:
    
    The covariance model.
  - getCloneWithModifiedCovarianceModel
```
public LIBORMarketModel getCloneWithModifiedCovarianceModel(AbstractLIBORCovarianceModel covarianceModel)
```
    Description copied from interface: LIBORMarketModelInterface
    
    Create a new object implementing LIBORMarketModelInterface, using the new covariance model.
    
    Specified by:
    
    getCloneWithModifiedCovarianceModel in interface LIBORMarketModelInterface
    
    Parameters:
    
    covarianceModel - A covariance model
    
    Returns:
    
    A new LIBORMarketModel using the specified covariance model.
  - getCloneWithModifiedData
```
public LIBORMarketModel getCloneWithModifiedData(Map<String,Object> dataModified)
                                          throws CalculationException
```
    Description copied from interface: LIBORMarketModelInterface
    
    Create a new object implementing LIBORMarketModelInterface, using the new data.
    
    Specified by:
    
    getCloneWithModifiedData in interface LIBORMarketModelInterface
    
    Parameters:
    
    dataModified - A map with values to be used in constructions (keys are identical to parameter names of the constructors).
    
    Returns:
    
    A new object implementing LIBORMarketModelInterface, using the new data.
    
    Throws:
    
    CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class LIBORMarketModel

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class net.finmath.montecarlo.model.AbstractModel

Methods inherited from class java.lang.Object

Methods inherited from interface net.finmath.montecarlo.model.AbstractModelInterface

Constructor Detail

LIBORMarketModel

LIBORMarketModel

LIBORMarketModel

LIBORMarketModel

LIBORMarketModel

LIBORMarketModel

LIBORMarketModel

Method Detail

getNumeraire

getInitialState

getDrift

getFactorLoading

applyStateSpaceTransform

getDriftApproximationMethod

getLIBOR

getNumberOfComponents

getNumberOfLibors

getLiborPeriod

getLiborPeriodIndex

getLiborPeriodDiscretization

getMeasure

getIntegratedLIBORCovariance

clone

getAnalyticModel

getDiscountCurve

getForwardRateCurve

getSwaptionMarketData

getCovarianceModel

getCloneWithModifiedCovarianceModel

getCloneWithModifiedData

toString