Mobile Hamburger Menu
Desktop Hamburger Menu
Home Calculators Guides
Document Title

MERTON'S JUMP DIFFUSION MODEL

By ProbabilityofProfit.com

Merton’s Jump Diffusion Model was developed by Robert C. Merton in 1979, and serves as an extension of the Black-Scholes model by introducing an additional term to incorporate dividends and or holding costs.
This model also considers the possibility of sudden discontinuous jumps in the asset’s underlying price due to unexpected events/volatility in the market.

THEORY & METHODOLOGY

THEORY

Merton’s Jump Diffusion Model, introduced by Robert C. Merton in 1979, builds on the Black-Scholes model by adding a layer of sophistication. Unlike Black-Scholes, which only deals with continuous price movements, Merton’s model accounts for dividends and holding costs. More importantly, it introduces the concept of sudden, unexpected jumps in asset prices.
 
These jumps reflect real-world market behavior, where prices can change abruptly due to unexpected events like economic announcements or market crashes. This makes the model far more realistic than its predecessors. In essence, while Black-Scholes assumes a smooth and predictable path for asset prices, Merton’s model acknowledges that prices can sometimes take sharp, unpredictable turns.
 
By combining continuous price changes with these sudden jumps, Merton’s Jump Diffusion Model provides a nuanced and practical approach to understanding and valuing options. It aligns more closely with how markets actually behave, capturing the impact of both steady trends and abrupt shocks. 

METHODOLOGY

The main point in Merton’s Jump Diffusion model is that the market does not follow a consistent variance log-normal distribution so neither should the valuation of options.
  • The model incorporates both continuous diffusion processes which are represented by gradual, continuous changes in the asset price and jump processes which represent sudden and discontinuous changes.
     
Dividends are also considered and reduce the value of the option. 
  • Dividends reduce the value of an option because the option owner doesn’t own the right to dividends until the option is exercised.They reduce the value of the underlying asset since they represent a cash outflow to the shareholder.

CALCULATIONS

ASSUMPTIONS

In the simplest form of the Merton's Jump Diffusion model these assumptions are to be followed:
  • Asset prices evolve continuously over time, following a stochastic process.
  • The underlying asset's price follows geometric Brownian motion with the addition of jump components. These jumps represent sudden, discontinuous changes in the asset's price, which can occur due to unexpected events or news.
  • Jump sizes and jump times are independent and identically distributed random variables.
  • Volatility (σ) and the risk-free interest rate (r) are constant over the option's lifetime.
  • Transaction costs or taxes are not included.
  • Markets are efficient in that asset prices reflect all available information.
  • There are no arbitrage opportunities in that it is not possible to make riskless profits by trading securities.

MERTON JUMP DIFFUSION MODEL SOLUTION

The calculation of the Merton Jump Diffusion model includes multiple complex computational steps involving differential equations, stochastic calculus, and a general understanding of probability theory; furthermore, performing calculations by hand is very strenuous and prone to error when done on a large scale, time-sensitive analysis. For this reason, we will show you how to calculate it using python, then break down each step of the process so you can better understand how the model works programmatically.
  • Upon discussing the addition of Jump Diffusion into our model, it’s worth mentioning the Levy Process which is a stochastic process characterized by independent and stationary increments.
    • The two most popular Levy processes include the Geometric Brownian Motion (without jumps) and Poisson processes (with jumps) which are both used in this model. 
    • The Geometric Brownian motion is continuous while the Levy process is discontinuous. 
       
For the purposes of this demonstration, we won’t go too far into detail of how it works as it involves conditional probability and stochastic calculus. 

PYTHON IMPLEMENTATION

Import Libraries
Code Snippet Display 

import numpy as np
from scipy.special import erf
  • As mentioned before, numpy is used for handling arrays and mathematical operations.
  • scipy.special.erf is a function from the scipy library that computes the error function, which is used in the calculation of the standard normal cumulative distribution function shown below.
Definition of Inverse of Standard Normal Cumulative Distribution Function
Code Snippet Display 

def Nfcn(x):
    return 0.5 * (1.0 + erf(x / np.sqrt(2)))
  • This function defines the inverse of the standard normal cumulative distribution function, denoted as 𝑁(𝑥) in the context of the script. It computes the probability that a standard normal random variable is less than or equal to x.
Main Function to Calculate Merton's Jump Diffusion Model Option Prices
Code Snippet Display 

def calcMJDOptionPrice(cp, S, K, T, sigma, r, q, lmbda, a, b, n):
    # Meshgrid for strike price and time to maturity
    K, T = np.meshgrid(K, T)
    u, v = K.shape
    # Repeat arrays to match dimensions
    K = np.repeat(K[:, :, np.newaxis], n, axis=2)
    T = np.repeat(T[:, :, np.newaxis], n, axis=2)
    sigma = np.repeat(sigma[:, np.newaxis, np.newaxis], v, axis=1)
    sigma = np.repeat(sigma[:, :, :, np.newaxis], n, axis=3)
    S = np.repeat(S[:, np.newaxis, np.newaxis], v, axis=1)
    S = np.repeat(S[:, :, :, np.newaxis], n, axis=3)
    # Generate sequence of event counts
    n_values = np.arange(n)
    n_values = np.repeat(n_values[np.newaxis, np.newaxis, :], u, axis=0)
    n_values = np.repeat(n_values[:, :, :, np.newaxis], v, axis=1)
    # Compute factorial of event counts
    factn = np.math.factorial(n_values)
    # Calculate intermediate variables
    m = a + 0.5 * b**2
    lambda_prime = lmbda * np.exp(m)
    r_n = r - lmbda * (np.exp(m) - 1) + n_values * (m) / T
    sigma_n = np.sqrt(sigma**2 + (n_values * b**2) / T)
    # Define functions for call and put prices
    def dfcn(z, sigma, r):
        return (1.0 / (sigma * np.sqrt(T))) * (np.log(S / K) + (r - q + z * 0.5 * (sigma**2)) * T)
    def callfcn(sigma, r):
        return ((1.0 / factn) * np.exp(-lambda_prime * T) * (lambda_prime * T)**n_values *
                (np.exp(-q * T) * S * Nfcn(dfcn(1, sigma, r)) - K * np.exp(-r * T) * Nfcn(dfcn(-1, sigma, r))))
    # Calculate option prices
    P = np.sum(callfcn(sigma_n, r_n), axis=2)
    if cp == -1:
        P = P - S * np.exp(-q * T[:, :, 0]) + K[:, :, 0] * np.exp(-r * T[:, :, 0])
    return P
  • Without getting into much detail of what each formula entails I will go over a brief description of this function and its input parameters. 
    • This function calculates option prices based on Merton's Jump Diffusion model. It takes several input parameters such as option type (call or put), current asset price (S), strike price (K), time to maturity (T), volatility of diffusion (sigma), risk-free rate (r), dividend yield (q), Poisson rate (lmbda), jump mean (a), jump standard deviation (b), and event count (n).
    • The function first creates a meshgrid for strike price (K) and time to maturity (T).
    • It then repeats arrays to match dimensions for vectorized calculations.
    • Intermediate variables such as m, lambda_prime, r_n, and sigma_n are computed.
    • Functions dfcn and callfcn are defined to calculate call and put option prices based on the Merton model.
    • Finally, option prices are calculated and returned as a NumPy array (P).
       
Example Usage
Code Snippet Display 

# Example input parameters
cp = 1  # 1 for call, -1 for put
S = np.array([...])  # current asset price
K = np.array([...])  # strike price
T = np.array([...])  # time to maturity in years
sigma = np.array([...])  # volatility of diffusion
r = 0.03  # risk-free rate
q = 0  # dividend yield
lmbda = 0.01  # Poisson rate
a = -0.2  # jump mean
b = 0.5  # jump standard deviation
n = 50  # event count

# Calculate option prices
P = calcMJDOptionPrice(cp, S, K, T, sigma, r, q, lmbda, a, b, n)
  • This part demonstrates how to use the calcMJDOptionPrice function with example input parameters to calculate option prices based on Merton's Jump Diffusion model.
  • You need to replace the ellipses (...) with your actual data arrays for S, K, T, and sigma.
  • ie. ([100, 105, 110, 115, 120]) 
Full Code
Click the button below to view the combined code.
Dropdown Button with Code Snippet 

import numpy as np
from scipy.special import erf

# Define inverse of standard normal cumulative distribution function
def Nfcn(x):
    return 0.5 * (1.0 + erf(x / np.sqrt(2)))

# Main function to calculate Merton's Jump Diffusion model option prices
def calcMJDOptionPrice(cp, S, K, T, sigma, r, q, lmbda, a, b, n):
    K, T = np.meshgrid(K, T)
    u, v = K.shape
    K = np.repeat(K[:, :, np.newaxis], n, axis=2)
    T = np.repeat(T[:, :, np.newaxis], n, axis=2)
    sigma = np.repeat(sigma[:, np.newaxis, np.newaxis], v, axis=1)
    sigma = np.repeat(sigma[:, :, :, np.newaxis], n, axis=3)
    S = np.repeat(S[:, np.newaxis, np.newaxis], v, axis=1)
    S = np.repeat(S[:, :, :, np.newaxis], n, axis=3)
    n_values = np.arange(n)
    n_values = np.repeat(n_values[np.newaxis, np.newaxis, :], u, axis=0)
    n_values = np.repeat(n_values[:, :, :, np.newaxis], v, axis=1)
    factn = np.math.factorial(n_values)
    m = a + 0.5 * b**2
    lambda_prime = lmbda * np.exp(m)
    r_n = r - lmbda * (np.exp(m) - 1) + n_values * (m) / T
    sigma_n = np.sqrt(sigma**2 + (n_values * b**2) / T)

    def dfcn(z, sigma, r):
        return (1.0 / (sigma * np.sqrt(T))) * (np.log(S / K) + (r - q + z * 0.5 * (sigma**2)) * T)

    def callfcn(sigma, r):
        return ((1.0 / factn) * np.exp(-lambda_prime * T) * (lambda_prime * T)**n_values *
                (np.exp(-q * T) * S * Nfcn(dfcn(1, sigma, r)) - K * np.exp(-r * T) * Nfcn(dfcn(-1, sigma, r))))

    P = np.sum(callfcn(sigma_n, r_n), axis=2)
    if cp == -1:
        P = P - S * np.exp(-q * T[:, :, 0]) + K[:, :, 0] * np.exp(-r * T[:, :, 0])
    return P

# Example usage:
# Define input parameters
cp = 1  # 1 for call, -1 for put
S = np.array([...])  # current asset price
K = np.array([...])  # strike price
T = np.array([...])  # time to maturity in years
sigma = np.array([...])  # volatility of diffusion
r = 0.03  # risk-free rate
q = 0  # dividend yield
lmbda = 0.01  # Poisson rate
a = -0.2  # jump mean
b = 0.5  # jump standard deviation
n = 50  # event count

# Calculate option prices
P = calcMJDOptionPrice(cp, S, K, T, sigma, r, q, lmbda, a, b, n)

PROS & CONS

PROS

CONS

Incorporation of Jumps: By considering sudden, discontinuous changes in asset prices, the model accounts for unexpected events or volatility spikes that may not be captured by traditional continuous diffusion models like Black-Scholes.

Data Requirements: Estimating parameters for jump processes requires historical data on jumps, which may not always be readily available or reliable.

Flexibility: The model allows for a more flexible representation of market behavior by incorporating both continuous diffusion processes and jump processes. This flexibility can better accommodate various market conditions and scenarios.

Sensitivity to Assumptions: The accuracy of the model's outputs can be influenced by the choice of parameters, the frequency of jumps assumed, and other model specifications, which may introduce uncertainties in its predictions.

Accuracy: Merton’s Jump Diffusion Model can provide more accurate pricing for options and other derivatives compared to models that assume continuous diffusion only.

Computational Intensity: The inclusion of jump processes can increase the computational intensity of the model, especially when simulating asset price paths or solving complex option pricing equations.

CONCLUSION

Merton’s Jump Diffusion Model takes financial modeling to the next level by combining smooth price movements with the possibility of sudden jumps. Unlike traditional models that assume prices change gradually, Merton’s approach acknowledges that markets can be unpredictable, with abrupt shifts driven by unexpected events.
 
This added layer of realism helps in pricing options more accurately, reflecting the true volatility and unpredictability of the market. While it does add some complexity to calculations and requires careful estimation of parameters, the benefits are significant. By capturing both steady trends and sharp market moves, Merton’s model provides a clearer picture of potential risks and rewards. Implementing this model in Python or other feasible languages can simplify the complex calculations involved, making it easier to apply in real-world scenarios.
 
In short, while it may be more intricate than traditional models, the insights it offers into market behavior make it well worth the effort. Thanks for diving into Merton’s Jump Diffusion Model with us—here’s to making more informed and effective financial decisions!

REFERENCES

At ProbabilityofProfit.com, we are dedicated to delivering accurate and trustworthy content to our readers. Our team meticulously researches each topic, ensuring that the information we provide is both comprehensive and reliable. We reference high-quality sources, including academic journals, industry reports, and market analysis, to support our content. Additionally, we draw upon original studies and data from respected publishers to provide a well-rounded perspective. 
 
Our commitment to accuracy means we constantly review and update our articles to reflect the latest developments and trends in options trading. We strive to present unbiased information, allowing our readers to make informed decisions based on solid evidence. Discover more about our rigorous standards and our dedication to excellence on our website.
Dropdown Button
Related Guides