MertonModel (finmath lib 4.0.11 API)

java.lang.Object
- net.finmath.montecarlo.model.AbstractProcessModel
- - net.finmath.montecarlo.assetderivativevaluation.models.MertonModel

All Implemented Interfaces:

ProcessModel
```
public class MertonModel
extends AbstractProcessModel
```
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). The model is \[ dS = \mu S dt + \sigma S dW + S dJ, \quad S(0) = S_{0}, \] \[ dN = r N dt, \quad N(0) = N_{0}, \] where \( W \) is Brownian motion and \( J \) is a jump process (compound Poisson process). The process \( J \) is given by \( J(t) = \sum_{i=1}^{N(t)} (Y_{i}-1) \), where \( \log(Y_{i}) \) are i.i.d. normals with mean \( a - \frac{1}{2} b^{2} \) and standard deviation \( b \). Here \( a \) is the jump size mean and \( b \) is the jump size std. dev. The model can be rewritten as \( S = \exp(X) \), where \[ dX = \mu dt + \sigma dW + dJ^{X}, \quad X(0) = \log(S_{0}), \] with \[ J^{X}(t) = \sum_{i=1}^{N(t)} \log(Y_{i}) \] with \( \mu = r - \frac{1}{2} \sigma^2 - (exp(a)-1) \lambda \). The class provides the model of S to an MonteCarloProcess via the specification of \( f = exp \), \( \mu = r - \frac{1}{2} \sigma^2 - (exp(a)-1) \lambda \), \( \lambda_{1,1} = \sigma, \lambda_{1,2} = a - \frac{1}{2} b^2, \lambda_{1,3} = b \), i.e., of the SDE \[ dX = \mu dt + \lambda_{1,1} dW + \lambda_{1,2} dN + \lambda_{1,3} Z dN, \quad X(0) = \log(S_{0}), \] with \( S = f(X) \). See MonteCarloProcess for the notation. For an example on the construction of the three factors \( dW \), \( dN \), and \( Z dN \) see MonteCarloMertonModel.

Version:

1.0

Author:

Christian Fries

See Also:

MonteCarloMertonModel, The interface for numerical schemes., The interface for models provinding parameters to numerical schemes.

Constructor Summary

Constructors
Constructor and Description
`MertonModel(double initialValue, double riskFreeRate, double volatility, double jumpIntensity, double jumpSizeMean, double jumpSizeStDev)` Create a Heston model.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`RandomVariable`	`applyStateSpaceTransform(int componentIndex, RandomVariable randomVariable)` Applies the state space transform f_i to the given state random variable such that Y_i → f_i(Y_i) =: X_i.
`RandomVariable`	`applyStateSpaceTransformInverse(int componentIndex, RandomVariable randomVariable)`
`ProcessModel`	`getCloneWithModifiedData(Map<String,Object> dataModified)` Returns a clone of this model where the specified properties have been modified.
`RandomVariable[]`	`getDrift(int timeIndex, RandomVariable[] realizationAtTimeIndex, RandomVariable[] realizationPredictor)` This method has to be implemented to return the drift, i.e.
`RandomVariable[]`	`getFactorLoading(int timeIndex, int componentIndex, RandomVariable[] realizationAtTimeIndex)` This method has to be implemented to return the factor loadings, i.e.
`RandomVariable[]`	`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`	`getJumpIntensity()`
`double`	`getJumpSizeMean()`
`double`	`getJumpSizeStdDev()`
`int`	`getNumberOfComponents()` Returns the number of components
`RandomVariable`	`getNumeraire(double time)` Return the numeraire at a given time index.
`RandomVariable`	`getRandomVariableForConstant(double value)` Return a random variable initialized with a constant using the models random variable factory.
`double`	`getRiskFreeRate()`
`double`	`getVolatility()`

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

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

- Constructor Detail
  - MertonModel
```
public MertonModel(double initialValue,
                   double riskFreeRate,
                   double volatility,
                   double jumpIntensity,
                   double jumpSizeMean,
                   double jumpSizeStDev)
```
    Create a Heston model.
    
    Parameters:
    
    initialValue - Spot value.
    
    riskFreeRate - The risk free rate.
    
    volatility - The log volatility.
    
    jumpIntensity - The intensity parameter lambda of the compound Poisson process.
    
    jumpSizeMean - The mean jump size of the normal distributes jump sizes of the compound Poisson process.
    
    jumpSizeStDev - The standard deviation of the normal distributes jump sizes of the compound Poisson process.
- Method Detail
  - getNumberOfComponents
```
public int getNumberOfComponents()
```
    Description copied from interface: ProcessModel
    
    Returns the number of components
    
    Returns:
    
    The number of components
  - applyStateSpaceTransform
```
public RandomVariable applyStateSpaceTransform(int componentIndex,
                                               RandomVariable randomVariable)
```
    Description copied from interface: ProcessModel
    
    Applies the state space transform f_i to the given state random variable such that Y_i → f_i(Y_i) =: X_i.
    
    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.
  - applyStateSpaceTransformInverse
```
public RandomVariable applyStateSpaceTransformInverse(int componentIndex,
                                                      RandomVariable randomVariable)
```
  - getInitialState
```
public RandomVariable[] getInitialState()
```
    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.
    
    Returns:
    
    The initial value of the state variable of the process Y(t=0).
  - getNumeraire
```
public RandomVariable getNumeraire(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.
    
    Parameters:
    
    time - The time t for which the numeraire N(t) should be returned.
    
    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.
  - getDrift
```
public RandomVariable[] getDrift(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
    μ = (μ₁, ..., μ_n) 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. 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 \).
    
    Parameters:
    
    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(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
    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.
    
    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.
  - 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.
    
    Parameters:
    
    value - The constant value.
    
    Returns:
    
    A new random variable initialized with a constant value.
  - getCloneWithModifiedData
```
public ProcessModel getCloneWithModifiedData(Map<String,Object> dataModified)
```
    Description copied from interface: ProcessModel
    
    Returns a clone of this model where the specified properties have been modified. Note that there is no guarantee that a model reacts on a specification of a properties in the parameter map dataModified. If data is provided which is ignored by the model no exception may be thrown.
    
    Parameters:
    
    dataModified - Key-value-map of parameters to modify.
    
    Returns:
    
    A clone of this model (or this model if no parameter was modified).
  - getRiskFreeRate
```
public double getRiskFreeRate()
```
    Returns:
    
    the riskFreeRate
  - getVolatility
```
public double getVolatility()
```
    Returns:
    
    the volatility
  - getJumpIntensity
```
public double getJumpIntensity()
```
    Returns:
    
    the jumpIntensity
  - getJumpSizeMean
```
public double getJumpSizeMean()
```
    Returns:
    
    the jumpSizeMean
  - getJumpSizeStdDev
```
public double getJumpSizeStdDev()
```
    Returns:
    
    the jumpSizeStdDev

Class MertonModel

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Constructor Detail

MertonModel

Method Detail

getNumberOfComponents

applyStateSpaceTransform

applyStateSpaceTransformInverse

getInitialState

getNumeraire

getDrift

getFactorLoading

getRandomVariableForConstant

getCloneWithModifiedData

getRiskFreeRate

getVolatility

getJumpIntensity

getJumpSizeMean

getJumpSizeStdDev