Module net.finmath.lib
Package net.finmath.montecarlo.interestrate.models

Class HullWhiteModelWithConstantCoeff

    • Constructor Detail

      • HullWhiteModelWithConstantCoeff

        public HullWhiteModelWithConstantCoeff​(TimeDiscretization liborPeriodDiscretization,
                                       AnalyticModel analyticModel,
                                       ForwardCurve forwardRateCurve,
                                       DiscountCurve discountCurve,
                                       double meanReversion,
                                       double volatility,
                                       Map<String,​?> properties)
        Creates a Hull-White model which implements LIBORMarketModel.
        Parameters:
        liborPeriodDiscretization - The forward rate discretization to be used in the getLIBOR method.
        analyticModel - The analytic model to be used (currently not used, may be null).
        forwardRateCurve - The forward curve to be used (currently not used, - the model uses disocuntCurve only.
        discountCurve - The disocuntCurve (currently also used to determine the forward curve).
        meanReversion - The mean reversion speed parameter a.
        volatility - The short rate volatility \( \sigma \).
        properties - A map specifying model properties (currently not used, may be null).

    • Method Detail

      • getNumberOfComponents

        public int getNumberOfComponents()
        Description copied from interface: ProcessModel
        Returns the number of components
        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.

      • 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.

      • 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).

      • getNumeraire

        public RandomVariable getNumeraire​(MonteCarloProcess process,
                                   double time)
                            throws CalculationException
        Description copied from interface: ProcessModel
        Return the numeraire at a given time index. Note: The random variable returned is a defensive copy and may be modified.
        Specified by:
        getNumeraire 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.
        time - The time t for which the numeraire N(t) should be returned.
        Returns:
        The numeraire at the specified time as RandomVariable
        Throws:
        CalculationException - Thrown if the valuation fails, specific cause may be available via the cause() method.

      • getDrift

        public RandomVariable[] getDrift​(MonteCarloProcess process,
                                 int timeIndex,
                                 RandomVariable[] realizationAtTimeIndex,
                                 RandomVariable[] realizationPredictor)
        Description copied from interface: ProcessModel
        This method has to be implemented to return the drift, i.e. the coefficient vector
        μ = (μ1, ..., μn) 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. Since the model is provided only on a time discretization, the method may also (should try to) return the drift as \( \frac{1}{t_{i+1}-t_{i}} \int_{t_{i}}^{t_{i+1}} \mu(\tau) \mathrm{d}\tau \).
        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 - The time index (related to the model times discretization).
        realizationAtTimeIndex - The given realization at timeIndex
        realizationPredictor - The given realization at timeIndex+1 or null if no predictor is available.
        Returns:
        The drift or average drift from timeIndex to timeIndex+1, i.e. \( \frac{1}{t_{i+1}-t_{i}} \int_{t_{i}}^{t_{i+1}} \mu(\tau) \mathrm{d}\tau \) (or a suitable approximation).

      • 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.

      • 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.

      • getLIBOR

        public RandomVariable getLIBOR​(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:
        getLIBOR 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.

      • 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)

      • 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.

      • getShortRateConditionalVariance

        public double getShortRateConditionalVariance​(double time,
                                              double maturity)
        Calculates the variance \( \mathop{Var}(r(t) \vert r(s) ) \), that is \( \int_{s}^{t} \sigma^{2}(\tau) \exp(-2 \cdot a \cdot (t-\tau)) \ \mathrm{d}\tau \) where \( a \) is the meanReversion and \( \sigma \) is the short rate instantaneous volatility.
        Parameters:
        time - The parameter s in \( \int_{s}^{t} \sigma^{2}(\tau) \exp(-2 \cdot a \cdot (t-\tau)) \ \mathrm{d}\tau \)
        maturity - The parameter t in \( \int_{s}^{t} \sigma^{2}(\tau) \exp(-2 \cdot a \cdot (t-\tau)) \ \mathrm{d}\tau \)
        Returns:
        The integrated square volatility.

      • getIntegratedBondSquaredVolatility

        public double getIntegratedBondSquaredVolatility​(double time,
                                                 double maturity)