Metadata-Version: 1.1
Name: fbm
Version: 0.2.0
Summary: Fractional Brownian motion realizations.
Home-page: https://github.com/crflynn/fbm
Author: Christopher Flynn
Author-email: crf204@gmail.com
License: MIT
Description-Content-Type: UNKNOWN
Description: fbm
        ===
        
        |travis| |codecov| |pypi| |pyversions|
        
        .. |travis| image:: https://img.shields.io/travis/crflynn/fbm.svg
            :target: https://travis-ci.org/crflynn/fbm
        
        .. |codecov| image:: https://codecov.io/gh/crflynn/fbm/branch/master/graphs/badge.svg
            :target: https://codecov.io/gh/crflynn/fbm
        
        .. |pypi| image:: https://img.shields.io/pypi/v/fbm.svg
            :target: https://pypi.python.org/pypi/fbm
        
        .. |pyversions| image:: https://img.shields.io/pypi/pyversions/fbm.svg
            :target: https://pypi.python.org/pypi/fbm
        
        * 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).
        
        Installation
        ------------
        
        The fbm package is available on PyPI and can be installed via pip:
        
        .. code-block::
        
            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.
        
        Usage:
        
        .. code-block:: python
        
            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:
        
        .. code-block:: python
        
            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.
        
        Usage:
        
        .. code-block:: python
        
            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:
        
        .. code-block:: python
        
            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.
        
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: License :: OSI Approved :: MIT License
Classifier: Intended Audience :: Science/Research
Classifier: Topic :: Scientific/Engineering :: Mathematics
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: Implementation :: CPython
