Euler–Maruyama method

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search

In Itô calculus, the Euler–Maruyama method (also called the Euler method) is a method for the approximate numerical solution of a stochastic differential equation (SDE). It is a simple generalization of the Euler method for ordinary differential equations to stochastic differential equations. It is named after Leonhard Euler and Gisiro Maruyama. Unfortunately, the same generalization cannot be done for any arbitrary deterministic method [1].

Consider the stochastic differential equation (see Itô calculus)

with initial condition X0 = x0, where Wt stands for the Wiener process, and suppose that we wish to solve this SDE on some interval of time [0, T]. Then the Euler–Maruyama approximation to the true solution X is the Markov chain Y defined as follows:

  • partition the interval [0, T] into N equal subintervals of width :
  • set Y0 = x0;
  • recursively define Yn for 1 ≤ n ≤ N by
where

The random variables ΔWn are independent and identically distributed normal random variables with expected value zero and variance .

Example[edit]

Numerical simulation[edit]

Gene expression modelled as stochastic process

An area that has benefited significantly from SDE is biology or more precisely mathematical biology. Here the number of publications on the use of stochastic model grew, as most of the models are nonlinear, demanding numerical schemes.

The graphic depicts a stochastic differential equation being solved using the Euler Scheme. The deterministic counterpart is shown as well.

Computer implementation[edit]

The following Python code implements the Euler–Maruyama method and uses it to solve the Ornstein–Uhlenbeck process defined by

The random numbers for are generated using the numpy mathematics package.

 1 # -*- coding: utf-8 -*-
 2 import numpy as np
 3 import matplotlib.pyplot as plt
 4 
 5 num_sims = 5 ### display five runs
 6 
 7 t_init = 3
 8 t_end  = 7
 9 N      = 1000 ### Compute 1000 grid points
10 dt     = float(t_end - t_init) / N 
11 y_init = 0
12 
13 c_theta = 0.7
14 c_mu    = 1.5
15 c_sigma = 0.06
16 
17 def mu(y, t): 
18     """Implement the Ornstein–Uhlenbeck mu.""" ## = \theta (\mu-Y_t)
19     return c_theta * (c_mu - y)
20 
21 def sigma(y, t): 
22     """Implement the Ornstein–Uhlenbeck sigma.""" ## = \sigma
23     return c_sigma
24     
25 def dW(delta_t): 
26     """Sample a random number at each call."""
27     return np.random.normal(loc = 0.0, scale = np.sqrt(delta_t))
28 
29 ts    = np.arange(t_init, t_end, dt)
30 ys    = np.zeros(N)
31 
32 ys[0] = y_init
33 
34 for _ in range(num_sims):
35     for i in range(1, ts.size):
36         t = (i-1) * dt
37         y = ys[i-1]
38         ys[i] = y + mu(y, t) * dt + sigma(y, t) * dW(dt)
39     plt.plot(ts, ys)
40 
41 plt.show()

See also[edit]

References[edit]

  1. ^ Kloeden, P.E. & Platen, E. (1992). Numerical Solution of Stochastic Differential Equations. Springer, Berlin. ISBN 3-540-54062-8.