Skip to main content
Donate to the Python Software Foundation or Purchase a PyCharm License to Benefit the PSF! Donate Now

Fractional Brownian motion realizations.

Project description

travis codecov pypi pyversions

  • Exact methods for simulating fractional Brownian motion (fBm) or fractional Gaussian noise (fGn) in python.
  • Approximate simulation of multifractional Brownian motion (mBm) or multifractional Gaussian noise (mGn).


The fbm package is available on PyPI and can be installed via pip:

pip install fbm

fractional Brownian motion

Fractional Brownian motion can be generated via either Hosking’s method, the Cholesky method, or the Davies-Harte method. All three methods are theoretically exact in generating a discretely sampled fBm/fGn.


from fbm import FBM

f = FBM(n=1024, hurst=0.75, length=1, method='daviesharte')
# or
f = FBM(1024, 0.75)

# Generate a fBm realization
fbm_sample = f.fbm()

# Generate a fGn realization
fgn_sample = f.fgn()

# Get the times associated with the fBm
t_values = f.times()

where n is the number of equispaced increments desired for a fBm with Hurst parameter hurst on the interval [0, length]. Method can be either 'hosking', 'cholesky', or 'daviesharte'. The fbm() method returns a length n+1 array of discrete values for the fBm (includes 0). The fgn() method returns a length n array of fBm increments, or fGn. The times() method returns a length n+1 array of times corresponding to the fBm realizations.

The n and hurst parameters are required. The length parameter defaults to 1 and method defaults to 'daviesharte'.

For simulating multiple realizations use the FBM class provided as above. Some intermediate values are cached for repeated simulation.

For one-off samples of fBm or fGn there are separate functions available:

from fbm import fbm, fgn, times

# Generate a fBm realization
fbm_sample = fbm(n=1024, hurst=0.75, length=1, method='daviesharte')

# Generate a fGn realization
fgn_sample = fgn(n=1024, hurst=0.75, length=1, method='daviesharte')

# Get the times associated with the fBm
t_values = times(n=1024, length=1)

For fastest performance use the Davies and Harte method. Note that the Davies and Harte method can fail if the Hurst parameter hurst is close to 1 and there are a small amount of increments n. If this occurs, a warning is printed to the console and it will fallback to using Hosking’s method to generate the realization. See page 412 of the following paper for a more detailed explanation:

  • Wood, Andrew TA, and Grace Chan. “Simulation of stationary Gaussian processes in [0, 1] d.” Journal of computational and graphical statistics 3, no. 4 (1994): 409-432.

Hosking’s method:

  • Hosking, Jonathan RM. “Modeling persistence in hydrological time series using fractional differencing.” Water resources research 20, no. 12 (1984): 1898-1908.

Cholesky method:

  • Asmussen, Søren. Stochastic simulation with a view towards stochastic processes. University of Aarhus. Centre for Mathematical Physics and Stochastics (MaPhySto)[MPS], 1998.

Davies Harte method:

  • Davies, Robert B., and D. S. Harte. “Tests for Hurst effect.” Biometrika 74, no. 1 (1987): 95-101.

multifractional Brownian motion

This package supports approximate generation of multifractional Brownian motion. The current method uses the Riemann–Liouville fractional integral representation of mBm.


import math
from fbm import MBM

# Example Hurst function with respect to time.
def h(t):
    return 0.25 * math.sin(20*t) + 0.5

m = MBM(n=1024, hurst=h, length=1, method='riemannliouville')
# or
m = MBM(1024, h)

# Generate a mBm realization
mbm_sample = m.mbm()

# Generate a mGn realization
mgn_sample = m.mgn()

# Get the times associated with the mBm
t_values = m.times()

The hurst argument here should be a callable that accepts one argument and returns a float in (0, 1).

For one-off samples of mBm or mGn there are separate functions available:

from fbm import mbm, mgn, times

# Define a hurst function
def h(t):
    return 0.75 - 0.5 * t

# Generate a mbm realization
mbm_sample = mbm(n=1024, hurst=h, length=1, method='riemannliouville')

# Generate a fGn realization
mgn_sample = mgn(n=1024, hurst=h, length=1, method='riemannliouville')

# Get the times associated with the mBm
t_values = times(n=1024, length=1)

Riemann-Liouville representation method:

Approximate method originally proposed for fBm in

  • Rambaldi, Sandro, and Ombretta Pinazza. “An accurate fractional Brownian motion generator.” Physica A: Statistical Mechanics and its Applications 208, no. 1 (1994): 21-30.

Adapted to approximate mBm in

  • Muniandy, S. V., and S. C. Lim. “Modeling of locally self-similar processes using multifractional Brownian motion of Riemann-Liouville type.” Physical Review E 63, no. 4 (2001): 046104.

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Filename, size & hash SHA256 hash help File type Python version Upload date
fbm-0.3.0-py2.py3-none-any.whl (9.4 kB) Copy SHA256 hash SHA256 Wheel py2.py3
fbm-0.3.0-py3-none-any.whl (9.4 kB) Copy SHA256 hash SHA256 Wheel py3
fbm-0.3.0.tar.gz (9.5 kB) Copy SHA256 hash SHA256 Source None

Supported by

Elastic Elastic Search Pingdom Pingdom Monitoring Google Google BigQuery Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN SignalFx SignalFx Supporter DigiCert DigiCert EV certificate StatusPage StatusPage Status page