Class LIBORMarketModelStandard

  • All Implemented Interfaces:
    IndependentModelParameterProvider, LIBORMarketModel, LIBORModel, TermStructureModel, ProcessModel

    public class LIBORMarketModelStandard
    extends AbstractProcessModel
    implements LIBORMarketModel
    Implements a basic LIBOR market model with some drift approximation methods.
    The class implements different measure(drift) / numeraire pairs (terminal and spot).
    The class specifies a LIBOR market model in its log-normal formulation, that is Lj = exp(Yj) where
    dYj = μj dt + λ1,j dW1 + ... + λm,j dWm
    see ProcessModel for details on the implemented interface.
    The model uses an AbstractLIBORCovarianceModel for the specification of 1,j,...,λm,j) as a covariance model, which may have the ability to calibrate to swaptions.
    Version:
    1.1
    Author:
    Christian Fries
    See Also:
    AbstractLIBORCovarianceModel
    • Constructor Detail

      • LIBORMarketModelStandard

        public LIBORMarketModelStandard​(TimeDiscretization liborPeriodDiscretization,
                                        ForwardCurve forwardRateCurve,
                                        LIBORCovarianceModel covarianceModel)
        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.
      • LIBORMarketModelStandard

        public LIBORMarketModelStandard​(TimeDiscretization liborPeriodDiscretization,
                                        ForwardCurve forwardRateCurve,
                                        DiscountCurve discountCurve,
                                        LIBORCovarianceModel covarianceModel)
        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.
      • LIBORMarketModelStandard

        public LIBORMarketModelStandard​(TimeDiscretization liborPeriodDiscretization,
                                        ForwardCurve forwardRateCurve,
                                        LIBORCovarianceModel covarianceModel,
                                        SwaptionMarketData 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.
      • LIBORMarketModelStandard

        public LIBORMarketModelStandard​(TimeDiscretization liborPeriodDiscretization,
                                        ForwardCurve forwardRateCurve,
                                        DiscountCurve discountCurve,
                                        LIBORCovarianceModel covarianceModel,
                                        SwaptionMarketData 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.
      • LIBORMarketModelStandard

        public LIBORMarketModelStandard​(TimeDiscretization liborPeriodDiscretization,
                                        ForwardCurve forwardRateCurve,
                                        DiscountCurve discountCurve,
                                        LIBORCovarianceModel covarianceModel,
                                        CalibrationProduct[] calibrationProducts)
                                 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.
        calibrationProducts - 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).
        Throws:
        CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.
    • Method Detail

      • getNumeraire

        public RandomVariable getNumeraire​(MonteCarloProcess process,
                                           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 ProcessModel
        Parameters:
        time - Time time t for which the numeraire should be returned N(t).
        process - The discretization process generating this model. The process provides call backs for TimeDiscretization and allows calls to getProcessValue for timeIndices less or equal the given one.
        Returns:
        The numeraire at the specified time as RandomVariableFromDoubleArray
        Throws:
        CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.
      • getInitialState

        public RandomVariable[] getInitialState​(MonteCarloProcess process)
        Description copied from interface: ProcessModel
        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 ProcessModel
        Parameters:
        process - The discretization process generating this model. The process provides call backs for TimeDiscretization and allows calls to getProcessValue for timeIndices less or equal the given one.
        Returns:
        The initial value of the state variable of the process Y(t=0).
      • getDrift

        public RandomVariable[] getDrift​(MonteCarloProcess process,
                                         int timeIndex,
                                         RandomVariable[] realizationAtTimeIndex,
                                         RandomVariable[] 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 ProcessModel
        Parameters:
        process - The discretization process generating this model. The process provides call backs for TimeDiscretization and allows calls to getProcessValue for timeIndices less or equal the given one.
        timeIndex - Time index i for which the drift should be returned μ(ti).
        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 if no predictor is available.
        Returns:
        The drift vector μ(ti) as RandomVariableFromDoubleArray[]
        See Also:
        The calculation of the drift is consistent with the calculation of the numeraire in getNumeraire.
      • getFactorLoading

        public RandomVariable[] getFactorLoading​(MonteCarloProcess process,
                                                 int timeIndex,
                                                 int componentIndex,
                                                 RandomVariable[] realizationAtTimeIndex)
        Description copied from interface: ProcessModel
        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
        dYj = μj dt + λ1,j dW1 + ... + λm,j dWm
        in an m-factor model. Here j denotes index of the component of the resulting process.
        Specified by:
        getFactorLoading in interface ProcessModel
        Parameters:
        process - The discretization process generating this model. The process provides call backs for TimeDiscretization and allows calls to getProcessValue for timeIndices less or equal the given one.
        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 RandomVariable applyStateSpaceTransform​(MonteCarloProcess process,
                                                       int timeIndex,
                                                       int componentIndex,
                                                       RandomVariable randomVariable)
        Description copied from interface: ProcessModel
        Applies the state space transform fi to the given state random variable such that Yi → fi(Yi) =: Xi.
        Specified by:
        applyStateSpaceTransform in interface ProcessModel
        Parameters:
        process - The discretization process generating this model. The process provides call backs for TimeDiscretization and allows calls to getProcessValue for timeIndices less or equal the given one.
        timeIndex - The time index (related to the model times discretization).
        componentIndex - The component index i.
        randomVariable - The state random variable Yi.
        Returns:
        New random variable holding the result of the state space transformation.
      • applyStateSpaceTransformInverse

        public RandomVariable applyStateSpaceTransformInverse​(MonteCarloProcess process,
                                                              int timeIndex,
                                                              int componentIndex,
                                                              RandomVariable randomVariable)
        Description copied from interface: ProcessModel
        Applies the inverse state space transform f-1i to the given random variable such that Xi → f-1i(Xi) =: Yi.
        Specified by:
        applyStateSpaceTransformInverse in interface ProcessModel
        Parameters:
        process - The discretization process generating this model. The process provides call backs for TimeDiscretization and allows calls to getProcessValue for timeIndices less or equal the given one.
        timeIndex - The time index (related to the model times discretization).
        componentIndex - The component index i.
        randomVariable - The state random variable Xi.
        Returns:
        New random variable holding the result of the state space transformation.
      • getRandomVariableForConstant

        public RandomVariable getRandomVariableForConstant​(double value)
        Description copied from interface: ProcessModel
        Return a random variable initialized with a constant using the models random variable factory.
        Specified by:
        getRandomVariableForConstant in interface ProcessModel
        Parameters:
        value - The constant value.
        Returns:
        A new random variable initialized with a constant value.
      • getForwardRate

        public RandomVariable getForwardRate​(MonteCarloProcess process,
                                             double time,
                                             double periodStart,
                                             double periodEnd)
                                      throws CalculationException
        Description copied from interface: TermStructureModel
        Returns the time \( t \) forward rate on the models forward curve. Note: It is guaranteed that the random variable returned by this method is \( \mathcal{F}_{t} ) \)-measurable.
        Specified by:
        getForwardRate in interface TermStructureModel
        Parameters:
        process - The discretization process generating this model. The process provides call backs for TimeDiscretization and allows calls to getProcessValue for timeIndices less or equal the given one.
        time - The evaluation time.
        periodStart - The period start of the forward rate.
        periodEnd - The period end of the forward rate.
        Returns:
        The forward rate.
        Throws:
        CalculationException - Thrown if model fails to calculate the random variable.
      • getNumberOfComponents

        public int getNumberOfComponents()
        This method is just a synonym to getNumberOfLibors
        Specified by:
        getNumberOfComponents in interface ProcessModel
        Returns:
        The number of components
      • getNumberOfFactors

        public int getNumberOfFactors()
        Description copied from interface: ProcessModel
        Returns the number of factors m, i.e., the number of independent Brownian drivers.
        Specified by:
        getNumberOfFactors in interface ProcessModel
        Returns:
        The number of factors.
      • getNumberOfLibors

        public int getNumberOfLibors()
        Description copied from interface: LIBORModel
        Get the number of LIBORs in the LIBOR discretization.
        Specified by:
        getNumberOfLibors in interface LIBORModel
        Returns:
        The number of LIBORs in the LIBOR discretization
      • getLiborPeriod

        public double getLiborPeriod​(int timeIndex)
        Description copied from interface: LIBORModel
        The period start corresponding to a given forward rate discretization index.
        Specified by:
        getLiborPeriod in interface LIBORModel
        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: LIBORModel
        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 LIBORModel
        Parameters:
        time - The period start.
        Returns:
        The index corresponding to a given time (interpretation is start of period)
      • getIntegratedLIBORCovariance

        public double[][][] getIntegratedLIBORCovariance​(TimeDiscretization simulationTimeDiscretization)
        Description copied from interface: LIBORMarketModel
        Returns the integrated instantaneous log-forward rate covariance, i.e., \( \int_{0}^{t_i} \mathrm{d} \log(L_{j}) \mathrm{d} \log(L_{k}) \mathrm{d}t \). The array returned has the parametrization [i][j][k], i.e., integratedLIBORCovariance[timeIndex][componentIndex1][componentIndex2].
        Specified by:
        getIntegratedLIBORCovariance in interface LIBORMarketModel
        Parameters:
        simulationTimeDiscretization - The timeDiscretization used for the integration.
        Returns:
        The integrated instantaneous log-LIBOR covariance.
      • setDriftApproximationMethod

        public void setDriftApproximationMethod​(LIBORMarketModelStandard.Driftapproximation driftApproximationMethod)
        Parameters:
        driftApproximationMethod - The driftApproximationMethod to set.
      • getAnalyticModel

        public AnalyticModel getAnalyticModel()
        Description copied from interface: TermStructureModel
        Return the associated analytic model, a collection of market date object like discount curve, forward curve and volatility surfaces.
        Specified by:
        getAnalyticModel in interface TermStructureModel
        Returns:
        The associated analytic model.
      • getSwaptionMarketData

        public SwaptionMarketData 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).