├── .gitignore
├── LICENSE
├── README.rst
├── dev-requirements.txt
├── docs
    ├── Makefile
    ├── _build
    │   ├── doctrees
    │   │   ├── apidoc
    │   │   │   ├── modules.doctree
    │   │   │   ├── py_vollib.black.doctree
    │   │   │   ├── py_vollib.black.greeks.doctree
    │   │   │   ├── py_vollib.black_scholes.doctree
    │   │   │   ├── py_vollib.black_scholes.greeks.doctree
    │   │   │   ├── py_vollib.black_scholes_merton.doctree
    │   │   │   ├── py_vollib.black_scholes_merton.greeks.doctree
    │   │   │   ├── py_vollib.doctree
    │   │   │   ├── py_vollib.helpers.doctree
    │   │   │   ├── py_vollib.ref_python.black.doctree
    │   │   │   ├── py_vollib.ref_python.black.greeks.doctree
    │   │   │   ├── py_vollib.ref_python.black_scholes.doctree
    │   │   │   ├── py_vollib.ref_python.black_scholes.greeks.doctree
    │   │   │   ├── py_vollib.ref_python.black_scholes_merton.doctree
    │   │   │   ├── py_vollib.ref_python.black_scholes_merton.greeks.doctree
    │   │   │   └── py_vollib.ref_python.doctree
    │   │   ├── environment.pickle
    │   │   └── index.doctree
    │   └── html
    │   │   ├── .buildinfo
    │   │   ├── _modules
    │   │       ├── index.html
    │   │       ├── py_vollib
    │   │       │   ├── black.html
    │   │       │   ├── black
    │   │       │   │   ├── greeks
    │   │       │   │   │   ├── analytical.html
    │   │       │   │   │   └── numerical.html
    │   │       │   │   └── implied_volatility.html
    │   │       │   ├── black_scholes.html
    │   │       │   ├── black_scholes
    │   │       │   │   ├── greeks
    │   │       │   │   │   ├── analytical.html
    │   │       │   │   │   └── numerical.html
    │   │       │   │   └── implied_volatility.html
    │   │       │   ├── black_scholes_merton.html
    │   │       │   ├── black_scholes_merton
    │   │       │   │   ├── greeks
    │   │       │   │   │   ├── analytical.html
    │   │       │   │   │   └── numerical.html
    │   │       │   │   └── implied_volatility.html
    │   │       │   ├── helpers.html
    │   │       │   ├── helpers
    │   │       │   │   ├── distributions.html
    │   │       │   │   ├── doctest_helper.html
    │   │       │   │   ├── exceptions.html
    │   │       │   │   └── numerical_greeks.html
    │   │       │   └── ref_python
    │   │       │   │   ├── black.html
    │   │       │   │   ├── black
    │   │       │   │       ├── greeks
    │   │       │   │       │   ├── analytical.html
    │   │       │   │       │   └── numerical.html
    │   │       │   │       └── implied_volatility.html
    │   │       │   │   ├── black_scholes.html
    │   │       │   │   ├── black_scholes
    │   │       │   │       ├── greeks
    │   │       │   │       │   ├── analytical.html
    │   │       │   │       │   └── numerical.html
    │   │       │   │       └── implied_volatility.html
    │   │       │   │   ├── black_scholes_merton.html
    │   │       │   │   └── black_scholes_merton
    │   │       │   │       ├── greeks
    │   │       │   │           ├── analytical.html
    │   │       │   │           └── numerical.html
    │   │       │   │       └── implied_volatility.html
    │   │       └── scipy
    │   │       │   └── stats
    │   │       │       └── _distn_infrastructure.html
    │   │   ├── _sources
    │   │       ├── apidoc
    │   │       │   ├── modules.rst.txt
    │   │       │   ├── py_vollib.black.greeks.rst.txt
    │   │       │   ├── py_vollib.black.rst.txt
    │   │       │   ├── py_vollib.black_scholes.greeks.rst.txt
    │   │       │   ├── py_vollib.black_scholes.rst.txt
    │   │       │   ├── py_vollib.black_scholes_merton.greeks.rst.txt
    │   │       │   ├── py_vollib.black_scholes_merton.rst.txt
    │   │       │   ├── py_vollib.helpers.rst.txt
    │   │       │   ├── py_vollib.ref_python.black.greeks.rst.txt
    │   │       │   ├── py_vollib.ref_python.black.rst.txt
    │   │       │   ├── py_vollib.ref_python.black_scholes.greeks.rst.txt
    │   │       │   ├── py_vollib.ref_python.black_scholes.rst.txt
    │   │       │   ├── py_vollib.ref_python.black_scholes_merton.greeks.rst.txt
    │   │       │   ├── py_vollib.ref_python.black_scholes_merton.rst.txt
    │   │       │   ├── py_vollib.ref_python.rst.txt
    │   │       │   └── py_vollib.rst.txt
    │   │       ├── f
    │   │       │   └── modules.rst.txt
    │   │       └── index.rst.txt
    │   │   ├── _static
    │   │       ├── ajax-loader.gif
    │   │       ├── basic.css
    │   │       ├── comment-bright.png
    │   │       ├── comment-close.png
    │   │       ├── comment.png
    │   │       ├── css
    │   │       │   ├── badge_only.css
    │   │       │   └── theme.css
    │   │       ├── doctools.js
    │   │       ├── down-pressed.png
    │   │       ├── down.png
    │   │       ├── favicon.ico
    │   │       ├── file.png
    │   │       ├── fonts
    │   │       │   ├── Inconsolata-Bold.ttf
    │   │       │   ├── Inconsolata-Regular.ttf
    │   │       │   ├── Lato-Bold.ttf
    │   │       │   ├── Lato-Regular.ttf
    │   │       │   ├── RobotoSlab-Bold.ttf
    │   │       │   ├── RobotoSlab-Regular.ttf
    │   │       │   ├── fontawesome-webfont.eot
    │   │       │   ├── fontawesome-webfont.svg
    │   │       │   ├── fontawesome-webfont.ttf
    │   │       │   └── fontawesome-webfont.woff
    │   │       ├── jquery-3.1.0.js
    │   │       ├── jquery.js
    │   │       ├── js
    │   │       │   ├── modernizr.min.js
    │   │       │   └── theme.js
    │   │       ├── minus.png
    │   │       ├── plus.png
    │   │       ├── pygments.css
    │   │       ├── searchtools.js
    │   │       ├── underscore-1.3.1.js
    │   │       ├── underscore.js
    │   │       ├── up-pressed.png
    │   │       ├── up.png
    │   │       ├── vollib_60.png
    │   │       └── websupport.js
    │   │   ├── apidoc
    │   │       ├── modules.html
    │   │       ├── py_vollib.black.greeks.html
    │   │       ├── py_vollib.black.html
    │   │       ├── py_vollib.black_scholes.greeks.html
    │   │       ├── py_vollib.black_scholes.html
    │   │       ├── py_vollib.black_scholes_merton.greeks.html
    │   │       ├── py_vollib.black_scholes_merton.html
    │   │       ├── py_vollib.helpers.html
    │   │       ├── py_vollib.html
    │   │       ├── py_vollib.ref_python.black.greeks.html
    │   │       ├── py_vollib.ref_python.black.html
    │   │       ├── py_vollib.ref_python.black_scholes.greeks.html
    │   │       ├── py_vollib.ref_python.black_scholes.html
    │   │       ├── py_vollib.ref_python.black_scholes_merton.greeks.html
    │   │       ├── py_vollib.ref_python.black_scholes_merton.html
    │   │       └── py_vollib.ref_python.html
    │   │   ├── genindex.html
    │   │   ├── index.html
    │   │   ├── objects.inv
    │   │   ├── py-modindex.html
    │   │   ├── search.html
    │   │   └── searchindex.js
    ├── apidoc
    │   ├── modules.rst
    │   ├── py_vollib.black.greeks.rst
    │   ├── py_vollib.black.rst
    │   ├── py_vollib.black_scholes.greeks.rst
    │   ├── py_vollib.black_scholes.rst
    │   ├── py_vollib.black_scholes_merton.greeks.rst
    │   ├── py_vollib.black_scholes_merton.rst
    │   ├── py_vollib.helpers.rst
    │   ├── py_vollib.ref_python.black.greeks.rst
    │   ├── py_vollib.ref_python.black.rst
    │   ├── py_vollib.ref_python.black_scholes.greeks.rst
    │   ├── py_vollib.ref_python.black_scholes.rst
    │   ├── py_vollib.ref_python.black_scholes_merton.greeks.rst
    │   ├── py_vollib.ref_python.black_scholes_merton.rst
    │   ├── py_vollib.ref_python.rst
    │   └── py_vollib.rst
    ├── conf.py
    ├── favicon.ico
    ├── index.rst
    └── vollib_60.png
├── py_vollib
    ├── __init__.py
    ├── black
    │   ├── __init__.py
    │   ├── greeks
    │   │   ├── __init__.py
    │   │   ├── analytical.py
    │   │   └── numerical.py
    │   └── implied_volatility.py
    ├── black_scholes
    │   ├── __init__.py
    │   ├── greeks
    │   │   ├── __init__.py
    │   │   ├── analytical.py
    │   │   └── numerical.py
    │   └── implied_volatility.py
    ├── black_scholes_merton
    │   ├── __init__.py
    │   ├── greeks
    │   │   ├── __init__.py
    │   │   ├── analytical.py
    │   │   └── numerical.py
    │   └── implied_volatility.py
    ├── helpers
    │   ├── __init__.py
    │   ├── constants.py
    │   ├── distributions.py
    │   ├── doctest_helper.py
    │   ├── exceptions.py
    │   └── numerical_greeks.py
    └── ref_python
    │   ├── __init__.py
    │   ├── black
    │       ├── __init__.py
    │       ├── greeks
    │       │   ├── __init__.py
    │       │   ├── analytical.py
    │       │   └── numerical.py
    │       └── implied_volatility.py
    │   ├── black_scholes
    │       ├── __init__.py
    │       ├── greeks
    │       │   ├── __init__.py
    │       │   ├── analytical.py
    │       │   └── numerical.py
    │       └── implied_volatility.py
    │   └── black_scholes_merton
    │       ├── __init__.py
    │       ├── greeks
    │           ├── __init__.py
    │           ├── analytical.py
    │           └── numerical.py
    │       └── implied_volatility.py
├── setup.py
└── tests
    ├── __init__.py
    ├── test_all.py
    ├── test_black_scholes.py
    ├── test_black_scholes_greeks.py
    ├── test_black_scholes_merton.py
    ├── test_black_scholes_merton_greeks.py
    ├── test_data.json
    ├── test_ref_python
        ├── __init__.py
        ├── test_ref_python_black_scholes.py
        ├── test_ref_python_black_scholes_greeks.py
        ├── test_ref_python_black_scholes_merton.py
        └── test_ref_python_black_scholes_merton_greeks.py
    ├── test_utils.py
    └── test_vollib_vs_ref_python_values
        ├── ___init__.py
        ├── black
            ├── __init__.py
            ├── test_greeks.py
            ├── test_implied_volatility.py
            └── test_price.py
        ├── black_scholes
            ├── __init__.py
            ├── test_greeks.py
            ├── test_implied_volatility.py
            └── test_price.py
        └── black_scholes_merton
            ├── __init__.py
            ├── test_greeks.py
            ├── test_implied_volatility.py
            └── test_price.py


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.o
 2 | *.pyc
 3 | .python-version
 4 | .cache
 5 | __pycache__
 6 | 
 7 | build
 8 | dist
 9 | *.egg-info
10 | *.egg
11 | 
12 | *.sh
13 | *scratch*
14 | 
15 | # idea IDE
16 | .idea/
17 | 
18 | # OS Specific
19 | .DS_Store
20 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015, Gammon Capital LLC
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
  1 | About ``py_vollib``
  2 | ===================
  3 | 
  4 | ``py_vollib`` is a python library for calculating option prices, implied volatility and greeks.  At its core is
  5 | Peter Jäckel's source code for ``LetsBeRational``, an extremely fast and accurate algorithm for obtaining Black's
  6 | implied volatility from option prices.
  7 | 
  8 | Building on this solid foundation, ``py_vollib`` provides functions to calculate option prices, implied volatility and
  9 | greeks using Black, Black-Scholes, and Black-Scholes-Merton. ``py_vollib`` implements both analytical and numerical
 10 | greeks for each of the three pricing formulae.
 11 | 
 12 | Comparison with `vollib`
 13 | ------------------------
 14 | 
 15 | +-------------------------------------------------+-------------------------+----------------------------+
 16 | | Feature                                         |      ``py_vollib``      |        ``vollib``          |
 17 | +=================================================+=========================+============================+
 18 | | Python Version Compatibility                    |       2.7 and 3.x       |          2.7 only          |
 19 | +-------------------------------------------------+-------------------------+----------------------------+
 20 | | Source Language                                 |          Python         | C with Python SWIG Wrapper |
 21 | +-------------------------------------------------+-------------------------+----------------------------+
 22 | | Optional Dependencies                           |          Numba          |            None            |
 23 | +-------------------------------------------------+-------------------------+----------------------------+
 24 | | Core Dependency (automatically installed by pip)| ``py_lets_be_rational`` |   ``lets_be_rational``     |
 25 | +-------------------------------------------------+-------------------------+----------------------------+
 26 | 
 27 | Execution Speed
 28 | ---------------
 29 | Except for the source languages of ``py_lets_be_rational`` and ``lets_be_rational``, ``py_vollib``  and ``vollib``  are
 30 | almost identical. Each is orders of magnitude faster than traditional implied volatility calculation libraries, thanks
 31 | to the algorithms developed by Peter Jäckel.  However, ``py_vollib``, without Numba installed, is about an order of
 32 | magnitude slower than ``vollib``.  Numba helps to mitigate this speed gap considerably.
 33 | 
 34 | Numba Dependency
 35 | ----------------
 36 | 
 37 | Numba is an optional dependency of ``py_vollib`` .  Because Numba installation can be tricky and OS-dependent, we
 38 | decided to leave it up to each user to decide how and whether to install Numba.  If Numba is present, execution speed
 39 | will be faster. If not, the code will still run -- just slower.
 40 | 
 41 | Installing Numba
 42 | ----------------
 43 | 
 44 | ``py_lets_be_rational`` optionally depends on ``numba`` which in turn depends on ``llvm-lite``. ``llvm-lite`` wants LLVM 3.9
 45 | being installed. On Mac OSX, use the latest version of HomeBrew to install ``numba``'s dependencies as shown below::
 46 | 
 47 |     brew install llvm@3.9
 48 |     LLVM_CONFIG=/usr/local/opt/llvm@3.9/bin/llvm-config pip install llvmlite==0.16.0
 49 |     pip install numba==0.31.0
 50 | 
 51 | For other operating systems, please refer to the ``llvm-lite`` and ``numba`` documentation.
 52 | 
 53 | About the reference Python implementation
 54 | -----------------------------------------
 55 | 
 56 | ``py_vollib`` contains ``py_vollib.ref_python``, a pure python version of the functions in ``py_vollib.*``, except
 57 | without any dependency on ``lets_be_rational`` or ``py_lets_be_rational``.  It is provided purely as a reference
 58 | implementation for sanity checking. It is not recommended for serious use.
 59 | 
 60 | 
 61 | Dependencies
 62 | ------------
 63 | 
 64 | ``py_vollib`` is Python 2.7/Python 3.6 compatible.  Its core dependency is ``py_lets_be_rational`` package, pure
 65 | python implementation of Peter Jäckel's original C source code.
 66 | 
 67 | To install via pip, type the following::
 68 | 
 69 |     pip install py_vollib
 70 | 
 71 | Installing ``py_vollib`` via pip will automatically install the necessary dependencies,
 72 | except for pip, and Python.
 73 | 
 74 | Python, and pip must be installed prior to installing ``py_vollib``.
 75 | 
 76 | 
 77 | About "Let's be Rational"
 78 | -------------------------
 79 | 
 80 | `"Let's Be Rational" <http://www.pjaeckel.webspace.virginmedia.com/LetsBeRational.pdf>`_ is a paper by `Peter Jäckel <http://jaeckel.org>`_ showing *"how Black's volatility can be implied from option prices with as little as two iterations to maximum attainable precision on standard (64 bit floating point) hardware for all possible inputs."*
 81 | 
 82 | The paper is accompanied by the full C source code, which resides at `www.jaeckel.org/LetsBeRational.7z <www.jaeckel.org/LetsBeRational.7z>`_.
 83 | 
 84 | ::
 85 | 
 86 |     Copyright © 2013-2014 Peter Jäckel.
 87 | 
 88 |     Permission to use, copy, modify, and distribute this software is freely granted,
 89 |     provided that this notice is preserved.
 90 | 
 91 |     WARRANTY DISCLAIMER
 92 |     The Software is provided "as is" without warranty of any kind, either express or implied,
 93 |     including without limitation any implied warranties of condition, uninterrupted use,
 94 |     merchantability, fitness for a particular purpose, or non-infringement.
 95 | 
 96 | Links
 97 | -----
 98 | 
 99 |   * `Let's Be Rational <http://www.pjaeckel.webspace.virginmedia.com/LetsBeRational.pdf>`_
100 |   * `pip <https://pypi.python.org/pypi/pip>`_
101 |   * `Licence <http://vollib.org/license>`_
102 |   * `Vollib Home <http://vollib.org>`_
103 |   * `py_lets_be_rational <http://github.com/vollib/py_lets_be_rational>`_
104 |   * `lets_be_rational <http://github.com/vollib/lets_be_rational>`_
105 |   * `vollib <http://github.com/vollib/vollib>`_
106 | 
107 | Development
108 | -----------
109 | 
110 | Fork the GitHub repository. This will make it available under your username e.g. ``https://github.com/YOUR-USERNAME/py_vollib``.
111 | Clone that repo on your computer, change the code as you wish. Commit and push it, and create a pull request. That's all.
112 | 
113 | Generate documentation
114 | ++++++++++++++++++++++
115 | 
116 | ::
117 | 
118 |     cd docs
119 |     sphinx-apidoc -f -o apidoc ../py_vollib
120 |     make html
121 | 
122 | 


--------------------------------------------------------------------------------
/dev-requirements.txt:
--------------------------------------------------------------------------------
 1 | # for documentation
 2 | sphinx==1.5.5
 3 | sphinx_rtd_theme==0.2.4
 4 | recommonmark==0.4.0
 5 | 
 6 | # for testing
 7 | pytest==3.0.7
 8 | 
 9 | # for experiments
10 | matplotlib==2.0.0
11 | jupyter==1.0.0
12 | 


--------------------------------------------------------------------------------
/docs/Makefile:
--------------------------------------------------------------------------------
 1 | # Minimal makefile for Sphinx documentation
 2 | #
 3 | 
 4 | # You can set these variables from the command line.
 5 | SPHINXOPTS    =
 6 | SPHINXBUILD   = sphinx-build
 7 | SPHINXPROJ    = py_vollib
 8 | SOURCEDIR     = .
 9 | BUILDDIR      = _build
10 | 
11 | # Put it first so that "make" without argument is like "make help".
12 | help:
13 | 	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
14 | 
15 | .PHONY: help Makefile
16 | 
17 | # Catch-all target: route all unknown targets to Sphinx using the new
18 | # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
19 | %: Makefile
20 | 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/modules.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/modules.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.black.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.black.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.black.greeks.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.black.greeks.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.black_scholes.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.black_scholes.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.black_scholes.greeks.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.black_scholes.greeks.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.black_scholes_merton.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.black_scholes_merton.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.black_scholes_merton.greeks.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.black_scholes_merton.greeks.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.helpers.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.helpers.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.ref_python.black.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.ref_python.black.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.ref_python.black.greeks.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.ref_python.black.greeks.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.ref_python.black_scholes.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.ref_python.black_scholes.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.ref_python.black_scholes.greeks.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.ref_python.black_scholes.greeks.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.ref_python.black_scholes_merton.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.ref_python.black_scholes_merton.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.ref_python.black_scholes_merton.greeks.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.ref_python.black_scholes_merton.greeks.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/apidoc/py_vollib.ref_python.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/apidoc/py_vollib.ref_python.doctree


--------------------------------------------------------------------------------
/docs/_build/doctrees/environment.pickle:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/environment.pickle


--------------------------------------------------------------------------------
/docs/_build/doctrees/index.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/doctrees/index.doctree


--------------------------------------------------------------------------------
/docs/_build/html/.buildinfo:
--------------------------------------------------------------------------------
1 | # Sphinx build info version 1
2 | # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
3 | config: 8b01e0601199b801ddacfa00f8f8059f
4 | tags: 645f666f9bcd5a90fca523b33c5a78b7
5 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/modules.rst.txt:
--------------------------------------------------------------------------------
1 | py_vollib
2 | =========
3 | 
4 | .. toctree::
5 |    :maxdepth: 4
6 | 
7 |    py_vollib
8 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.black.greeks.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black\.greeks package
 2 | =================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.black\.greeks\.analytical module
 8 | --------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.black.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.black\.greeks\.numerical module
16 | -------------------------------------------
17 | 
18 | .. automodule:: py_vollib.black.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.black.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.black.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black package
 2 | =========================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.black.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.black\.implied\_volatility module
15 | ---------------------------------------------
16 | 
17 | .. automodule:: py_vollib.black.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.black
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.black_scholes.greeks.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black\_scholes\.greeks package
 2 | ==========================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.black\_scholes\.greeks\.analytical module
 8 | -----------------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.black_scholes.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.black\_scholes\.greeks\.numerical module
16 | ----------------------------------------------------
17 | 
18 | .. automodule:: py_vollib.black_scholes.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.black_scholes.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.black_scholes.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black\_scholes package
 2 | ==================================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.black_scholes.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.black\_scholes\.implied\_volatility module
15 | ------------------------------------------------------
16 | 
17 | .. automodule:: py_vollib.black_scholes.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.black_scholes
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.black_scholes_merton.greeks.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black\_scholes\_merton\.greeks package
 2 | ==================================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.black\_scholes\_merton\.greeks\.analytical module
 8 | -------------------------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.black_scholes_merton.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.black\_scholes\_merton\.greeks\.numerical module
16 | ------------------------------------------------------------
17 | 
18 | .. automodule:: py_vollib.black_scholes_merton.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.black_scholes_merton.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.black_scholes_merton.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black\_scholes\_merton package
 2 | ==========================================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.black_scholes_merton.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.black\_scholes\_merton\.implied\_volatility module
15 | --------------------------------------------------------------
16 | 
17 | .. automodule:: py_vollib.black_scholes_merton.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.black_scholes_merton
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.helpers.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.helpers package
 2 | ===========================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.helpers\.constants module
 8 | -------------------------------------
 9 | 
10 | .. automodule:: py_vollib.helpers.constants
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.helpers\.distributions module
16 | -----------------------------------------
17 | 
18 | .. automodule:: py_vollib.helpers.distributions
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | py\_vollib\.helpers\.doctest\_helper module
24 | -------------------------------------------
25 | 
26 | .. automodule:: py_vollib.helpers.doctest_helper
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 
31 | py\_vollib\.helpers\.exceptions module
32 | --------------------------------------
33 | 
34 | .. automodule:: py_vollib.helpers.exceptions
35 |     :members:
36 |     :undoc-members:
37 |     :show-inheritance:
38 | 
39 | py\_vollib\.helpers\.numerical\_greeks module
40 | ---------------------------------------------
41 | 
42 | .. automodule:: py_vollib.helpers.numerical_greeks
43 |     :members:
44 |     :undoc-members:
45 |     :show-inheritance:
46 | 
47 | 
48 | Module contents
49 | ---------------
50 | 
51 | .. automodule:: py_vollib.helpers
52 |     :members:
53 |     :undoc-members:
54 |     :show-inheritance:
55 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.ref_python.black.greeks.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black\.greeks package
 2 | ==============================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.ref\_python\.black\.greeks\.analytical module
 8 | ---------------------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.ref_python.black.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.ref\_python\.black\.greeks\.numerical module
16 | --------------------------------------------------------
17 | 
18 | .. automodule:: py_vollib.ref_python.black.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.ref_python.black.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.ref_python.black.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black package
 2 | ======================================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.ref_python.black.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.ref\_python\.black\.implied\_volatility module
15 | ----------------------------------------------------------
16 | 
17 | .. automodule:: py_vollib.ref_python.black.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.ref_python.black
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.ref_python.black_scholes.greeks.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black\_scholes\.greeks package
 2 | =======================================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.ref\_python\.black\_scholes\.greeks\.analytical module
 8 | ------------------------------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.ref_python.black_scholes.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.ref\_python\.black\_scholes\.greeks\.numerical module
16 | -----------------------------------------------------------------
17 | 
18 | .. automodule:: py_vollib.ref_python.black_scholes.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.ref_python.black_scholes.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.ref_python.black_scholes.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black\_scholes package
 2 | ===============================================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.ref_python.black_scholes.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.ref\_python\.black\_scholes\.implied\_volatility module
15 | -------------------------------------------------------------------
16 | 
17 | .. automodule:: py_vollib.ref_python.black_scholes.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.ref_python.black_scholes
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.ref_python.black_scholes_merton.greeks.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black\_scholes\_merton\.greeks package
 2 | ===============================================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.ref\_python\.black\_scholes\_merton\.greeks\.analytical module
 8 | --------------------------------------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.ref_python.black_scholes_merton.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.ref\_python\.black\_scholes\_merton\.greeks\.numerical module
16 | -------------------------------------------------------------------------
17 | 
18 | .. automodule:: py_vollib.ref_python.black_scholes_merton.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.ref_python.black_scholes_merton.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.ref_python.black_scholes_merton.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black\_scholes\_merton package
 2 | =======================================================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.ref_python.black_scholes_merton.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.ref\_python\.black\_scholes\_merton\.implied\_volatility module
15 | ---------------------------------------------------------------------------
16 | 
17 | .. automodule:: py_vollib.ref_python.black_scholes_merton.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.ref_python.black_scholes_merton
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.ref_python.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python package
 2 | ===============================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.ref_python.black
10 |     py_vollib.ref_python.black_scholes
11 |     py_vollib.ref_python.black_scholes_merton
12 | 
13 | Module contents
14 | ---------------
15 | 
16 | .. automodule:: py_vollib.ref_python
17 |     :members:
18 |     :undoc-members:
19 |     :show-inheritance:
20 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/apidoc/py_vollib.rst.txt:
--------------------------------------------------------------------------------
 1 | py\_vollib package
 2 | ==================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.black
10 |     py_vollib.black_scholes
11 |     py_vollib.black_scholes_merton
12 |     py_vollib.helpers
13 |     py_vollib.ref_python
14 | 
15 | Module contents
16 | ---------------
17 | 
18 | .. automodule:: py_vollib
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/f/modules.rst.txt:
--------------------------------------------------------------------------------
1 | apidoc
2 | ======
3 | 
4 | .. toctree::
5 |    :maxdepth: 4
6 | 
7 | 


--------------------------------------------------------------------------------
/docs/_build/html/_sources/index.rst.txt:
--------------------------------------------------------------------------------
 1 | .. vollib documentation master file, created by
 2 |    sphinx-quickstart on Wed Apr  1 19:21:03 2015.
 3 |    You can adapt this file completely to your liking, but it should at least
 4 |    contain the root `toctree` directive.
 5 | 
 6 | 
 7 | .. include:: ../README.rst
 8 | 
 9 | 
10 | Contents:
11 | =========
12 | .. toctree::
13 |    :caption: Table of Contents
14 |    :name: mastertoc
15 | 
16 | 
17 | .. toctree::
18 |    :maxdepth: 1
19 | 
20 | .. toctree::
21 |    :titlesonly:
22 | 
23 |       py_vollib modules <apidoc/modules.rst>
24 | 
25 | 
26 | Indices and tables
27 | ==================
28 | 
29 | * :ref:`genindex`
30 | * :ref:`modindex`
31 | * :ref:`search`
32 | 
33 | 


--------------------------------------------------------------------------------
/docs/_build/html/_static/ajax-loader.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/ajax-loader.gif


--------------------------------------------------------------------------------
/docs/_build/html/_static/comment-bright.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/comment-bright.png


--------------------------------------------------------------------------------
/docs/_build/html/_static/comment-close.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/comment-close.png


--------------------------------------------------------------------------------
/docs/_build/html/_static/comment.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/comment.png


--------------------------------------------------------------------------------
/docs/_build/html/_static/css/badge_only.css:
--------------------------------------------------------------------------------
1 | .fa:before{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:before,.clearfix:after{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-weight:normal;font-style:normal;src:url("../font/fontawesome_webfont.eot");src:url("../font/fontawesome_webfont.eot?#iefix") format("embedded-opentype"),url("../font/fontawesome_webfont.woff") format("woff"),url("../font/fontawesome_webfont.ttf") format("truetype"),url("../font/fontawesome_webfont.svg#FontAwesome") format("svg")}.fa:before{display:inline-block;font-family:FontAwesome;font-style:normal;font-weight:normal;line-height:1;text-decoration:inherit}a .fa{display:inline-block;text-decoration:inherit}li .fa{display:inline-block}li .fa-large:before,li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-0.8em}ul.fas li .fa{width:0.8em}ul.fas li .fa-large:before,ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before{content:""}.icon-book:before{content:""}.fa-caret-down:before{content:""}.icon-caret-down:before{content:""}.fa-caret-up:before{content:""}.icon-caret-up:before{content:""}.fa-caret-left:before{content:""}.icon-caret-left:before{content:""}.fa-caret-right:before{content:""}.icon-caret-right:before{content:""}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;border-top:solid 10px #343131;font-family:"Lato","proxima-nova","Helvetica Neue",Arial,sans-serif;z-index:400}.rst-versions a{color:#2980B9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27AE60;*zoom:1}.rst-versions .rst-current-version:before,.rst-versions .rst-current-version:after{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book{float:left}.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#E74C3C;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#F1C40F;color:#000}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:gray;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:solid 1px #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px}.rst-versions.rst-badge .icon-book{float:none}.rst-versions.rst-badge .fa-book{float:none}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book{float:left}.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge .rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width: 768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}
2 | /*# sourceMappingURL=badge_only.css.map */
3 | 


--------------------------------------------------------------------------------
/docs/_build/html/_static/down-pressed.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/down-pressed.png


--------------------------------------------------------------------------------
/docs/_build/html/_static/down.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/down.png


--------------------------------------------------------------------------------
/docs/_build/html/_static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/favicon.ico


--------------------------------------------------------------------------------
/docs/_build/html/_static/file.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/file.png


--------------------------------------------------------------------------------
/docs/_build/html/_static/fonts/Inconsolata-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/fonts/Inconsolata-Bold.ttf


--------------------------------------------------------------------------------
/docs/_build/html/_static/fonts/Inconsolata-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/fonts/Inconsolata-Regular.ttf


--------------------------------------------------------------------------------
/docs/_build/html/_static/fonts/Lato-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/fonts/Lato-Bold.ttf


--------------------------------------------------------------------------------
/docs/_build/html/_static/fonts/Lato-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/fonts/Lato-Regular.ttf


--------------------------------------------------------------------------------
/docs/_build/html/_static/fonts/RobotoSlab-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/fonts/RobotoSlab-Bold.ttf


--------------------------------------------------------------------------------
/docs/_build/html/_static/fonts/RobotoSlab-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/fonts/RobotoSlab-Regular.ttf


--------------------------------------------------------------------------------
/docs/_build/html/_static/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/docs/_build/html/_static/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/docs/_build/html/_static/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/docs/_build/html/_static/js/theme.js:
--------------------------------------------------------------------------------
  1 | require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"sphinx-rtd-theme":[function(require,module,exports){
  2 | var jQuery = (typeof(window) != 'undefined') ? window.jQuery : require('jquery');
  3 | 
  4 | // Sphinx theme nav state
  5 | function ThemeNav () {
  6 | 
  7 |     var nav = {
  8 |         navBar: null,
  9 |         win: null,
 10 |         winScroll: false,
 11 |         winResize: false,
 12 |         linkScroll: false,
 13 |         winPosition: 0,
 14 |         winHeight: null,
 15 |         docHeight: null,
 16 |         isRunning: false
 17 |     };
 18 | 
 19 |     nav.enable = function () {
 20 |         var self = this;
 21 | 
 22 |         if (!self.isRunning) {
 23 |             self.isRunning = true;
 24 |             jQuery(function ($) {
 25 |                 self.init($);
 26 | 
 27 |                 self.reset();
 28 |                 self.win.on('hashchange', self.reset);
 29 | 
 30 |                 // Set scroll monitor
 31 |                 self.win.on('scroll', function () {
 32 |                     if (!self.linkScroll) {
 33 |                         self.winScroll = true;
 34 |                     }
 35 |                 });
 36 |                 setInterval(function () { if (self.winScroll) self.onScroll(); }, 25);
 37 | 
 38 |                 // Set resize monitor
 39 |                 self.win.on('resize', function () {
 40 |                     self.winResize = true;
 41 |                 });
 42 |                 setInterval(function () { if (self.winResize) self.onResize(); }, 25);
 43 |                 self.onResize();
 44 |             });
 45 |         };
 46 |     };
 47 | 
 48 |     nav.init = function ($) {
 49 |         var doc = $(document),
 50 |             self = this;
 51 | 
 52 |         this.navBar = $('div.wy-side-scroll:first');
 53 |         this.win = $(window);
 54 | 
 55 |         // Set up javascript UX bits
 56 |         $(document)
 57 |             // Shift nav in mobile when clicking the menu.
 58 |             .on('click', "[data-toggle='wy-nav-top']", function() {
 59 |                 $("[data-toggle='wy-nav-shift']").toggleClass("shift");
 60 |                 $("[data-toggle='rst-versions']").toggleClass("shift");
 61 |             })
 62 | 
 63 |             // Nav menu link click operations
 64 |             .on('click', ".wy-menu-vertical .current ul li a", function() {
 65 |                 var target = $(this);
 66 |                 // Close menu when you click a link.
 67 |                 $("[data-toggle='wy-nav-shift']").removeClass("shift");
 68 |                 $("[data-toggle='rst-versions']").toggleClass("shift");
 69 |                 // Handle dynamic display of l3 and l4 nav lists
 70 |                 self.toggleCurrent(target);
 71 |                 self.hashChange();
 72 |             })
 73 |             .on('click', "[data-toggle='rst-current-version']", function() {
 74 |                 $("[data-toggle='rst-versions']").toggleClass("shift-up");
 75 |             })
 76 | 
 77 |         // Make tables responsive
 78 |         $("table.docutils:not(.field-list)")
 79 |             .wrap("<div class='wy-table-responsive'></div>");
 80 | 
 81 |         // Add expand links to all parents of nested ul
 82 |         $('.wy-menu-vertical ul').not('.simple').siblings('a').each(function () {
 83 |             var link = $(this);
 84 |                 expand = $('<span class="toctree-expand"></span>');
 85 |             expand.on('click', function (ev) {
 86 |                 self.toggleCurrent(link);
 87 |                 ev.stopPropagation();
 88 |                 return false;
 89 |             });
 90 |             link.prepend(expand);
 91 |         });
 92 |     };
 93 | 
 94 |     nav.reset = function () {
 95 |         // Get anchor from URL and open up nested nav
 96 |         var anchor = encodeURI(window.location.hash);
 97 |         if (anchor) {
 98 |             try {
 99 |                 var link = $('.wy-menu-vertical')
100 |                     .find('[href="' + anchor + '"]');
101 |                 // If we didn't find a link, it may be because we clicked on
102 |                 // something that is not in the sidebar (eg: when using
103 |                 // sphinxcontrib.httpdomain it generates headerlinks but those
104 |                 // aren't picked up and placed in the toctree). So let's find
105 |                 // the closest header in the document and try with that one.
106 |                 if (link.length === 0) {
107 |                   var doc_link = $('.document a[href="' + anchor + '"]');
108 |                   var closest_section = doc_link.closest('div.section');
109 |                   // Try again with the closest section entry.
110 |                   link = $('.wy-menu-vertical')
111 |                     .find('[href="#' + closest_section.attr("id") + '"]');
112 | 
113 |                 }
114 |                 $('.wy-menu-vertical li.toctree-l1 li.current')
115 |                     .removeClass('current');
116 |                 link.closest('li.toctree-l2').addClass('current');
117 |                 link.closest('li.toctree-l3').addClass('current');
118 |                 link.closest('li.toctree-l4').addClass('current');
119 |             }
120 |             catch (err) {
121 |                 console.log("Error expanding nav for anchor", err);
122 |             }
123 |         }
124 |     };
125 | 
126 |     nav.onScroll = function () {
127 |         this.winScroll = false;
128 |         var newWinPosition = this.win.scrollTop(),
129 |             winBottom = newWinPosition + this.winHeight,
130 |             navPosition = this.navBar.scrollTop(),
131 |             newNavPosition = navPosition + (newWinPosition - this.winPosition);
132 |         if (newWinPosition < 0 || winBottom > this.docHeight) {
133 |             return;
134 |         }
135 |         this.navBar.scrollTop(newNavPosition);
136 |         this.winPosition = newWinPosition;
137 |     };
138 | 
139 |     nav.onResize = function () {
140 |         this.winResize = false;
141 |         this.winHeight = this.win.height();
142 |         this.docHeight = $(document).height();
143 |     };
144 | 
145 |     nav.hashChange = function () {
146 |         this.linkScroll = true;
147 |         this.win.one('hashchange', function () {
148 |             this.linkScroll = false;
149 |         });
150 |     };
151 | 
152 |     nav.toggleCurrent = function (elem) {
153 |         var parent_li = elem.closest('li');
154 |         parent_li.siblings('li.current').removeClass('current');
155 |         parent_li.siblings().find('li.current').removeClass('current');
156 |         parent_li.find('> ul li.current').removeClass('current');
157 |         parent_li.toggleClass('current');
158 |     }
159 | 
160 |     return nav;
161 | };
162 | 
163 | module.exports.ThemeNav = ThemeNav();
164 | 
165 | if (typeof(window) != 'undefined') {
166 |     window.SphinxRtdTheme = { StickyNav: module.exports.ThemeNav };
167 | }
168 | 
169 | },{"jquery":"jquery"}]},{},["sphinx-rtd-theme"]);
170 | 


--------------------------------------------------------------------------------
/docs/_build/html/_static/minus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/minus.png


--------------------------------------------------------------------------------
/docs/_build/html/_static/plus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/plus.png


--------------------------------------------------------------------------------
/docs/_build/html/_static/pygments.css:
--------------------------------------------------------------------------------
 1 | .highlight .hll { background-color: #ffffcc }
 2 | .highlight  { background: #eeffcc; }
 3 | .highlight .c { color: #408090; font-style: italic } /* Comment */
 4 | .highlight .err { border: 1px solid #FF0000 } /* Error */
 5 | .highlight .k { color: #007020; font-weight: bold } /* Keyword */
 6 | .highlight .o { color: #666666 } /* Operator */
 7 | .highlight .ch { color: #408090; font-style: italic } /* Comment.Hashbang */
 8 | .highlight .cm { color: #408090; font-style: italic } /* Comment.Multiline */
 9 | .highlight .cp { color: #007020 } /* Comment.Preproc */
10 | .highlight .cpf { color: #408090; font-style: italic } /* Comment.PreprocFile */
11 | .highlight .c1 { color: #408090; font-style: italic } /* Comment.Single */
12 | .highlight .cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */
13 | .highlight .gd { color: #A00000 } /* Generic.Deleted */
14 | .highlight .ge { font-style: italic } /* Generic.Emph */
15 | .highlight .gr { color: #FF0000 } /* Generic.Error */
16 | .highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
17 | .highlight .gi { color: #00A000 } /* Generic.Inserted */
18 | .highlight .go { color: #333333 } /* Generic.Output */
19 | .highlight .gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
20 | .highlight .gs { font-weight: bold } /* Generic.Strong */
21 | .highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
22 | .highlight .gt { color: #0044DD } /* Generic.Traceback */
23 | .highlight .kc { color: #007020; font-weight: bold } /* Keyword.Constant */
24 | .highlight .kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
25 | .highlight .kn { color: #007020; font-weight: bold } /* Keyword.Namespace */
26 | .highlight .kp { color: #007020 } /* Keyword.Pseudo */
27 | .highlight .kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
28 | .highlight .kt { color: #902000 } /* Keyword.Type */
29 | .highlight .m { color: #208050 } /* Literal.Number */
30 | .highlight .s { color: #4070a0 } /* Literal.String */
31 | .highlight .na { color: #4070a0 } /* Name.Attribute */
32 | .highlight .nb { color: #007020 } /* Name.Builtin */
33 | .highlight .nc { color: #0e84b5; font-weight: bold } /* Name.Class */
34 | .highlight .no { color: #60add5 } /* Name.Constant */
35 | .highlight .nd { color: #555555; font-weight: bold } /* Name.Decorator */
36 | .highlight .ni { color: #d55537; font-weight: bold } /* Name.Entity */
37 | .highlight .ne { color: #007020 } /* Name.Exception */
38 | .highlight .nf { color: #06287e } /* Name.Function */
39 | .highlight .nl { color: #002070; font-weight: bold } /* Name.Label */
40 | .highlight .nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
41 | .highlight .nt { color: #062873; font-weight: bold } /* Name.Tag */
42 | .highlight .nv { color: #bb60d5 } /* Name.Variable */
43 | .highlight .ow { color: #007020; font-weight: bold } /* Operator.Word */
44 | .highlight .w { color: #bbbbbb } /* Text.Whitespace */
45 | .highlight .mb { color: #208050 } /* Literal.Number.Bin */
46 | .highlight .mf { color: #208050 } /* Literal.Number.Float */
47 | .highlight .mh { color: #208050 } /* Literal.Number.Hex */
48 | .highlight .mi { color: #208050 } /* Literal.Number.Integer */
49 | .highlight .mo { color: #208050 } /* Literal.Number.Oct */
50 | .highlight .sa { color: #4070a0 } /* Literal.String.Affix */
51 | .highlight .sb { color: #4070a0 } /* Literal.String.Backtick */
52 | .highlight .sc { color: #4070a0 } /* Literal.String.Char */
53 | .highlight .dl { color: #4070a0 } /* Literal.String.Delimiter */
54 | .highlight .sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
55 | .highlight .s2 { color: #4070a0 } /* Literal.String.Double */
56 | .highlight .se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
57 | .highlight .sh { color: #4070a0 } /* Literal.String.Heredoc */
58 | .highlight .si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
59 | .highlight .sx { color: #c65d09 } /* Literal.String.Other */
60 | .highlight .sr { color: #235388 } /* Literal.String.Regex */
61 | .highlight .s1 { color: #4070a0 } /* Literal.String.Single */
62 | .highlight .ss { color: #517918 } /* Literal.String.Symbol */
63 | .highlight .bp { color: #007020 } /* Name.Builtin.Pseudo */
64 | .highlight .fm { color: #06287e } /* Name.Function.Magic */
65 | .highlight .vc { color: #bb60d5 } /* Name.Variable.Class */
66 | .highlight .vg { color: #bb60d5 } /* Name.Variable.Global */
67 | .highlight .vi { color: #bb60d5 } /* Name.Variable.Instance */
68 | .highlight .vm { color: #bb60d5 } /* Name.Variable.Magic */
69 | .highlight .il { color: #208050 } /* Literal.Number.Integer.Long */


--------------------------------------------------------------------------------
/docs/_build/html/_static/up-pressed.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/up-pressed.png


--------------------------------------------------------------------------------
/docs/_build/html/_static/up.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/up.png


--------------------------------------------------------------------------------
/docs/_build/html/_static/vollib_60.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/_static/vollib_60.png


--------------------------------------------------------------------------------
/docs/_build/html/objects.inv:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/_build/html/objects.inv


--------------------------------------------------------------------------------
/docs/_build/html/search.html:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | <!DOCTYPE html>
  4 | <!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
  5 | <!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
  6 | <head>
  7 |   <meta charset="utf-8">
  8 |   
  9 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 10 |   
 11 |   <title>Search &mdash; py_vollib 1.0.2 documentation</title>
 12 |   
 13 | 
 14 |   
 15 |   
 16 |     <link rel="shortcut icon" href="_static/favicon.ico"/>
 17 |   
 18 |   
 19 |   
 20 | 
 21 |   
 22 | 
 23 |   
 24 |   
 25 |     
 26 | 
 27 |   
 28 | 
 29 |   
 30 |   
 31 |     <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
 32 |   
 33 | 
 34 |   
 35 | 
 36 |   
 37 |         <link rel="index" title="Index"
 38 |               href="genindex.html"/>
 39 |         <link rel="search" title="Search" href="#"/>
 40 |     <link rel="top" title="py_vollib 1.0.2 documentation" href="index.html"/> 
 41 | 
 42 |   
 43 |   <script src="_static/js/modernizr.min.js"></script>
 44 | 
 45 | </head>
 46 | 
 47 | <body class="wy-body-for-nav" role="document">
 48 | 
 49 |    
 50 |   <div class="wy-grid-for-nav">
 51 | 
 52 |     
 53 |     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
 54 |       <div class="wy-side-scroll">
 55 |         <div class="wy-side-nav-search">
 56 |           
 57 | 
 58 |           
 59 |             <a href="index.html" class="icon icon-home"> py_vollib
 60 |           
 61 | 
 62 |           
 63 |             
 64 |             <img src="_static/vollib_60.png" class="logo" />
 65 |           
 66 |           </a>
 67 | 
 68 |           
 69 |             
 70 |             
 71 |               <div class="version">
 72 |                 1.0
 73 |               </div>
 74 |             
 75 |           
 76 | 
 77 |           
 78 | <div role="search">
 79 |   <form id="rtd-search-form" class="wy-form" action="#" method="get">
 80 |     <input type="text" name="q" placeholder="Search docs" />
 81 |     <input type="hidden" name="check_keywords" value="yes" />
 82 |     <input type="hidden" name="area" value="default" />
 83 |   </form>
 84 | </div>
 85 | 
 86 |           
 87 |         </div>
 88 | 
 89 |         <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
 90 |           
 91 |             
 92 |             
 93 |               
 94 |             
 95 |             
 96 |               <ul>
 97 | <li class="toctree-l1"><a class="reference internal" href="apidoc/modules.html">   py_vollib modules</a></li>
 98 | </ul>
 99 | 
100 |             
101 |           
102 |         </div>
103 |       </div>
104 |     </nav>
105 | 
106 |     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
107 | 
108 |       
109 |       <nav class="wy-nav-top" role="navigation" aria-label="top navigation">
110 |         
111 |           <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
112 |           <a href="index.html">py_vollib</a>
113 |         
114 |       </nav>
115 | 
116 | 
117 |       
118 |       <div class="wy-nav-content">
119 |         <div class="rst-content">
120 |           
121 | 
122 | 
123 | 
124 | 
125 | 
126 | 
127 | 
128 | 
129 | 
130 | 
131 | 
132 | 
133 | 
134 | 
135 | 
136 | <div role="navigation" aria-label="breadcrumbs navigation">
137 | 
138 |   <ul class="wy-breadcrumbs">
139 |     
140 |       <li><a href="index.html">Docs</a> &raquo;</li>
141 |         
142 |       <li>Search</li>
143 |     
144 |     
145 |       <li class="wy-breadcrumbs-aside">
146 |         
147 |       </li>
148 |     
149 |   </ul>
150 | 
151 |   
152 |   <hr/>
153 | </div>
154 |           <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
155 |            <div itemprop="articleBody">
156 |             
157 |   <noscript>
158 |   <div id="fallback" class="admonition warning">
159 |     <p class="last">
160 |       Please activate JavaScript to enable the search
161 |       functionality.
162 |     </p>
163 |   </div>
164 |   </noscript>
165 | 
166 |   
167 |   <div id="search-results">
168 |   
169 |   </div>
170 | 
171 |            </div>
172 |            <div class="articleComments">
173 |             
174 |            </div>
175 |           </div>
176 |           <footer>
177 |   
178 | 
179 |   <hr/>
180 | 
181 |   <div role="contentinfo">
182 |     <p>
183 |         &copy; Copyright 2017, Gammon Capital LLC..
184 | 
185 |     </p>
186 |   </div>
187 |   Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>. 
188 | 
189 | </footer>
190 | 
191 |         </div>
192 |       </div>
193 | 
194 |     </section>
195 | 
196 |   </div>
197 |   
198 | 
199 | 
200 |   
201 | 
202 |     <script type="text/javascript">
203 |         var DOCUMENTATION_OPTIONS = {
204 |             URL_ROOT:'./',
205 |             VERSION:'1.0.2',
206 |             COLLAPSE_INDEX:false,
207 |             FILE_SUFFIX:'.html',
208 |             HAS_SOURCE:  true,
209 |             SOURCELINK_SUFFIX: '.txt'
210 |         };
211 |     </script>
212 |       <script type="text/javascript" src="_static/jquery.js"></script>
213 |       <script type="text/javascript" src="_static/underscore.js"></script>
214 |       <script type="text/javascript" src="_static/doctools.js"></script>
215 |       <script type="text/javascript" src="_static/searchtools.js"></script>
216 | 
217 |   
218 | 
219 |   
220 |   
221 |     <script type="text/javascript" src="_static/js/theme.js"></script>
222 |   
223 | 
224 |   
225 |   
226 |   <script type="text/javascript">
227 |       jQuery(function () {
228 |           SphinxRtdTheme.StickyNav.enable();
229 |       });
230 |   </script>
231 |   
232 |   <script type="text/javascript">
233 |     jQuery(function() { Search.loadIndex("searchindex.js"); });
234 |   </script>
235 |   
236 |   <script type="text/javascript" id="searchindexloader"></script>
237 |    
238 | 
239 | 
240 | </body>
241 | </html>


--------------------------------------------------------------------------------
/docs/apidoc/modules.rst:
--------------------------------------------------------------------------------
1 | py_vollib
2 | =========
3 | 
4 | .. toctree::
5 |    :maxdepth: 4
6 | 
7 |    py_vollib
8 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.black.greeks.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black\.greeks package
 2 | =================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.black\.greeks\.analytical module
 8 | --------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.black.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.black\.greeks\.numerical module
16 | -------------------------------------------
17 | 
18 | .. automodule:: py_vollib.black.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.black.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.black.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black package
 2 | =========================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.black.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.black\.implied\_volatility module
15 | ---------------------------------------------
16 | 
17 | .. automodule:: py_vollib.black.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.black
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.black_scholes.greeks.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black\_scholes\.greeks package
 2 | ==========================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.black\_scholes\.greeks\.analytical module
 8 | -----------------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.black_scholes.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.black\_scholes\.greeks\.numerical module
16 | ----------------------------------------------------
17 | 
18 | .. automodule:: py_vollib.black_scholes.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.black_scholes.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.black_scholes.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black\_scholes package
 2 | ==================================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.black_scholes.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.black\_scholes\.implied\_volatility module
15 | ------------------------------------------------------
16 | 
17 | .. automodule:: py_vollib.black_scholes.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.black_scholes
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.black_scholes_merton.greeks.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black\_scholes\_merton\.greeks package
 2 | ==================================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.black\_scholes\_merton\.greeks\.analytical module
 8 | -------------------------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.black_scholes_merton.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.black\_scholes\_merton\.greeks\.numerical module
16 | ------------------------------------------------------------
17 | 
18 | .. automodule:: py_vollib.black_scholes_merton.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.black_scholes_merton.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.black_scholes_merton.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.black\_scholes\_merton package
 2 | ==========================================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.black_scholes_merton.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.black\_scholes\_merton\.implied\_volatility module
15 | --------------------------------------------------------------
16 | 
17 | .. automodule:: py_vollib.black_scholes_merton.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.black_scholes_merton
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.helpers.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.helpers package
 2 | ===========================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.helpers\.constants module
 8 | -------------------------------------
 9 | 
10 | .. automodule:: py_vollib.helpers.constants
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.helpers\.distributions module
16 | -----------------------------------------
17 | 
18 | .. automodule:: py_vollib.helpers.distributions
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | py\_vollib\.helpers\.doctest\_helper module
24 | -------------------------------------------
25 | 
26 | .. automodule:: py_vollib.helpers.doctest_helper
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 
31 | py\_vollib\.helpers\.exceptions module
32 | --------------------------------------
33 | 
34 | .. automodule:: py_vollib.helpers.exceptions
35 |     :members:
36 |     :undoc-members:
37 |     :show-inheritance:
38 | 
39 | py\_vollib\.helpers\.numerical\_greeks module
40 | ---------------------------------------------
41 | 
42 | .. automodule:: py_vollib.helpers.numerical_greeks
43 |     :members:
44 |     :undoc-members:
45 |     :show-inheritance:
46 | 
47 | 
48 | Module contents
49 | ---------------
50 | 
51 | .. automodule:: py_vollib.helpers
52 |     :members:
53 |     :undoc-members:
54 |     :show-inheritance:
55 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.ref_python.black.greeks.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black\.greeks package
 2 | ==============================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.ref\_python\.black\.greeks\.analytical module
 8 | ---------------------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.ref_python.black.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.ref\_python\.black\.greeks\.numerical module
16 | --------------------------------------------------------
17 | 
18 | .. automodule:: py_vollib.ref_python.black.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.ref_python.black.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.ref_python.black.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black package
 2 | ======================================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.ref_python.black.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.ref\_python\.black\.implied\_volatility module
15 | ----------------------------------------------------------
16 | 
17 | .. automodule:: py_vollib.ref_python.black.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.ref_python.black
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.ref_python.black_scholes.greeks.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black\_scholes\.greeks package
 2 | =======================================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.ref\_python\.black\_scholes\.greeks\.analytical module
 8 | ------------------------------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.ref_python.black_scholes.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.ref\_python\.black\_scholes\.greeks\.numerical module
16 | -----------------------------------------------------------------
17 | 
18 | .. automodule:: py_vollib.ref_python.black_scholes.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.ref_python.black_scholes.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.ref_python.black_scholes.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black\_scholes package
 2 | ===============================================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.ref_python.black_scholes.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.ref\_python\.black\_scholes\.implied\_volatility module
15 | -------------------------------------------------------------------
16 | 
17 | .. automodule:: py_vollib.ref_python.black_scholes.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.ref_python.black_scholes
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.ref_python.black_scholes_merton.greeks.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black\_scholes\_merton\.greeks package
 2 | ===============================================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | py\_vollib\.ref\_python\.black\_scholes\_merton\.greeks\.analytical module
 8 | --------------------------------------------------------------------------
 9 | 
10 | .. automodule:: py_vollib.ref_python.black_scholes_merton.greeks.analytical
11 |     :members:
12 |     :undoc-members:
13 |     :show-inheritance:
14 | 
15 | py\_vollib\.ref\_python\.black\_scholes\_merton\.greeks\.numerical module
16 | -------------------------------------------------------------------------
17 | 
18 | .. automodule:: py_vollib.ref_python.black_scholes_merton.greeks.numerical
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 
23 | 
24 | Module contents
25 | ---------------
26 | 
27 | .. automodule:: py_vollib.ref_python.black_scholes_merton.greeks
28 |     :members:
29 |     :undoc-members:
30 |     :show-inheritance:
31 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.ref_python.black_scholes_merton.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python\.black\_scholes\_merton package
 2 | =======================================================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.ref_python.black_scholes_merton.greeks
10 | 
11 | Submodules
12 | ----------
13 | 
14 | py\_vollib\.ref\_python\.black\_scholes\_merton\.implied\_volatility module
15 | ---------------------------------------------------------------------------
16 | 
17 | .. automodule:: py_vollib.ref_python.black_scholes_merton.implied_volatility
18 |     :members:
19 |     :undoc-members:
20 |     :show-inheritance:
21 | 
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: py_vollib.ref_python.black_scholes_merton
27 |     :members:
28 |     :undoc-members:
29 |     :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.ref_python.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib\.ref\_python package
 2 | ===============================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.ref_python.black
10 |     py_vollib.ref_python.black_scholes
11 |     py_vollib.ref_python.black_scholes_merton
12 | 
13 | Module contents
14 | ---------------
15 | 
16 | .. automodule:: py_vollib.ref_python
17 |     :members:
18 |     :undoc-members:
19 |     :show-inheritance:
20 | 


--------------------------------------------------------------------------------
/docs/apidoc/py_vollib.rst:
--------------------------------------------------------------------------------
 1 | py\_vollib package
 2 | ==================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 | 
 9 |     py_vollib.black
10 |     py_vollib.black_scholes
11 |     py_vollib.black_scholes_merton
12 |     py_vollib.helpers
13 |     py_vollib.ref_python
14 | 
15 | Module contents
16 | ---------------
17 | 
18 | .. automodule:: py_vollib
19 |     :members:
20 |     :undoc-members:
21 |     :show-inheritance:
22 | 


--------------------------------------------------------------------------------
/docs/conf.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | # -*- coding: utf-8 -*-
 3 | 
 4 | from __future__ import print_function
 5 | 
 6 | import sphinx_rtd_theme
 7 | from recommonmark.parser import CommonMarkParser
 8 | 
 9 | project           = 'py_vollib'
10 | copyright         = '2017, Gammon Capital LLC.'
11 | author            = 'Gammon Capital LLC.'
12 | version           = '1.0'
13 | release           = '1.0.2'
14 | extensions        = ['sphinx.ext.autodoc',
15 |                      'sphinx.ext.doctest',
16 |                      'sphinx.ext.coverage',
17 |                      'sphinx.ext.imgmath',
18 |                      'sphinx.ext.ifconfig',
19 |                      'sphinx.ext.viewcode']
20 | source_parsers     = {'.md': CommonMarkParser}
21 | source_suffix      = ['.rst', '.md']
22 | master_doc         = 'index'
23 | language           = None
24 | exclude_patterns   = ['_build', 'Thumbs.db', '.DS_Store']
25 | pygments_style     = 'sphinx'
26 | todo_include_todos = False
27 | html_theme         = "sphinx_rtd_theme"
28 | html_logo          = "vollib_60.png"
29 | html_favicon       = "favicon.ico"
30 | html_theme_path    = [sphinx_rtd_theme.get_html_theme_path()]
31 | 


--------------------------------------------------------------------------------
/docs/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/favicon.ico


--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
 1 | .. vollib documentation master file, created by
 2 |    sphinx-quickstart on Wed Apr  1 19:21:03 2015.
 3 |    You can adapt this file completely to your liking, but it should at least
 4 |    contain the root `toctree` directive.
 5 | 
 6 | 
 7 | .. include:: ../README.rst
 8 | 
 9 | 
10 | Contents:
11 | =========
12 | .. toctree::
13 |    :caption: Table of Contents
14 |    :name: mastertoc
15 | 
16 | 
17 | .. toctree::
18 |    :maxdepth: 1
19 | 
20 | .. toctree::
21 |    :titlesonly:
22 | 
23 |       py_vollib modules <apidoc/modules.rst>
24 | 
25 | 
26 | Indices and tables
27 | ==================
28 | 
29 | * :ref:`genindex`
30 | * :ref:`modindex`
31 | * :ref:`search`
32 | 
33 | 


--------------------------------------------------------------------------------
/docs/vollib_60.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/docs/vollib_60.png


--------------------------------------------------------------------------------
/py_vollib/__init__.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | py_vollib
 5 | ~~~~~~~~~
 6 | 
 7 | A library for option pricing, implied volatility, and
 8 | greek calculation.  py_vollib is based on lets_be_rational,
 9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
10 | described below.
11 | 
12 | :copyright: © 2017 Gammon Capital LLC
13 | :license: MIT, see LICENSE for more details.
14 | 
15 | About LetsBeRational:
16 | ~~~~~~~~~~~~~~~~~~~~~
17 | 
18 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
19 | 
20 | ::
21 | 
22 |     ========================================================================================
23 |     Copyright © 2013-2014 Peter Jäckel.
24 |     
25 |     Permission to use, copy, modify, and distribute this software is freely granted,
26 |     provided that this notice is preserved.
27 |     
28 |     WARRANTY DISCLAIMER
29 |     The Software is provided "as is" without warranty of any kind, either express or implied,
30 |     including without limitation any implied warranties of condition, uninterrupted use,
31 |     merchantability, fitness for a particular purpose, or non-infringement.
32 |     ========================================================================================
33 | 
34 | 
35 | """
36 | 


--------------------------------------------------------------------------------
/py_vollib/black/__init__.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | """
  4 | py_vollib.black
  5 | ~~~~~~~~~~~~~~~
  6 | 
  7 | A library for option pricing, implied volatility, and
  8 | greek calculation.  py_vollib is based on lets_be_rational,
  9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
 10 | described below.
 11 | 
 12 | :copyright: © 2017 Gammon Capital LLC
 13 | :license: MIT, see LICENSE for more details.
 14 | 
 15 | About LetsBeRational:
 16 | ~~~~~~~~~~~~~~~~~~~~~
 17 | 
 18 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
 19 | 
 20 | ::
 21 | 
 22 |     ========================================================================================
 23 |     Copyright © 2013-2014 Peter Jäckel.
 24 | 
 25 |     Permission to use, copy, modify, and distribute this software is freely granted,
 26 |     provided that this notice is preserved.
 27 | 
 28 |     WARRANTY DISCLAIMER
 29 |     The Software is provided "as is" without warranty of any kind, either express or implied,
 30 |     including without limitation any implied warranties of condition, uninterrupted use,
 31 |     merchantability, fitness for a particular purpose, or non-infringement.
 32 |     ========================================================================================
 33 | 
 34 | 
 35 | """
 36 | 
 37 | 
 38 | # -----------------------------------------------------------------------------
 39 | # IMPORTS
 40 | 
 41 | # Standard library imports
 42 | from __future__ import division
 43 | from math import log, sqrt
 44 | 
 45 | # Related third party imports
 46 | import py_lets_be_rational as lets_be_rational
 47 | import numpy
 48 | from numpy import log, sqrt
 49 | 
 50 | # Local application/library specific imports
 51 | from py_vollib.helpers import binary_flag
 52 | 
 53 | 
 54 | # -----------------------------------------------------------------------------
 55 | # FUNCTIONS - OPTION PRICING
 56 | 
 57 | def black(flag, F, K, t, r, sigma):
 58 |     
 59 |     """Calculate the (discounted) Black option price.
 60 | 
 61 |     :param F: underlying futures price
 62 |     :type F: float
 63 |     :param K: strike price
 64 |     :type K: float
 65 |     :param sigma: annualized standard deviation, or volatility
 66 |     :type sigma: float
 67 |     :param t: time to expiration in years
 68 |     :type t: float  
 69 |         
 70 |     >>> F = 100
 71 |     >>> K = 100
 72 |     >>> sigma = .2
 73 |     >>> flag = 'c'
 74 |     >>> r = .02
 75 |     >>> t = .5
 76 |     >>> black(flag, F, K, t, r, sigma)
 77 |     5.5811067246048118
 78 | 
 79 |     """
 80 |     
 81 |     deflater = numpy.exp(-r * t)
 82 |     return undiscounted_black(F, K, sigma, t, flag) * deflater
 83 | 
 84 | # -----------------------------------------------------------------------------
 85 | # FUNCTIONS - FOR REFERENCE AND TESTING
 86 | 
 87 | def undiscounted_black(F, K, sigma, t, flag):
 88 | 
 89 |     """Calculate the **undiscounted** Black option price.
 90 | 
 91 |     :param F: underlying futures price
 92 |     :type F: float
 93 |     :param K: strike price
 94 |     :type K: float
 95 |     :param sigma: annualized standard deviation, or volatility
 96 |     :type sigma: float
 97 |     :param t: time to expiration in years
 98 |     :type t: float   
 99 | 
100 |     >>> F = 100
101 |     >>> K = 100
102 |     >>> sigma = .2
103 |     >>> flag = 'c'
104 |     >>> t = .5
105 |     >>> undiscounted_black(F, K, sigma, t, flag)
106 |     5.637197779701664
107 |     
108 |     """
109 | 
110 |     q = binary_flag[flag]
111 |     F = float(F)
112 |     K = float(K)
113 |     sigma = float(sigma)
114 |     t = float(t)
115 |     
116 |     return lets_be_rational.black(F, K, sigma, t, q)
117 | 
118 | 
119 | def normalised_black(x, s, flag):
120 | 
121 |     """Calculate the normalised Black value,
122 |     a "time value put-call invariant" transformation
123 |     of the Black pricing formula.  In other words, 
124 |     the amount of time value, or "extrinsic" value 
125 |     of a put and call at the same log-moneyness will
126 |     be always be identical.
127 | 
128 |     :param x: ln(F/K) where K is the strike price, and F is the futures price
129 |     :type x: float
130 |     :param s: volatility times the square root of time to expiration
131 |     :type s: float
132 |     :param flag: 'p' or 'c' for put or call 
133 |     :type flag: str   
134 |     
135 |     
136 |     >>> def normalised_intrinsic(F, K, flag): 
137 |     ...     if flag=='c':
138 |     ...         return max(F-K,0)/(F*K)**0.5
139 |     ...     else:
140 |     ...         return max(K-F,0)/(F*K)**0.5    
141 |     
142 |     >>> F = 100.
143 |     >>> K = 95.
144 |     >>> x = log(F/K)
145 |     >>> t = 0.5
146 |     >>> v = 0.3
147 |     >>> s = v * sqrt(t)    
148 |     
149 |     >>> normalised_black(x,s,'p')
150 |     0.061296663817558904
151 |     
152 |     >>> normalised_black(x,s,'c')
153 |     0.11259558142181655
154 |     
155 |     '''
156 |     Here the put is OTM, so has only time value.
157 |     The call is ITM, having both intrinsic and time value.
158 |     Since the time value must be equal for both, 
159 |     the call normalised price minus its normalised 
160 |     intrinsic must equal the put normalised price.
161 |     
162 |     
163 |     >>> (normalised_black(x,s,'p') - (
164 |     ... normalised_black(x,s,'c') - normalised_intrinsic(F,K,'c')))<1e-12 
165 |     True
166 |     
167 |     
168 |     """
169 |     
170 |     q = binary_flag[flag]
171 |     
172 |     return lets_be_rational.normalised_black(x, s, q)
173 | 
174 | 
175 | if __name__ == "__main__":
176 |     from py_vollib.helpers.doctest_helper import run_doctest
177 |     run_doctest()
178 | 
179 | 
180 | 


--------------------------------------------------------------------------------
/py_vollib/black/greeks/__init__.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | py_vollib
 5 | ~~~~~~~~~
 6 | 
 7 | A library for option pricing, implied volatility, and
 8 | greek calculation.  py_vollib is based on lets_be_rational,
 9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
10 | described below.
11 | 
12 | :copyright: © 2017 Gammon Capital LLC
13 | :license: MIT, see LICENSE for more details.
14 | 
15 | About LetsBeRational:
16 | ~~~~~~~~~~~~~~~~~~~~~
17 | 
18 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
19 | 
20 | ::
21 | 
22 |     ========================================================================================
23 |     Copyright © 2013-2014 Peter Jäckel.
24 | 
25 |     Permission to use, copy, modify, and distribute this software is freely granted,
26 |     provided that this notice is preserved.
27 | 
28 |     WARRANTY DISCLAIMER
29 |     The Software is provided "as is" without warranty of any kind, either express or implied,
30 |     including without limitation any implied warranties of condition, uninterrupted use,
31 |     merchantability, fitness for a particular purpose, or non-infringement.
32 |     ========================================================================================
33 | 
34 | 
35 | """
36 | 


--------------------------------------------------------------------------------
/py_vollib/black_scholes/__init__.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | py_vollib.black_scholes
 5 | ~~~~~~~~~~~~~~~~~~~~~~~
 6 | 
 7 | A library for option pricing, implied volatility, and
 8 | greek calculation.  py_vollib is based on lets_be_rational,
 9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
10 | described below.
11 | 
12 | :copyright: © 2017 Gammon Capital LLC
13 | :license: MIT, see LICENSE for more details.
14 | 
15 | About LetsBeRational:
16 | ~~~~~~~~~~~~~~~~~~~~~
17 | 
18 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
19 | 
20 | ::
21 | 
22 |     ========================================================================================
23 |     Copyright © 2013-2014 Peter Jäckel.
24 | 
25 |     Permission to use, copy, modify, and distribute this software is freely granted,
26 |     provided that this notice is preserved.
27 | 
28 |     WARRANTY DISCLAIMER
29 |     The Software is provided "as is" without warranty of any kind, either express or implied,
30 |     including without limitation any implied warranties of condition, uninterrupted use,
31 |     merchantability, fitness for a particular purpose, or non-infringement.
32 |     ========================================================================================
33 | 
34 | 
35 | """
36 | 
37 | 
38 | # -----------------------------------------------------------------------------
39 | # IMPORTS
40 | 
41 | # Standard library imports
42 | from __future__ import division
43 | 
44 | # Related third party imports
45 | import numpy
46 | 
47 | # Local application/library specific imports
48 | from py_vollib.black import undiscounted_black
49 | 
50 | 
51 | # -----------------------------------------------------------------------------
52 | # FUNCTIONS 
53 | 
54 | def black_scholes(flag, S, K, t, r, sigma):
55 |     """Return the Black-Scholes option price.
56 | 
57 |     :param S: underlying asset price
58 |     :type S: float
59 |     :param K: strike price
60 |     :type K: float
61 |     :param sigma: annualized standard deviation, or volatility
62 |     :type sigma: float
63 |     :param t: time to expiration in years
64 |     :type t: float
65 |     :param r: risk-free interest rate
66 |     :type r: float
67 |     :param flag: 'c' or 'p' for call or put.
68 |     :type flag: str    
69 |     
70 |     
71 |     >>> c = black_scholes('c',100,90,.5,.01,.2) 
72 |     >>> abs(c - 12.111581435) < .000001
73 |     True
74 | 
75 |     >>> p = black_scholes('p',100,90,.5,.01,.2) 
76 |     >>> abs(p - 1.66270456231) < .000001
77 |     True
78 |     """   
79 |     
80 |     deflater = numpy.exp(-r * t)
81 |     F = S / deflater
82 |     return undiscounted_black(F, K, sigma, t, flag) * deflater
83 | 
84 | 
85 | if __name__ == "__main__":
86 |     from py_vollib.helpers.doctest_helper import run_doctest
87 |     run_doctest()
88 | 


--------------------------------------------------------------------------------
/py_vollib/black_scholes/greeks/__init__.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | py_vollib.black_scholes.greeks
 5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 6 | 
 7 | A library for option pricing, implied volatility, and
 8 | greek calculation.  py_vollib is based on lets_be_rational,
 9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
10 | described below.
11 | 
12 | :copyright: © 2017 Gammon Capital LLC
13 | :license: MIT, see LICENSE for more details.
14 | 
15 | About LetsBeRational:
16 | ~~~~~~~~~~~~~~~~~~~~~
17 | 
18 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
19 | 
20 | ::
21 | 
22 |     ========================================================================================
23 |     Copyright © 2013-2014 Peter Jäckel.
24 | 
25 |     Permission to use, copy, modify, and distribute this software is freely granted,
26 |     provided that this notice is preserved.
27 | 
28 |     WARRANTY DISCLAIMER
29 |     The Software is provided "as is" without warranty of any kind, either express or implied,
30 |     including without limitation any implied warranties of condition, uninterrupted use,
31 |     merchantability, fitness for a particular purpose, or non-infringement.
32 |     ========================================================================================
33 | 
34 | 
35 | """
36 | 


--------------------------------------------------------------------------------
/py_vollib/black_scholes/implied_volatility.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | """
  4 | py_vollib.black_scholes.implied_volatility
  5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  6 | 
  7 | A library for option pricing, implied volatility, and
  8 | greek calculation.  py_vollib is based on lets_be_rational,
  9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
 10 | described below.
 11 | 
 12 | :copyright: © 2017 Gammon Capital LLC
 13 | :license: MIT, see LICENSE for more details.
 14 | 
 15 | About LetsBeRational:
 16 | ~~~~~~~~~~~~~~~~~~~~~
 17 | 
 18 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
 19 | 
 20 | ::
 21 | 
 22 |     ========================================================================================
 23 |     Copyright © 2013-2014 Peter Jäckel.
 24 | 
 25 |     Permission to use, copy, modify, and distribute this software is freely granted,
 26 |     provided that this notice is preserved.
 27 | 
 28 |     WARRANTY DISCLAIMER
 29 |     The Software is provided "as is" without warranty of any kind, either express or implied,
 30 |     including without limitation any implied warranties of condition, uninterrupted use,
 31 |     merchantability, fitness for a particular purpose, or non-infringement.
 32 |     ========================================================================================
 33 | 
 34 | 
 35 | """
 36 | 
 37 | 
 38 | # -----------------------------------------------------------------------------
 39 | # IMPORTS
 40 | 
 41 | # Standard library imports
 42 | 
 43 | # Related third party imports
 44 | from py_lets_be_rational import implied_volatility_from_a_transformed_rational_guess as iv
 45 | import numpy
 46 | 
 47 | # Local application/library specific imports
 48 | from py_vollib.black_scholes import black_scholes
 49 | from py_vollib.helpers import binary_flag
 50 | from py_vollib.helpers import forward_price
 51 | from py_vollib.helpers.constants import FLOAT_MAX, MINUS_FLOAT_MAX
 52 | from py_vollib.helpers.exceptions import PriceIsAboveMaximum, PriceIsBelowIntrinsic
 53 | 
 54 | 
 55 | # -----------------------------------------------------------------------------
 56 | # FUNCTIONS
 57 | 
 58 | def implied_volatility(price, S, K, t, r, flag):
 59 |     """Calculate the Black-Scholes implied volatility.
 60 | 
 61 |     :param price: the Black-Scholes option price
 62 |     :type price: float
 63 |     :param S: underlying asset price
 64 |     :type S: float
 65 |     :param K: strike price
 66 |     :type K: float
 67 |     :param t: time to expiration in years
 68 |     :type t: float
 69 |     :param r: risk-free interest rate
 70 |     :type r: float
 71 |     :param flag: 'c' or 'p' for call or put.
 72 |     :type flag: str 
 73 |     
 74 |     >>> S = 100
 75 |     >>> K = 100
 76 |     >>> sigma = .2
 77 |     >>> r = .01
 78 |     >>> flag = 'c'
 79 |     >>> t = .5
 80 | 
 81 |     >>> price = black_scholes(flag, S, K, t, r, sigma)
 82 |     >>> iv = implied_volatility(price, S, K, t, r, flag)
 83 | 
 84 |     >>> expected_price = 5.87602423383
 85 |     >>> expected_iv = 0.2
 86 |     
 87 |     >>> abs(expected_price - price) < 0.00001
 88 |     True
 89 |     >>> abs(expected_iv - iv) < 0.00001
 90 |     True
 91 |     """
 92 |     deflater = numpy.exp(-r * t)
 93 |     undiscounted_option_price = price / deflater
 94 |     F = forward_price(S, t, r)
 95 |     sigma_calc = iv(undiscounted_option_price, F, K, t, binary_flag[flag])
 96 |     if sigma_calc == FLOAT_MAX:
 97 |         raise PriceIsAboveMaximum()
 98 |     elif sigma_calc == MINUS_FLOAT_MAX:
 99 |         raise PriceIsBelowIntrinsic()
100 |     return sigma_calc
101 | 
102 | 
103 | if __name__ == "__main__":
104 |     from py_vollib.helpers.doctest_helper import run_doctest
105 |     run_doctest()
106 | 


--------------------------------------------------------------------------------
/py_vollib/black_scholes_merton/__init__.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | py_vollib.black_scholes_merton
 5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 6 | 
 7 | A library for option pricing, implied volatility, and
 8 | greek calculation.  py_vollib is based on lets_be_rational,
 9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
10 | described below.
11 | 
12 | :copyright: © 2017 Gammon Capital LLC
13 | :license: MIT, see LICENSE for more details.
14 | 
15 | About LetsBeRational:
16 | ~~~~~~~~~~~~~~~~~~~~~
17 | 
18 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
19 | 
20 | ::
21 | 
22 |     ========================================================================================
23 |     Copyright © 2013-2014 Peter Jäckel.
24 | 
25 |     Permission to use, copy, modify, and distribute this software is freely granted,
26 |     provided that this notice is preserved.
27 | 
28 |     WARRANTY DISCLAIMER
29 |     The Software is provided "as is" without warranty of any kind, either express or implied,
30 |     including without limitation any implied warranties of condition, uninterrupted use,
31 |     merchantability, fitness for a particular purpose, or non-infringement.
32 |     ========================================================================================
33 | 
34 | 
35 | """
36 | 
37 | 
38 | # -----------------------------------------------------------------------------
39 | # IMPORTS
40 | 
41 | # Standard library imports
42 | 
43 | # Related third party imports
44 | import numpy
45 | 
46 | # Local application/library specific imports
47 | from py_lets_be_rational import black
48 | from py_vollib.helpers import binary_flag
49 | 
50 | 
51 | # -----------------------------------------------------------------------------
52 | # FUNCTIONS
53 | 
54 | def black_scholes_merton(flag, S, K, t, r, sigma, q):
55 |     """Return the Black-Scholes-Merton option price.
56 | 
57 |     :param S: underlying asset price
58 |     :type S: float
59 |     :param K: strike price
60 |     :type K: float
61 |     :param sigma: annualized standard deviation, or volatility
62 |     :type sigma: float
63 |     :param t: time to expiration in years
64 |     :type t: float
65 |     :param r: risk-free interest rate
66 |     :type r: float
67 |     :param q: annualized continuous dividend rate
68 |     :type q: float 
69 | 
70 |     From Espen Haug, The Complete Guide To Option Pricing Formulas
71 |     Page 4
72 | 
73 |     >>> S=100
74 |     >>> K=95
75 |     >>> q=.05
76 |     >>> t = 0.5
77 |     >>> r = 0.1
78 |     >>> sigma = 0.2
79 | 
80 |     >>> p_published_value = 2.4648
81 |     >>> p_calc = black_scholes_merton('p', S, K, t, r, sigma, q)
82 |     >>> abs(p_published_value - p_calc) < 0.0001
83 |     True
84 |     """
85 |     
86 |     F = S * numpy.exp((r-q)*t)
87 |     deflater = numpy.exp(-r * t)
88 |     return black(F, K, sigma, t, binary_flag[flag]) * deflater
89 | 
90 | 
91 | if __name__ == "__main__":
92 |     from py_vollib.helpers.doctest_helper import run_doctest
93 |     run_doctest()
94 | 


--------------------------------------------------------------------------------
/py_vollib/black_scholes_merton/greeks/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/py_vollib/black_scholes_merton/greeks/__init__.py


--------------------------------------------------------------------------------
/py_vollib/black_scholes_merton/implied_volatility.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | """
  4 | py_vollib.black_scholes_merton.implied_volatility
  5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  6 | 
  7 | Copyright © 2017 Gammon Capital LLC
  8 | 
  9 | A library for option pricing, implied volatility, and
 10 | greek calculation.  py_vollib is based on lets_be_rational,
 11 | a Python wrapper for LetsBeRational by Peter Jaeckel as
 12 | described below.
 13 | 
 14 | :copyright: © 2017 Gammon Capital LLC
 15 | :license: MIT, see LICENSE for more details.
 16 | 
 17 | About LetsBeRational:
 18 | ~~~~~~~~~~~~~~~~~~~~~
 19 | 
 20 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
 21 | 
 22 | ::
 23 | 
 24 |     ========================================================================================
 25 |     Copyright © 2013-2014 Peter Jäckel.
 26 | 
 27 |     Permission to use, copy, modify, and distribute this software is freely granted,
 28 |     provided that this notice is preserved.
 29 | 
 30 |     WARRANTY DISCLAIMER
 31 |     The Software is provided "as is" without warranty of any kind, either express or implied,
 32 |     including without limitation any implied warranties of condition, uninterrupted use,
 33 |     merchantability, fitness for a particular purpose, or non-infringement.
 34 |     ========================================================================================
 35 | 
 36 | 
 37 | """
 38 | 
 39 | 
 40 | # -----------------------------------------------------------------------------
 41 | # IMPORTS
 42 | 
 43 | # Standard library imports
 44 | from __future__ import division
 45 | 
 46 | # Related third party imports
 47 | from py_lets_be_rational import implied_volatility_from_a_transformed_rational_guess as iv
 48 | import numpy
 49 | 
 50 | # Local application/library specific imports
 51 | from py_vollib.black_scholes_merton import black_scholes_merton
 52 | from py_vollib.helpers import binary_flag
 53 | from py_vollib.helpers.exceptions import PriceIsAboveMaximum, PriceIsBelowIntrinsic
 54 | from py_vollib.helpers.constants import MINUS_FLOAT_MAX, FLOAT_MAX
 55 | 
 56 | 
 57 | # -----------------------------------------------------------------------------
 58 | # FUNCTIONS
 59 | 
 60 | def implied_volatility(price, S, K, t, r, q, flag):
 61 |     """Calculate the Black-Scholes-Merton implied volatility.
 62 | 
 63 |     :param S: underlying asset price
 64 |     :type S: float
 65 |     :param K: strike price
 66 |     :type K: float
 67 |     :param sigma: annualized standard deviation, or volatility
 68 |     :type sigma: float
 69 |     :param t: time to expiration in years
 70 |     :type t: float
 71 |     :param r: risk-free interest rate
 72 |     :type r: float
 73 |     :param q: annualized continuous dividend rate
 74 |     :type q: float 
 75 |     :param flag: 'c' or 'p' for call or put.
 76 |     :type flag: str
 77 | 
 78 |     >>> S = 100
 79 |     >>> K = 100
 80 |     >>> sigma = .2
 81 |     >>> r = .01
 82 |     >>> flag = 'c'
 83 |     >>> t = .5
 84 |     >>> q = 0
 85 |     
 86 |     >>> price = black_scholes_merton(flag, S, K, t, r, sigma, q)
 87 |     >>> iv = implied_volatility(price, S, K, t, r, q, flag)
 88 | 
 89 |     >>> expected_price = 5.87602423383
 90 |     >>> expected_iv = 0.2
 91 |     
 92 |     >>> abs(expected_price - price) < 0.00001
 93 |     True
 94 |     >>> abs(expected_iv - iv) < 0.00001
 95 |     True
 96 |     """
 97 | 
 98 |     deflater = numpy.exp(-r * t)
 99 |     
100 |     undiscounted_option_price = price / deflater
101 |     
102 |     F = S * numpy.exp((r-q)*t)
103 |     
104 |     sigma_calc = iv(undiscounted_option_price, F, K, t, binary_flag[flag])
105 | 
106 |     if sigma_calc == FLOAT_MAX:
107 |         
108 |         raise PriceIsAboveMaximum()
109 |     
110 |     elif sigma_calc == MINUS_FLOAT_MAX:
111 |         
112 |         raise PriceIsBelowIntrinsic() 
113 |     
114 |     return sigma_calc
115 | 
116 | 
117 | if __name__ == "__main__":
118 |     from py_vollib.helpers.doctest_helper import run_doctest
119 |     run_doctest()
120 | 


--------------------------------------------------------------------------------
/py_vollib/helpers/__init__.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | """
  4 | py_vollib.helpers
  5 | ~~~~~~~~~~~~~~~~~
  6 | 
  7 | A library for option pricing, implied volatility, and
  8 | greek calculation.  py_vollib is based on lets_be_rational,
  9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
 10 | described below.
 11 | 
 12 | :copyright: © 2017 Gammon Capital LLC
 13 | :license: MIT, see LICENSE for more details.
 14 | 
 15 | About LetsBeRational:
 16 | ~~~~~~~~~~~~~~~~~~~~~
 17 | 
 18 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
 19 | 
 20 | ::
 21 | 
 22 |     ========================================================================================
 23 |     Copyright © 2013-2014 Peter Jäckel.
 24 | 
 25 |     Permission to use, copy, modify, and distribute this software is freely granted,
 26 |     provided that this notice is preserved.
 27 | 
 28 |     WARRANTY DISCLAIMER
 29 |     The Software is provided "as is" without warranty of any kind, either express or implied,
 30 |     including without limitation any implied warranties of condition, uninterrupted use,
 31 |     merchantability, fitness for a particular purpose, or non-infringement.
 32 |     ========================================================================================
 33 | 
 34 | 
 35 | """
 36 | 
 37 | 
 38 | # -----------------------------------------------------------------------------
 39 | # IMPORTS
 40 | 
 41 | # Standard library imports
 42 | from __future__ import division
 43 | 
 44 | # Related third party imports
 45 | import numpy
 46 | 
 47 | # Local application/library specific imports
 48 | 
 49 | 
 50 | # -----------------------------------------------------------------------------
 51 | # DATA
 52 | 
 53 | ONE_OVER_SQRT_TWO_PI = 0.3989422804014326779399460599343818684758586311649
 54 | CALL = 'c'
 55 | PUT = 'p'
 56 | 
 57 | binary_flag = {CALL:1,PUT:-1}
 58 | 
 59 | 
 60 | def test_binary_flag():
 61 |     """
 62 |     ::
 63 |     
 64 |       ========================================================
 65 |     
 66 |       Note:  In "Let's be Rational," Peter Jäckel uses θ as a flag
 67 |       to distinguish between puts and calls.
 68 |       +1 represents a call, -1 represents a put.
 69 |     
 70 |       See page 1, Introduction, first paragraph.
 71 |       
 72 |       Throughout py_vollib this is replaced with 'c' and 'p'.
 73 |       ========================================================    
 74 |     
 75 |     >>> binary_flag['c']
 76 |     1
 77 |     >>> binary_flag['p']
 78 |     -1
 79 |     """
 80 | 
 81 | 
 82 | # -----------------------------------------------------------------------------
 83 | # FUNCTIONS
 84 | 
 85 | pdf = lambda x: ONE_OVER_SQRT_TWO_PI * numpy.exp(-.5*x*x)
 86 | """the probability density function
 87 | 
 88 |     :param x: a continuous random variable
 89 |     :type S: float
 90 | 
 91 | """
 92 | 
 93 | 
 94 | def forward_price(S,t,r):
 95 |     """Calculate the forward price of an underlying asset.
 96 | 
 97 |     :param S: underlying asset price
 98 |     :type S: float
 99 |     :param t: time to expiration in years
100 |     :type t: float
101 |     :param r: risk-free interest rate
102 |     :type r: float
103 | 
104 |     >>> S = 95
105 |     >>> t = .5
106 |     >>> r = .02
107 |     >>> F = forward_price(S,t,r)
108 |     >>> pre_calculated = 95.95476587299596
109 |     >>> abs(F-pre_calculated)<.000000001
110 |     True
111 |     """
112 | 
113 |     return S/numpy.exp(-r*t)
114 | 
115 | 
116 | if __name__ == "__main__":
117 |     from py_vollib.helpers.doctest_helper import run_doctest
118 |     run_doctest()
119 | 


--------------------------------------------------------------------------------
/py_vollib/helpers/constants.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | py_vollib.helpers.constants
 5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 6 | 
 7 | A library for option pricing, implied volatility, and
 8 | greek calculation.  py_vollib is based on lets_be_rational,
 9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
10 | described below.
11 | 
12 | :copyright: © 2017 Gammon Capital LLC
13 | :license: MIT, see LICENSE for more details.
14 | 
15 | About LetsBeRational:
16 | ~~~~~~~~~~~~~~~~~~~~~
17 | 
18 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
19 | 
20 | ::
21 | 
22 |     ========================================================================================
23 |     Copyright © 2013-2014 Peter Jäckel.
24 | 
25 |     Permission to use, copy, modify, and distribute this software is freely granted,
26 |     provided that this notice is preserved.
27 | 
28 |     WARRANTY DISCLAIMER
29 |     The Software is provided "as is" without warranty of any kind, either express or implied,
30 |     including without limitation any implied warranties of condition, uninterrupted use,
31 |     merchantability, fitness for a particular purpose, or non-infringement.
32 |     ========================================================================================
33 | 
34 | 
35 | """
36 | 
37 | 
38 | # -----------------------------------------------------------------------------
39 | # IMPORTS
40 | 
41 | # Standard library imports
42 | import sys
43 | 
44 | # Related third party imports
45 | 
46 | # Local application/library specific imports
47 | 
48 | 
49 | FLOAT_MAX = sys.float_info.max
50 | MINUS_FLOAT_MAX = - FLOAT_MAX
51 | 
52 | 
53 | if __name__ == "__main__":
54 |     from py_vollib.helpers.doctest_helper import run_doctest
55 |     run_doctest()
56 | 


--------------------------------------------------------------------------------
/py_vollib/helpers/doctest_helper.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | py_vollib.helpers.doctest_helper
 5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 6 | 
 7 | A library for option pricing, implied volatility, and
 8 | greek calculation.  py_vollib is based on lets_be_rational,
 9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
10 | described below.
11 | 
12 | :copyright: © 2017 Gammon Capital LLC
13 | :license: MIT, see LICENSE for more details.
14 | 
15 | About LetsBeRational:
16 | ~~~~~~~~~~~~~~~~~~~~~
17 | 
18 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
19 | 
20 | ::
21 | 
22 |     ========================================================================================
23 |     Copyright © 2013-2014 Peter Jäckel.
24 | 
25 |     Permission to use, copy, modify, and distribute this software is freely granted,
26 |     provided that this notice is preserved.
27 | 
28 |     WARRANTY DISCLAIMER
29 |     The Software is provided "as is" without warranty of any kind, either express or implied,
30 |     including without limitation any implied warranties of condition, uninterrupted use,
31 |     merchantability, fitness for a particular purpose, or non-infringement.
32 |     ========================================================================================
33 | 
34 | 
35 | """
36 | 
37 | # -----------------------------------------------------------------------------
38 | # IMPORTS
39 | 
40 | # Standard library imports
41 | 
42 | # Related third party imports
43 | 
44 | # Local application/library specific imports
45 | 
46 | 
47 | def run_doctest():
48 |     hline = '**********************************************************************'
49 |     import doctest
50 |     result = doctest.testmod()
51 |     if result.failed:
52 |         print(hline)
53 |         print('{} out of {} tests failed'.format(
54 |             result.failed, result.attempted))
55 |         print(hline)
56 |     else:    
57 |         print(hline)
58 |         print('{} out of {} tests passed.'.format(
59 |             result.attempted, result.attempted))
60 |         print(hline)
61 | 
62 | 
63 | if __name__ == "__main__":
64 |     from py_vollib.helpers.doctest_helper import run_doctest
65 |     run_doctest()
66 | 


--------------------------------------------------------------------------------
/py_vollib/helpers/exceptions.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | py_vollib.helpers.exceptions
 5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 6 | 
 7 | A library for option pricing, implied volatility, and
 8 | greek calculation.  py_vollib is based on lets_be_rational,
 9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
10 | described below.
11 | 
12 | :copyright: © 2017 Gammon Capital LLC
13 | :license: MIT, see LICENSE for more details.
14 | 
15 | About LetsBeRational:
16 | ~~~~~~~~~~~~~~~~~~~~~
17 | 
18 | The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
19 | 
20 | ::
21 | 
22 |     ========================================================================================
23 |     Copyright © 2013-2014 Peter Jäckel.
24 | 
25 |     Permission to use, copy, modify, and distribute this software is freely granted,
26 |     provided that this notice is preserved.
27 | 
28 |     WARRANTY DISCLAIMER
29 |     The Software is provided "as is" without warranty of any kind, either express or implied,
30 |     including without limitation any implied warranties of condition, uninterrupted use,
31 |     merchantability, fitness for a particular purpose, or non-infringement.
32 |     ========================================================================================
33 | 
34 | 
35 | """
36 | 
37 | 
38 | # -----------------------------------------------------------------------------
39 | # IMPORTS
40 | 
41 | # Standard library imports
42 | 
43 | # Related third party imports
44 | 
45 | # Local application/library specific imports
46 | 
47 | 
48 | class InvalidArgument(Exception):
49 |     pass
50 | 
51 | 
52 | class PriceIsAboveMaximum(Exception):
53 |     pass
54 | 
55 | 
56 | class PriceIsBelowIntrinsic(Exception):
57 |     pass
58 | 
59 | 
60 | if __name__ == "__main__":
61 |     from py_vollib.helpers.doctest_helper import run_doctest
62 |     run_doctest()
63 | 


--------------------------------------------------------------------------------
/py_vollib/ref_python/__init__.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | py_vollib.ref_python
 5 | ~~~~~~~~~~~~~~~~~~~~
 6 | 
 7 | A library for option pricing, implied volatility, and
 8 | greek calculation.  py_vollib is based on lets_be_rational,
 9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
10 | described below.
11 | 
12 | :copyright: © 2017 Gammon Capital LLC
13 | :license: MIT, see LICENSE for more details.
14 | 
15 | py_vollib.ref_python is a pure python version of py_vollib without any dependence on LetsBeRational. It is provided purely as a reference implementation for sanity checking. It is not recommended for industrial use.
16 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
17 | 
18 | """
19 | 


--------------------------------------------------------------------------------
/py_vollib/ref_python/black/__init__.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | """
  4 | py_vollib.ref_python.black
  5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~
  6 | 
  7 | A library for option pricing, implied volatility, and
  8 | greek calculation.  py_vollib is based on lets_be_rational,
  9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
 10 | described below.
 11 | 
 12 | :copyright: © 2017 Gammon Capital LLC
 13 | :license: MIT, see LICENSE for more details.
 14 | 
 15 | py_vollib.ref_python is a pure python version of py_vollib without any dependence on LetsBeRational. It is provided purely as a reference implementation for sanity checking. It is not recommended for industrial use.
 16 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 17 | 
 18 | """
 19 | 
 20 | 
 21 | # -----------------------------------------------------------------------------
 22 | # IMPORTS
 23 | 
 24 | # Standard library imports
 25 | from __future__ import division
 26 | from math import log, sqrt
 27 | 
 28 | # Related third party imports
 29 | import numpy
 30 | from numpy import log, sqrt
 31 | from scipy.stats import norm
 32 | 
 33 | # Local application/library specific imports
 34 | 
 35 | 
 36 | N = norm.cdf
 37 | 
 38 | 
 39 | # -----------------------------------------------------------------------------
 40 | # FUNCTIONS - INTERNAL, FOR COMPARISON
 41 | 
 42 | '''
 43 | From John C. Hull, "Options, Futures and Other Derivatives,"
 44 | 7th edition, Chapter 16.8, page 342
 45 | '''
 46 | 
 47 | def d1(F, K, t, r, sigma):  # keep r argument for consistency
 48 |     """Calculate the d1 component of the Black PDE.
 49 | 
 50 |     :param F: underlying futures price
 51 |     :type F: float
 52 |     :param K: strike price
 53 |     :type K: float
 54 |     :param sigma: annualized standard deviation, or volatility
 55 |     :type sigma: float
 56 |     :param t: time to expiration in years
 57 |     :type t: float
 58 |     :param r: risk-free interest rate
 59 |     :type r: float
 60 | 
 61 |     Doctest using Hull, page 343, example 16.6
 62 | 
 63 |     >>> F = 20
 64 |     >>> K = 20
 65 |     >>> r = .09
 66 |     >>> t = 4/12.0
 67 |     >>> sigma = 0.25
 68 | 
 69 |     >>> calculated_value = d1(F, K, t, r, sigma)
 70 |     >>> #0.0721687836487
 71 |     >>> text_book_value = 0.07216
 72 |     >>> abs(calculated_value - text_book_value) < .00001
 73 |     True
 74 |     """
 75 | 
 76 |     sigma_squared = sigma * sigma
 77 |     numerator = log(F / float(K)) + sigma_squared * t / 2.0
 78 |     denominator = sigma * sqrt(t)
 79 | 
 80 |     return numerator / denominator
 81 | 
 82 | 
 83 | def d2(F, K, t, r, sigma):  # keep r argument for consistency
 84 |     """Calculate the d2 component of the Black PDE.
 85 | 
 86 |     :param F: underlying futures price
 87 |     :type F: float
 88 |     :param K: strike price
 89 |     :type K: float
 90 |     :param sigma: annualized standard deviation, or volatility
 91 |     :type sigma: float
 92 |     :param t: time to expiration in years
 93 |     :type t: float
 94 |     :param r: risk-free interest rate
 95 |     :type r: float
 96 | 
 97 |     Hull, page 343, example 16.6
 98 | 
 99 |     >>> F = 20
100 |     >>> K = 20
101 |     >>> r = .09
102 |     >>> t = 4/12.0
103 |     >>> sigma = 0.25
104 | 
105 |     >>> calculated_value = d2(F, K, t, r, sigma)
106 |     >>> #-0.0721687836487
107 |     >>> text_book_value = -0.07216
108 |     >>> abs(calculated_value - text_book_value) < .00001
109 |     True
110 |     """
111 | 
112 |     return d1(F, K, t, r, sigma) - sigma * sqrt(t)
113 | 
114 | 
115 | def black_call(F, K, t, r, sigma):  # Equation 16.9
116 |     """Calculate the price of a call using Black.  (Python
117 |     implementation for reference.)
118 | 
119 |     :param F: underlying futures price
120 |     :type F: float
121 |     :param K: strike price
122 |     :type K: float
123 |     :param sigma: annualized standard deviation, or volatility
124 |     :type sigma: float
125 |     :param t: time to expiration in years
126 |     :type t: float
127 |     :param r: risk-free interest rate
128 |     :type r: float
129 | 
130 |     Hull, page 343, example 16.7
131 | 
132 |     >>> F = 620
133 |     >>> K = 600
134 |     >>> r = .05
135 |     >>> sigma = .2
136 |     >>> t = 0.5
137 |     >>> calculated_value = black_call(F, K, t, r, sigma)
138 |     >>> #44.1868533121
139 |     >>> text_book_value = 44.19
140 |     >>> abs(calculated_value - text_book_value) < .01
141 |     True
142 |     """
143 | 
144 |     deflater = numpy.exp(-r * t)
145 |     N_d1 = N(d1(F, K, t, r, sigma))
146 |     N_d2 = N(d2(F, K, t, r, sigma))
147 | 
148 |     return deflater * (F * N_d1 - K * N_d2)
149 | 
150 | 
151 | def black_put(F, K, t, r, sigma):  # Equation 16.10
152 |     """Calculate the price of a put using Black.  (Python
153 |     implementation for reference.)
154 | 
155 |     :param F: underlying futures price
156 |     :type F: float
157 |     :param K: strike price
158 |     :type K: float
159 |     :param sigma: annualized standard deviation, or volatility
160 |     :type sigma: float
161 |     :param t: time to expiration in years
162 |     :type t: float
163 |     :param r: risk-free interest rate
164 |     :type r: float
165 | 
166 |     Hull, page 338, example 16.6
167 | 
168 |     >>> F = 20
169 |     >>> K = 20
170 |     >>> r = .09
171 |     >>> sigma = .25
172 |     >>> t = 4/12.0
173 |     >>> calculated_value = black_put(F, K, t, r, sigma)
174 |     >>> # 1.11664145656
175 |     >>> text_book_value = 1.12
176 |     >>> abs(calculated_value - text_book_value) < .01
177 |     True
178 |     """
179 | 
180 |     deflater = numpy.exp(-r * t)
181 |     N_of_minus_d1 = N(-d1(F, K, t, r, sigma))
182 |     N_of_minus_d2 = N(-d2(F, K, t, r, sigma))
183 | 
184 |     return deflater * (-F * N_of_minus_d1 + K * N_of_minus_d2)
185 | 
186 | 
187 | def black(flag, F, K, t, r, sigma):
188 |     """Calculate the (discounted) Black option price.
189 | 
190 |     :param F: underlying futures price
191 |     :type F: float
192 |     :param K: strike price
193 |     :type K: float
194 |     :param sigma: annualized standard deviation, or volatility
195 |     :type sigma: float
196 |     :param t: time to expiration in years
197 |     :type t: float
198 | 
199 |     >>> F = 100
200 |     >>> K = 100
201 |     >>> sigma = .2
202 |     >>> flag = 'c'
203 |     >>> r = .02
204 |     >>> t = .5
205 | 
206 |     >>> expected = 5.5811067246048118
207 |     >>> actual = black(flag, F, K, t, r, sigma)
208 |     >>> abs(expected - actual) < 1e-12
209 |     True
210 |     """
211 | 
212 |     if flag == 'c':
213 |         return black_call(F, K, t, r, sigma)
214 |     elif flag == 'p':
215 |         return black_put(F, K, t, r, sigma)
216 |     else:
217 |         raise Exception("flag '{}' is invalid.".format(flag))
218 | 
219 | 
220 | if __name__ == "__main__":
221 |     from py_vollib.helpers.doctest_helper import run_doctest
222 |     run_doctest()
223 | 


--------------------------------------------------------------------------------
/py_vollib/ref_python/black/greeks/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/py_vollib/ref_python/black/greeks/__init__.py


--------------------------------------------------------------------------------
/py_vollib/ref_python/black/greeks/numerical.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | """
  4 | py_vollib.ref_python.black.greeks.numerical
  5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  6 | 
  7 | A library for option pricing, implied volatility, and
  8 | greek calculation.  py_vollib is based on lets_be_rational,
  9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
 10 | described below.
 11 | 
 12 | :copyright: © 2017 Gammon Capital LLC
 13 | :license: MIT, see LICENSE for more details.
 14 | 
 15 | py_vollib.ref_python is a pure python version of py_vollib without any dependence on LetsBeRational. It is provided purely as a reference implementation for sanity checking. It is not recommended for industrial use.
 16 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 17 | 
 18 | """
 19 | 
 20 | 
 21 | # -----------------------------------------------------------------------------
 22 | # IMPORTS
 23 | 
 24 | # Standard library imports
 25 | 
 26 | # Related third party imports
 27 | 
 28 | # Local application/library specific imports
 29 | from py_vollib.ref_python.black import black
 30 | from py_vollib.helpers.numerical_greeks import delta as numerical_delta
 31 | from py_vollib.helpers.numerical_greeks import vega as numerical_vega
 32 | from py_vollib.helpers.numerical_greeks import theta as numerical_theta
 33 | from py_vollib.helpers.numerical_greeks import rho as numerical_rho
 34 | from py_vollib.helpers.numerical_greeks import gamma as numerical_gamma
 35 | from py_vollib.ref_python.black.greeks.analytical import gamma as agamma
 36 | from py_vollib.ref_python.black.greeks.analytical import delta as adelta
 37 | from py_vollib.ref_python.black.greeks.analytical import vega as avega
 38 | from py_vollib.ref_python.black.greeks.analytical import rho as arho
 39 | from py_vollib.ref_python.black.greeks.analytical import theta as atheta
 40 | 
 41 | 
 42 | f = lambda flag, F, K, t, r, sigma, b: black(flag, F, K, t, r, sigma)
 43 | 
 44 | 
 45 | def delta(flag, F, K, t, r, sigma):
 46 |     """Returns the Black delta of an option.
 47 | 
 48 |     :param flag: 'c' or 'p' for call or put.
 49 |     :type flag: str
 50 |     :param F: underlying futures price
 51 |     :type F: float
 52 |     :param K: strike price
 53 |     :type K: float
 54 |     :param t: time to expiration in years
 55 |     :type t: float
 56 |     :param r: annual risk-free interest rate
 57 |     :type r: float
 58 |     :param sigma: volatility
 59 |     :type sigma: float
 60 | 
 61 |     :returns:  float 
 62 |     """
 63 | 
 64 |     b = 0
 65 | 
 66 |     return numerical_delta(flag, F, K, t, r, sigma, b, f)
 67 | 
 68 | 
 69 | def theta(flag, F, K, t, r, sigma):
 70 |     """Returns the Black theta of an option.
 71 | 
 72 |     :param flag: 'c' or 'p' for call or put.
 73 |     :type flag: str
 74 |     :param F: underlying futures price
 75 |     :type F: float
 76 |     :param K: strike price
 77 |     :type K: float
 78 |     :param t: time to expiration in years
 79 |     :type t: float
 80 |     :param r: annual risk-free interest rate
 81 |     :type r: float
 82 |     :param sigma: volatility
 83 |     :type sigma: float
 84 | 
 85 |     :returns:  float 
 86 |     """
 87 | 
 88 |     b = 0
 89 | 
 90 |     return numerical_theta(flag, F, K, t, r, sigma, b, f)
 91 | 
 92 | 
 93 | def vega(flag, F, K, t, r, sigma):
 94 |     """Returns the Black vega of an option.
 95 | 
 96 |     :param flag: 'c' or 'p' for call or put.
 97 |     :type flag: str
 98 |     :param F: underlying futures price
 99 |     :type F: float
100 |     :param K: strike price
101 |     :type K: float
102 |     :param t: time to expiration in years
103 |     :type t: float
104 |     :param r: annual risk-free interest rate
105 |     :type r: float
106 |     :param sigma: volatility
107 |     :type sigma: float
108 | 
109 |     :returns:  float 
110 |     """
111 | 
112 |     b = 0
113 | 
114 |     return numerical_vega(flag, F, K, t, r, sigma, b, f)
115 | 
116 | 
117 | def rho(flag, F, K, t, r, sigma):
118 |     """Returns the Black rho of an option.
119 | 
120 |     :param flag: 'c' or 'p' for call or put.
121 |     :type flag: str
122 |     :param F: underlying futures price
123 |     :type F: float
124 |     :param K: strike price
125 |     :type K: float
126 |     :param t: time to expiration in years
127 |     :type t: float
128 |     :param r: annual risk-free interest rate
129 |     :type r: float
130 |     :param sigma: volatility
131 |     :type sigma: float
132 | 
133 |     :returns:  float 
134 |     """
135 | 
136 |     b = 0
137 | 
138 |     return numerical_rho(flag, F, K, t, r, sigma, b, f)
139 | 
140 | 
141 | def gamma(flag, F, K, t, r, sigma):
142 |     """Returns the Black gamma of an option.
143 | 
144 |     :param flag: 'c' or 'p' for call or put.
145 |     :type flag: str
146 |     :param F: underlying futures price
147 |     :type F: float
148 |     :param K: strike price
149 |     :type K: float
150 |     :param t: time to expiration in years
151 |     :type t: float
152 |     :param r: annual risk-free interest rate
153 |     :type r: float
154 |     :param sigma: volatility
155 |     :type sigma: float
156 | 
157 |     :returns:  float 
158 |     """
159 | 
160 |     b = 0
161 | 
162 |     return numerical_gamma(flag, F, K, t, r, sigma, b, f)
163 | 
164 | 
165 | def test():
166 |     '''Tests by comparing the analytical and numerical greek values.
167 | 
168 |     >>> S =  49
169 |     >>> K = 50 
170 |     >>> r = .05
171 |     >>> t = 0.3846
172 |     >>> sigma = 0.2
173 |     >>> flag = 'c'
174 | 
175 |     >>> epsilon = .0001
176 | 
177 |     >>> v1 = delta(flag, S, K, t, r, sigma)
178 |     >>> v2 = adelta(flag, S, K, t, r, sigma)
179 |     >>> abs(v1-v2)<epsilon
180 |     True
181 | 
182 |     >>> v1 = gamma(flag, S, K, t, r, sigma)
183 |     >>> v2 = agamma(flag, S, K, t, r, sigma)
184 |     >>> abs(v1-v2)<epsilon
185 |     True
186 | 
187 |     >>> v1 = rho(flag, S, K, t, r, sigma)
188 |     >>> v2 = arho(flag, S, K, t, r, sigma)
189 |     >>> abs(v1-v2)<epsilon
190 |     True
191 | 
192 |     >>> v1 = vega(flag, S, K, t, r, sigma)
193 |     >>> v2 = avega(flag, S, K, t, r, sigma)
194 |     >>> abs(v1-v2)<epsilon
195 |     True
196 | 
197 |     >>> v1 = theta(flag, S, K, t, r, sigma)
198 |     >>> v2 = atheta(flag, S, K, t, r, sigma)
199 |     >>> abs(v1-v2)<epsilon
200 |     True
201 |     '''
202 | 
203 |     pass
204 | 
205 | 
206 | if __name__ == "__main__":
207 |     from py_vollib.helpers.doctest_helper import run_doctest
208 |     run_doctest()
209 | 


--------------------------------------------------------------------------------
/py_vollib/ref_python/black/implied_volatility.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | """
  4 | py_vollib.ref_python.black.implied_volatility
  5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  6 | 
  7 | A library for option pricing, implied volatility, and
  8 | greek calculation.  py_vollib is based on lets_be_rational,
  9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
 10 | described below.
 11 | 
 12 | :copyright: © 2017 Gammon Capital LLC
 13 | :license: MIT, see LICENSE for more details.
 14 | 
 15 | py_vollib.ref_python is a pure python version of py_vollib without any dependence on LetsBeRational. It is provided purely as a reference implementation for sanity checking. It is not recommended for industrial use.
 16 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 17 | 
 18 | """
 19 | 
 20 | 
 21 | # -----------------------------------------------------------------------------
 22 | # IMPORTS
 23 | 
 24 | # Standard library imports
 25 | 
 26 | # Related third party imports
 27 | from scipy.optimize import brentq
 28 | 
 29 | # Local application/library specific imports
 30 | from py_vollib.ref_python.black import black
 31 | 
 32 | 
 33 | # -----------------------------------------------------------------------------
 34 | # FUNCTIONS - IMPLIED VOLATILITY
 35 | 
 36 | def implied_volatility(price, F, K, r, t, flag):
 37 |     """Returns the Black delta of an option.
 38 | 
 39 |     :param price:
 40 |     :type price: float
 41 |     :param F: underlying futures price
 42 |     :type F: float
 43 |     :param K: strike price
 44 |     :type K: float
 45 |     :param r: annual risk-free interest rate
 46 |     :type r: float
 47 |     :param t: time to expiration in years
 48 |     :type t: float
 49 |     :param flag: 'c' or 'p' for call or put.
 50 |     :type flag: str
 51 | 
 52 |     :returns:  float
 53 | 
 54 |     >>> F = 101.0
 55 |     >>> K = 102.0
 56 |     >>> t = .5
 57 |     >>> r = .01
 58 |     >>> flag = 'p'
 59 |     >>> sigma_in = 0.2
 60 | 
 61 |     >>> price = black(flag, F, K, t, r, sigma_in)
 62 |     >>> expected_price = 6.20451158097
 63 |     >>> abs(expected_price - price) < 0.00001
 64 |     True
 65 | 
 66 |     >>> sigma_out = implied_volatility(price, F, K, r, t, flag)
 67 |     >>> sigma_in == sigma_out or abs(sigma_in - sigma_out) < 0.00001
 68 |     True
 69 | 
 70 |     >>> F = 100
 71 |     >>> K = 100
 72 |     >>> sigma = .2
 73 |     >>> flag = 'c'
 74 |     >>> t = .5
 75 |     >>> r = .02
 76 | 
 77 |     >>> discounted_call_price = black(flag, F, K, t, r, sigma)
 78 |     >>> iv = implied_volatility(discounted_call_price, F, K, r, t, flag)
 79 | 
 80 |     >>> expected_discounted_call_price = 5.5811067246
 81 |     >>> expected_iv = 0.2
 82 |     >>> abs(expected_discounted_call_price - discounted_call_price) < 0.00001
 83 |     True
 84 |     >>> abs(expected_iv - iv) < 0.00001
 85 |     True
 86 |     """
 87 | 
 88 |     f = lambda sigma: price - black(flag, F, K, t, r, sigma)
 89 | 
 90 |     return brentq(
 91 |         f,
 92 |         a=1e-12,
 93 |         b=100,
 94 |         xtol=1e-15,
 95 |         rtol=1e-15,
 96 |         maxiter=1000,
 97 |         full_output=False
 98 |     )
 99 | 
100 | 
101 | if __name__ == "__main__":
102 |     from py_vollib.helpers.doctest_helper import run_doctest
103 |     run_doctest()
104 | 


--------------------------------------------------------------------------------
/py_vollib/ref_python/black_scholes/__init__.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | """
  4 | py_vollib.ref_python.black_scholes
  5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  6 | 
  7 | A library for option pricing, implied volatility, and
  8 | greek calculation.  py_vollib is based on lets_be_rational,
  9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
 10 | described below.
 11 | 
 12 | :copyright: © 2017 Gammon Capital LLC
 13 | :license: MIT, see LICENSE for more details.
 14 | 
 15 | py_vollib.ref_python is a pure python version of py_vollib without any dependence on LetsBeRational. It is provided purely as a reference implementation for sanity checking. It is not recommended for industrial use.
 16 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 17 | 
 18 | """
 19 | 
 20 | 
 21 | # -----------------------------------------------------------------------------
 22 | # IMPORTS
 23 | 
 24 | # Standard library imports
 25 | from __future__ import division
 26 | 
 27 | # Related third party imports
 28 | import numpy
 29 | from scipy.stats import norm
 30 | 
 31 | # Local application/library specific imports
 32 | 
 33 | 
 34 | N = norm.cdf
 35 | 
 36 | 
 37 | # -----------------------------------------------------------------------------
 38 | # FUNCTIONS - REFERENCE PYTHON IMPLEMENTATION, FOR COMPARISON
 39 | 
 40 | def d1(S, K, t, r, sigma):  # see Hull, page 292
 41 |     """Calculate the d1 component of the Black-Scholes PDE.
 42 | 
 43 |     :param S: underlying asset price
 44 |     :type S: float
 45 |     :param K: strike price
 46 |     :type K: float
 47 |     :param sigma: annualized standard deviation, or volatility
 48 |     :type sigma: float
 49 |     :param t: time to expiration in years
 50 |     :type t: float
 51 |     :param r: risk-free interest rate
 52 |     :type r: float
 53 | 
 54 |     John C. Hull, "Options, Futures and Other Derivatives,"
 55 |     7th edition, Example 13.6, page 294
 56 | 
 57 |     >>> S = 42
 58 |     >>> K = 40
 59 |     >>> r = .10
 60 |     >>> sigma = .20
 61 |     >>> t = 0.5
 62 |     >>> calculated_d1 = d1(S,K,t,r,sigma)
 63 |     >>> text_book_d1 = 0.7693
 64 |     >>> abs(calculated_d1 - text_book_d1) < 0.0001
 65 |     True
 66 |     """
 67 | 
 68 |     sigma_squared = sigma * sigma
 69 |     numerator = numpy.log(S / float(K)) + (r + sigma_squared / 2.) * t
 70 |     denominator = sigma * numpy.sqrt(t)
 71 | 
 72 |     if not denominator:
 73 |         print ('')
 74 |     return numerator / denominator
 75 | 
 76 | 
 77 | def d2(S, K, t, r, sigma):  # see Hull, page 292
 78 |     """Calculate the d2 component of the Black-Scholes PDE.
 79 | 
 80 |     :param S: underlying asset price
 81 |     :type S: float
 82 |     :param K: strike price
 83 |     :type K: float
 84 |     :param sigma: annualized standard deviation, or volatility
 85 |     :type sigma: float
 86 |     :param t: time to expiration in years
 87 |     :type t: float
 88 |     :param r: risk-free interest rate
 89 |     :type r: float
 90 | 
 91 |     John C. Hull, "Options, Futures and Other Derivatives,"
 92 |     7th edition, Example 13.6, page 294
 93 | 
 94 |     >>> S = 42
 95 |     >>> K = 40
 96 |     >>> r = .10
 97 |     >>> sigma = .20
 98 |     >>> t = 0.5
 99 |     >>> calculated_d2 = d2(S,K,t,r,sigma) #0.627841271869
100 |     >>> text_book_d2 = 0.6278
101 |     >>> abs(calculated_d2 - text_book_d2) < 0.0001
102 |     True
103 |     """
104 | 
105 |     return d1(S, K, t, r, sigma) - sigma * numpy.sqrt(t)
106 | 
107 | 
108 | def black_scholes(flag, S, K, t, r, sigma):
109 |     """Return the Black-Scholes option price implemented in
110 |         python (for reference).
111 | 
112 |     :param S: underlying asset price
113 |     :type S: float
114 |     :param K: strike price
115 |     :type K: float
116 |     :param sigma: annualized standard deviation, or volatility
117 |     :type sigma: float
118 |     :param t: time to expiration in years
119 |     :type t: float
120 |     :param r: risk-free interest rate
121 |     :type r: float
122 |     :param flag: 'c' or 'p' for call or put.
123 |     :type flag: str
124 | 
125 |     >>> S,K,t,r,sigma = 60,65,.25,.08,.3
126 |     >>> expected = 2.13336844492
127 |     >>> actual = black_scholes('c',S,K,t,r,sigma)
128 |     >>> abs(expected-actual) < 1e-11
129 |     True
130 |     """
131 | 
132 |     e_to_the_minus_rt = numpy.exp(-r * t)
133 |     D1 = d1(S, K, t, r, sigma)
134 |     D2 = d2(S, K, t, r, sigma)
135 |     if flag == 'c':
136 |         return S * N(D1) - K * e_to_the_minus_rt * N(D2)
137 |     else:
138 |         return - S * N(-D1) + K * e_to_the_minus_rt * N(-D2)
139 | 
140 | 
141 | if __name__ == "__main__":
142 |     from py_vollib.helpers.doctest_helper import run_doctest
143 |     run_doctest()
144 | 


--------------------------------------------------------------------------------
/py_vollib/ref_python/black_scholes/greeks/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/py_vollib/ref_python/black_scholes/greeks/__init__.py


--------------------------------------------------------------------------------
/py_vollib/ref_python/black_scholes/implied_volatility.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | py_vollib.ref_python.black_scholes.implied_volatility
 5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 6 | 
 7 | A library for option pricing, implied volatility, and
 8 | greek calculation.  py_vollib is based on lets_be_rational,
 9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
10 | described below.
11 | 
12 | :copyright: © 2017 Gammon Capital LLC
13 | :license: MIT, see LICENSE for more details.
14 | 
15 | py_vollib.ref_python is a pure python version of py_vollib without any dependence on LetsBeRational. It is provided purely as a reference implementation for sanity checking. It is not recommended for industrial use.
16 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
17 | 
18 | """
19 | 
20 | 
21 | # -----------------------------------------------------------------------------
22 | # IMPORTS
23 | 
24 | # Standard library imports
25 | 
26 | # Related third party imports
27 | from scipy.optimize import brentq
28 | 
29 | # Local application/library specific imports
30 | from py_vollib.ref_python.black_scholes import black_scholes
31 | 
32 | 
33 | # -----------------------------------------------------------------------------
34 | # FUNCTIONS
35 | 
36 | def implied_volatility(price, S, K, t, r, flag):
37 |     """Calculate the Black-Scholes implied volatility.
38 | 
39 |     :param price: the Black-Scholes option price
40 |     :type price: float
41 |     :param S: underlying asset price
42 |     :type S: float
43 |     :param K: strike price
44 |     :type K: float
45 |     :param t: time to expiration in years
46 |     :type t: float
47 |     :param r: risk-free interest rate
48 |     :type r: float
49 |     :param flag: 'c' or 'p' for call or put.
50 |     :type flag: str
51 | 
52 |     >>> S = 100
53 |     >>> K = 100
54 |     >>> sigma = .2
55 |     >>> r = .01
56 |     >>> flag = 'c'
57 |     >>> t = .5
58 | 
59 |     >>> price = black_scholes(flag, S, K, t, r, sigma)
60 |     >>> iv = implied_volatility(price, S, K, t, r, flag)
61 | 
62 |     >>> expected_price = 5.87602423383
63 |     >>> expected_iv = 0.2
64 |     
65 |     >>> abs(expected_price - price) < 0.00001
66 |     True
67 |     >>> abs(expected_iv - iv) < 0.01
68 |     True
69 | 
70 |     >>> sigma = 0.3
71 |     >>> S, K, t, r, flag = 100.0, 1000.0, 0.5, 0.05, 'p'
72 |     >>> price = black_scholes(flag, S, K, t, r, sigma)
73 |     >>> print (price)
74 |     875.309912028
75 |     >>> iv = implied_volatility(price, S, K, t, r, flag)
76 | 
77 |     >>> print (round(iv, 1))
78 |     0.0
79 |     """
80 | 
81 |     f = lambda sigma: price - black_scholes(flag, S, K, t, r, sigma)
82 | 
83 |     return brentq(
84 |         f,
85 |         a=1e-12,
86 |         b=100,
87 |         xtol=1e-15,
88 |         rtol=1e-15,
89 |         maxiter=1000,
90 |         full_output=False
91 |     )
92 | 
93 | 
94 | if __name__ == "__main__":
95 |     from py_vollib.helpers.doctest_helper import run_doctest
96 |     run_doctest()
97 | 


--------------------------------------------------------------------------------
/py_vollib/ref_python/black_scholes_merton/__init__.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | """
  4 | py_vollib.ref_python.black_scholes_merton
  5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  6 | 
  7 | A library for option pricing, implied volatility, and
  8 | greek calculation.  py_vollib is based on lets_be_rational,
  9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
 10 | described below.
 11 | 
 12 | :copyright: © 2017 Gammon Capital LLC
 13 | :license: MIT, see LICENSE for more details.
 14 | 
 15 | py_vollib.ref_python is a pure python version of py_vollib without any dependence on LetsBeRational. It is provided purely as a reference implementation for sanity checking. It is not recommended for industrial use.
 16 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 17 | 
 18 | """
 19 | 
 20 | 
 21 | # -----------------------------------------------------------------------------
 22 | # IMPORTS
 23 | 
 24 | # Standard library imports
 25 | from __future__ import division
 26 | 
 27 | # Related third party imports
 28 | import numpy
 29 | from scipy.stats import norm
 30 | 
 31 | # Local application/library specific imports
 32 | 
 33 | 
 34 | N = norm.cdf
 35 | 
 36 | 
 37 | # -----------------------------------------------------------------------------
 38 | # FUNCTIONS, FOR REFERENCE AND TESTING
 39 | 
 40 | def d1(S, K, t, r, sigma, q):
 41 |     """Calculate the d1 component of the Black-Scholes-Merton PDE.
 42 | 
 43 |     :param S: underlying asset price
 44 |     :type S: float
 45 |     :param K: strike price
 46 |     :type K: float
 47 |     :param sigma: annualized standard deviation, or volatility
 48 |     :type sigma: float
 49 |     :param t: time to expiration in years
 50 |     :type t: float
 51 |     :param r: risk-free interest rate
 52 |     :type r: float
 53 |     :param q: annualized continuous dividend rate
 54 |     :type q: float
 55 | 
 56 |     From Espen Haug, The Complete Guide To Option Pricing Formulas
 57 |     Page 4
 58 | 
 59 |     >>> S=100
 60 |     >>> K=95
 61 |     >>> q=.05
 62 |     >>> t = 0.5
 63 |     >>> r = 0.1
 64 |     >>> sigma = 0.2
 65 | 
 66 |     >>> d1_published_value = 0.6102
 67 |     >>> d1_calc = d1(S,K,t,r,sigma,q)
 68 |     >>> abs(d1_published_value - d1_calc) < 0.0001
 69 |     True
 70 |     """
 71 | 
 72 |     numerator = numpy.log(S / float(K)) + ((r - q) + sigma * sigma / 2.0) * t
 73 |     denominator = sigma * numpy.sqrt(t)
 74 |     return numerator / denominator
 75 | 
 76 | 
 77 | def d2(S, K, t, r, sigma, q):
 78 |     """Calculate the d2 component of the Black-Scholes-Merton PDE.
 79 | 
 80 |     :param S: underlying asset price
 81 |     :type S: float
 82 |     :param K: strike price
 83 |     :type K: float
 84 |     :param sigma: annualized standard deviation, or volatility
 85 |     :type sigma: float
 86 |     :param t: time to expiration in years
 87 |     :type t: float
 88 |     :param r: risk-free interest rate
 89 |     :type r: float
 90 |     :param q: annualized continuous dividend rate
 91 |     :type q: float
 92 | 
 93 |     From Espen Haug, The Complete Guide To Option Pricing Formulas
 94 |     Page 4
 95 | 
 96 |     >>> S=100
 97 |     >>> K=95
 98 |     >>> q=.05
 99 |     >>> t = 0.5
100 |     >>> r = 0.1
101 |     >>> sigma = 0.2
102 | 
103 |     >>> d2_published_value = 0.4688
104 |     >>> d2_calc = d2(S,K,t,r,sigma,q)
105 |     >>> abs(d2_published_value - d2_calc) < 0.0001
106 |     True
107 |     """
108 | 
109 |     return d1(S, K, t, r, sigma, q) - sigma * numpy.sqrt(t)
110 | 
111 | 
112 | def bsm_call(S, K, t, r, sigma, q):
113 |     """Return the Black-Scholes-Merton call price
114 |     implemented in python (for reference).
115 | 
116 |     :param S: underlying asset price
117 |     :type S: float
118 |     :param K: strike price
119 |     :type K: float
120 |     :param sigma: annualized standard deviation, or volatility
121 |     :type sigma: float
122 |     :param t: time to expiration in years
123 |     :type t: float
124 |     :param r: risk-free interest rate
125 |     :type r: float
126 |     :param q: annualized continuous dividend rate
127 |     :type q: float
128 |     """
129 | 
130 |     D1 = d1(S, K, t, r, sigma, q)
131 |     D2 = d2(S, K, t, r, sigma, q)
132 | 
133 |     return S * numpy.exp(-q * t) * N(D1) - K * numpy.exp(-r * t) * N(D2)
134 | 
135 | 
136 | def bsm_put(S, K, t, r, sigma, q):
137 |     """Return the Black-Scholes-Merton put price
138 |     implemented in python (for reference).
139 | 
140 |     :param S: underlying asset price
141 |     :type S: float
142 |     :param K: strike price
143 |     :type K: float
144 |     :param sigma: annualized standard deviation, or volatility
145 |     :type sigma: float
146 |     :param t: time to expiration in years
147 |     :type t: float
148 |     :param r: risk-free interest rate
149 |     :type r: float
150 |     :param q: annualized continuous dividend rate
151 |     :type q: float
152 | 
153 |     From Espen Haug, The Complete Guide To Option Pricing Formulas
154 |     Page 4
155 | 
156 |     >>> S=100
157 |     >>> K=95
158 |     >>> q=.05
159 |     >>> t = 0.5
160 |     >>> r = 0.1
161 |     >>> sigma = 0.2
162 | 
163 |     >>> p_published_value = 2.4648
164 |     >>> p_calc = bsm_put(S, K, t, r, sigma, q)
165 |     >>> abs(p_published_value - p_calc) < 0.0001
166 |     True
167 |     """
168 | 
169 |     D1 = d1(S, K, t, r, sigma, q)
170 |     D2 = d2(S, K, t, r, sigma, q)
171 |     return K * numpy.exp(-r * t) * N(-D2) - S * numpy.exp(-q * t) * N(-D1)
172 | 
173 | 
174 | def black_scholes_merton(flag, S, K, t, r, sigma, q):
175 |     """Return the Black-Scholes-Merton call price implemented in
176 |     python (for reference).
177 | 
178 |     :param S: underlying asset price
179 |     :type S: float
180 |     :param K: strike price
181 |     :type K: float
182 |     :param sigma: annualized standard deviation, or volatility
183 |     :type sigma: float
184 |     :param t: time to expiration in years
185 |     :type t: float
186 |     :param r: risk-free interest rate
187 |     :type r: float
188 |     :param q: annualized continuous dividend rate
189 |     :type q: float
190 |     :param flag: 'c' or 'p' for call or put.
191 |     :type flag: str
192 | 
193 |     From Espen Haug, The Complete Guide To Option Pricing Formulas
194 |     Page 4
195 | 
196 |     >>> S=100
197 |     >>> K=95
198 |     >>> q=.05
199 |     >>> t = 0.5
200 |     >>> r = 0.1
201 |     >>> sigma = 0.2
202 | 
203 |     >>> p_published_value = 2.4648
204 |     >>> p_calc = black_scholes_merton('p', S, K, t, r, sigma, q)
205 |     >>> abs(p_published_value - p_calc) < 0.0001
206 |     True
207 |     """
208 | 
209 |     if flag == 'c':
210 |         return bsm_call(S, K, t, r, sigma, q)
211 |     else:
212 |         return bsm_put(S, K, t, r, sigma, q)
213 | 
214 | 
215 | if __name__ == "__main__":
216 |     from py_vollib.helpers.doctest_helper import run_doctest
217 |     run_doctest()
218 | 


--------------------------------------------------------------------------------
/py_vollib/ref_python/black_scholes_merton/greeks/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/py_vollib/ref_python/black_scholes_merton/greeks/__init__.py


--------------------------------------------------------------------------------
/py_vollib/ref_python/black_scholes_merton/greeks/numerical.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | """
  4 | py_vollib.ref_python.black_scholes_merton.greeks.numerical
  5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  6 | 
  7 | A library for option pricing, implied volatility, and
  8 | greek calculation.  py_vollib is based on lets_be_rational,
  9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
 10 | described below.
 11 | 
 12 | :copyright: © 2017 Gammon Capital LLC
 13 | :license: MIT, see LICENSE for more details.
 14 | 
 15 | py_vollib.ref_python is a pure python version of py_vollib without any dependence on LetsBeRational. It is provided purely as a reference implementation for sanity checking. It is not recommended for industrial use.
 16 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 17 | 
 18 | """
 19 | 
 20 | 
 21 | # -----------------------------------------------------------------------------
 22 | # IMPORTS
 23 | 
 24 | # Standard library imports
 25 | 
 26 | # Related third party imports
 27 | 
 28 | # Local application/library specific imports
 29 | from py_vollib.ref_python.black_scholes_merton import black_scholes_merton
 30 | from py_vollib.helpers.numerical_greeks import delta as numerical_delta
 31 | from py_vollib.helpers.numerical_greeks import vega as numerical_vega
 32 | from py_vollib.helpers.numerical_greeks import theta as numerical_theta
 33 | from py_vollib.helpers.numerical_greeks import rho as numerical_rho
 34 | from py_vollib.helpers.numerical_greeks import gamma as numerical_gamma
 35 | from py_vollib.ref_python.black_scholes_merton.greeks.analytical import gamma as agamma
 36 | from py_vollib.ref_python.black_scholes_merton.greeks.analytical import delta as adelta
 37 | from py_vollib.ref_python.black_scholes_merton.greeks.analytical import vega as avega
 38 | from py_vollib.ref_python.black_scholes_merton.greeks.analytical import rho as arho
 39 | from py_vollib.ref_python.black_scholes_merton.greeks.analytical import theta as atheta
 40 | 
 41 | 
 42 | # -----------------------------------------------------------------------------
 43 | # FUNCTIONS - NUMERICAL GREEK CALCULATION
 44 | 
 45 | f = lambda flag, S, K, t, r, sigma, b: black_scholes_merton(flag, S, K, t, r, sigma, r-b)
 46 | 
 47 | 
 48 | def delta(flag, S, K, t, r, sigma, q):
 49 |     """Returns the Black-Scholes-Merton delta of an option.
 50 | 
 51 |     :param flag: 'c' or 'p' for call or put.
 52 |     :type flag: str
 53 |     :param S: underlying asset price
 54 |     :type S: float
 55 |     :param K: strike price
 56 |     :type K: float
 57 |     :param t: time to expiration in years
 58 |     :type t: float
 59 |     :param r: annual risk-free interest rate
 60 |     :type r: float
 61 |     :param sigma: volatility
 62 |     :type sigma: float
 63 |     :param q: annualized continuous dividend yield
 64 |     :type q: float
 65 | 
 66 |     :returns:  float
 67 |     """
 68 | 
 69 |     return numerical_delta(flag, S, K, t, r, sigma, r-q, f)
 70 | 
 71 | 
 72 | def theta(flag, S, K, t, r, sigma, q):
 73 |     """Returns the Black-Scholes-Merton theta of an option.
 74 | 
 75 |     :param flag: 'c' or 'p' for call or put.
 76 |     :type flag: str
 77 |     :param S: underlying asset price
 78 |     :type S: float
 79 |     :param K: strike price
 80 |     :type K: float
 81 |     :param t: time to expiration in years
 82 |     :type t: float
 83 |     :param r: annual risk-free interest rate
 84 |     :type r: float
 85 |     :param sigma: volatility
 86 |     :type sigma: float
 87 |     :param q: annualized continuous dividend yield
 88 |     :type q: float
 89 | 
 90 |     :returns:  float
 91 |     """
 92 | 
 93 |     return numerical_theta(flag, S, K, t, r, sigma, r-q, f)
 94 | 
 95 | 
 96 | def vega(flag, S, K, t, r, sigma, q):
 97 |     """Returns the Black-Scholes-Merton vega of an option.
 98 | 
 99 |     :param flag: 'c' or 'p' for call or put.
100 |     :type flag: str
101 |     :param S: underlying asset price
102 |     :type S: float
103 |     :param K: strike price
104 |     :type K: float
105 |     :param t: time to expiration in years
106 |     :type t: float
107 |     :param r: annual risk-free interest rate
108 |     :type r: float
109 |     :param sigma: volatility
110 |     :type sigma: float
111 |     :param q: annualized continuous dividend yield
112 |     :type q: float
113 | 
114 |     :returns:  float
115 |     """
116 |     return numerical_vega(flag, S, K, t, r, sigma, r-q, f)
117 | 
118 | 
119 | def rho(flag, S, K, t, r, sigma, q):
120 |     """Returns the Black-Scholes-Merton rho of an option.
121 | 
122 |     :param flag: 'c' or 'p' for call or put.
123 |     :type flag: str
124 |     :param S: underlying asset price
125 |     :type S: float
126 |     :param K: strike price
127 |     :type K: float
128 |     :param t: time to expiration in years
129 |     :type t: float
130 |     :param r: annual risk-free interest rate
131 |     :type r: float
132 |     :param sigma: volatility
133 |     :type sigma: float
134 |     :param q: annualized continuous dividend yield
135 |     :type q: float
136 | 
137 |     :returns:  float
138 |     """
139 |     return numerical_rho(flag, S, K, t, r, sigma, r-q, f)
140 | 
141 | 
142 | def gamma(flag, S, K, t, r, sigma, q):
143 |     """Returns the Black-Scholes-Merton gamma of an option.
144 | 
145 |     :param flag: 'c' or 'p' for call or put.
146 |     :type flag: str
147 |     :param S: underlying asset price
148 |     :type S: float
149 |     :param K: strike price
150 |     :type K: float
151 |     :param t: time to expiration in years
152 |     :type t: float
153 |     :param r: annual risk-free interest rate
154 |     :type r: float
155 |     :param sigma: volatility
156 |     :type sigma: float
157 |     :param q: annualized continuous dividend yield
158 |     :type q: float
159 | 
160 |     :returns:  float
161 |     """
162 |     return numerical_gamma(flag, S, K, t, r, sigma, r-q, f)
163 | 
164 | 
165 | def test_analytical_vs_numerical():
166 |     """Test by comparing analytical and numerical values.
167 | 
168 |     >>> S =  49
169 |     >>> K = 50
170 |     >>> r = .05
171 |     >>> q = .05 
172 |     >>> t = 0.3846
173 |     >>> sigma = 0.2
174 |     >>> flag = 'c'
175 | 
176 |     >>> epsilon = .0001
177 | 
178 |     >>> v1 = delta(flag, S, K, t, r, sigma, q)
179 |     >>> v2 = adelta(flag, S, K, t, r, sigma, q)
180 |     >>> abs(v1-v2)<epsilon
181 |     True
182 | 
183 |     >>> v1 = gamma(flag, S, K, t, r, sigma, q)
184 |     >>> v2 = agamma(flag, S, K, t, r, sigma, q)
185 |     >>> abs(v1-v2)<epsilon
186 |     True
187 | 
188 |     >>> v1 = rho(flag, S, K, t, r, sigma, q)
189 |     >>> v2 = arho(flag, S, K, t, r, sigma, q)
190 |     >>> abs(v1-v2)<epsilon
191 |     True
192 | 
193 |     >>> v1 = vega(flag, S, K, t, r, sigma, q)
194 |     >>> v2 = avega(flag, S, K, t, r, sigma, q)
195 |     >>> abs(v1-v2)<epsilon
196 |     True
197 | 
198 |     >>> v1 = theta(flag, S, K, t, r, sigma, q)
199 |     >>> v2 = atheta(flag, S, K, t, r, sigma, q)
200 |     >>> abs(v1-v2)<epsilon
201 |     True
202 |     """
203 | 
204 |     pass
205 | 
206 | 
207 | if __name__ == "__main__":
208 |     from py_vollib.helpers.doctest_helper import run_doctest
209 |     run_doctest()
210 | 


--------------------------------------------------------------------------------
/py_vollib/ref_python/black_scholes_merton/implied_volatility.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | """
 4 | py_vollib.ref_python.black_scholes_merton.implied_volatility
 5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 6 | 
 7 | A library for option pricing, implied volatility, and
 8 | greek calculation.  py_vollib is based on lets_be_rational,
 9 | a Python wrapper for LetsBeRational by Peter Jaeckel as
10 | described below.
11 | 
12 | :copyright: © 2017 Gammon Capital LLC
13 | :license: MIT, see LICENSE for more details.
14 | 
15 | py_vollib.ref_python is a pure python version of py_vollib without any dependence on LetsBeRational. It is provided purely as a reference implementation for sanity checking. It is not recommended for industrial use.
16 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
17 | 
18 | """
19 | 
20 | 
21 | # -----------------------------------------------------------------------------
22 | # IMPORTS
23 | 
24 | # Standard library imports
25 | 
26 | # Related third party imports
27 | from scipy.optimize import brentq
28 | 
29 | # Local application/library specific imports
30 | from py_vollib.ref_python.black_scholes_merton import black_scholes_merton
31 | 
32 | 
33 | # -----------------------------------------------------------------------------
34 | # FUNCTIONS
35 | 
36 | def implied_volatility(price, S, K, t, r, q, flag):
37 |     """Calculate the Black-Scholes-Merton implied volatility.
38 | 
39 |     :param S: underlying asset price
40 |     :type S: float
41 |     :param K: strike price
42 |     :type K: float
43 |     :param sigma: annualized standard deviation, or volatility
44 |     :type sigma: float
45 |     :param t: time to expiration in years
46 |     :type t: float
47 |     :param r: risk-free interest rate
48 |     :type r: float
49 |     :param q: annualized continuous dividend rate
50 |     :type q: float
51 |     :param flag: 'c' or 'p' for call or put.
52 |     :type flag: str
53 | 
54 |     >>> S = 100
55 |     >>> K = 100
56 |     >>> sigma = .2
57 |     >>> r = .01
58 |     >>> flag = 'c'
59 |     >>> t = .5
60 |     >>> q = .02
61 | 
62 |     >>> price = black_scholes_merton(flag, S, K, t, r, sigma, q)
63 |     >>> implied_volatility(price, S, K, t, r, q, flag)
64 |     0.20000000000000018
65 | 
66 |     >>> flac = 'p'
67 |     >>> sigma = 0.3
68 |     >>> price = black_scholes_merton(flag, S, K, t, r, sigma, q)
69 |     >>> price
70 |     8.138101080183894
71 |     >>> implied_volatility(price, S, K, t, r, q, flag)
72 |     0.30000000000000027
73 |     """
74 | 
75 |     f = lambda sigma: price - black_scholes_merton(flag, S, K, t, r, sigma, q)
76 | 
77 |     return brentq(
78 |         f,
79 |         a=1e-12,
80 |         b=100,
81 |         xtol=1e-15,
82 |         rtol=1e-15,
83 |         maxiter=1000,
84 |         full_output=False
85 |     )
86 | 
87 | 
88 | if __name__ == "__main__":
89 |     from py_vollib.helpers.doctest_helper import run_doctest
90 |     run_doctest()
91 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | # encoding: utf-8
 3 | 
 4 | 
 5 | from setuptools import setup, find_packages
 6 | 
 7 | 
 8 | setup(
 9 |     name='py_vollib',
10 |     version='1.0.3',
11 |     description='',
12 |     url='http://vollib.org',
13 |     maintainer='vollib',
14 |     maintainer_email='vollib@gammoncap.com',
15 |     license='MIT',
16 |     install_requires=[
17 |         'py_lets_be_rational',
18 |         'simplejson',
19 |         'numpy',
20 |         'pandas',
21 |         'scipy'
22 |     ],
23 |     packages=find_packages()
24 | )
25 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/tests/__init__.py


--------------------------------------------------------------------------------
/tests/test_all.py:
--------------------------------------------------------------------------------
1 | import pytest
2 | 
3 | 
4 | pytest.main()
5 | 


--------------------------------------------------------------------------------
/tests/test_black_scholes.py:
--------------------------------------------------------------------------------
  1 | # -----------------------------------------------------------------------------
  2 | # IMPORTS
  3 | 
  4 | # Standard library imports
  5 | from __future__ import print_function
  6 | import unittest
  7 | 
  8 | # Related third party imports
  9 | 
 10 | # Local application/library specific imports
 11 | from py_vollib.black_scholes import black_scholes
 12 | from py_vollib.black_scholes.greeks import analytical
 13 | from py_vollib.black_scholes.greeks import numerical
 14 | from py_vollib.black_scholes.implied_volatility import implied_volatility
 15 | from tests.test_utils import IteratorForTestData
 16 | 
 17 | 
 18 | class TestBlackScholesAgainstBenchmarkValues(unittest.TestCase):
 19 |     def setUp(self):
 20 |         self.tdi = IteratorForTestData()
 21 | 
 22 |     def test_prices(self):
 23 |         while self.tdi.has_next():
 24 |             row = self.tdi.next_row()
 25 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 26 |             self.assertAlmostEqual(black_scholes('c', S, K, t, r, sigma), row['bs_call'], delta=0.000001)
 27 |             self.assertAlmostEqual(black_scholes('p', S, K, t, r, sigma), row['bs_put'], delta=0.000001)
 28 | 
 29 |     def test_analytical_delta(self):
 30 |         while self.tdi.has_next():
 31 |             row = self.tdi.next_row()
 32 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 33 |             self.assertAlmostEqual(analytical.delta('c', S, K, t, r, sigma), row['CD'], delta=0.000001)
 34 |             self.assertAlmostEqual(analytical.delta('p', S, K, t, r, sigma), row['PD'], delta=0.000001)
 35 | 
 36 |     def test_analytical_theta(self):
 37 |         while self.tdi.has_next():
 38 |             row = self.tdi.next_row()
 39 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 40 |             self.assertAlmostEqual(analytical.theta('c', S, K, t, r, sigma), row['CT'] / 365.0, delta=0.000001)
 41 |             self.assertAlmostEqual(analytical.theta('p', S, K, t, r, sigma), row['PT'] / 365.0, delta=0.000001)
 42 | 
 43 |     def test_analytical_gamma(self):
 44 |         while self.tdi.has_next():
 45 |             row = self.tdi.next_row()
 46 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 47 |             self.assertAlmostEqual(analytical.gamma('c', S, K, t, r, sigma), row['CG'], delta=0.000001)
 48 |             self.assertAlmostEqual(analytical.gamma('p', S, K, t, r, sigma), row['PG'], delta=0.000001)
 49 | 
 50 |     def test_analytical_vega(self):
 51 |         while self.tdi.has_next():
 52 |             row = self.tdi.next_row()
 53 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 54 |             self.assertAlmostEqual(analytical.vega('c', S, K, t, r, sigma), row['CV'] * .01, delta=0.000001)
 55 |             self.assertAlmostEqual(analytical.vega('p', S, K, t, r, sigma), row['PV'] * .01, delta=0.000001)
 56 | 
 57 |     def test_analytical_rho(self):
 58 |         while self.tdi.has_next():
 59 |             row = self.tdi.next_row()
 60 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 61 |             self.assertAlmostEqual(analytical.rho('c', S, K, t, r, sigma), row['CR'] * 0.01, delta=0.000000001)
 62 |             self.assertAlmostEqual(analytical.rho('p', S, K, t, r, sigma), row['PR'] * 0.01, delta=0.000000001)
 63 | 
 64 |     def test_numerical_delta(self):
 65 |         while self.tdi.has_next():
 66 |             row = self.tdi.next_row()
 67 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 68 |             self.assertAlmostEqual(numerical.delta('c', S, K, t, r, sigma), row['CD'], delta=0.000001)
 69 |             self.assertAlmostEqual(numerical.delta('p', S, K, t, r, sigma), row['PD'], delta=0.000001)
 70 | 
 71 |     def test_numerical_theta(self):
 72 |         while self.tdi.has_next():
 73 |             row = self.tdi.next_row()
 74 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 75 |             self.assertAlmostEqual(numerical.theta('c', S, K, t, r, sigma), row['CT'] / 365.0, delta=1)
 76 |             self.assertAlmostEqual(numerical.theta('p', S, K, t, r, sigma), row['PT'] / 365.0, delta=1)
 77 | 
 78 |     def test_numerical_gamma(self):
 79 |         while self.tdi.has_next():
 80 |             row = self.tdi.next_row()
 81 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 82 |             self.assertAlmostEqual(numerical.gamma('c', S, K, t, r, sigma), row['CG'], delta=0.000001)
 83 |             self.assertAlmostEqual(numerical.gamma('p', S, K, t, r, sigma), row['PG'], delta=0.000001)
 84 | 
 85 |     def test_numerical_vega(self):
 86 |         while self.tdi.has_next():
 87 |             row = self.tdi.next_row()
 88 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 89 |             self.assertAlmostEqual(numerical.vega('c', S, K, t, r, sigma), row['CV'] * 0.01, delta=0.01)
 90 |             self.assertAlmostEqual(numerical.vega('p', S, K, t, r, sigma), row['PV'] * 0.01, delta=0.01)
 91 | 
 92 |     def test_numerical_rho(self):
 93 |         while self.tdi.has_next():
 94 |             row = self.tdi.next_row()
 95 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 96 |             self.assertAlmostEqual(numerical.rho('c', S, K, t, r, sigma), row['CR'] * 0.01, delta=0.001)
 97 |             self.assertAlmostEqual(numerical.rho('p', S, K, t, r, sigma), row['PR'] * 0.01, delta=0.001)
 98 | 
 99 |     def test_implied_volatility(self):
100 |         while self.tdi.has_next():
101 |             row = self.tdi.next_row()
102 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
103 |             C, P = black_scholes('c', S, K, t, r, sigma), black_scholes('p', S, K, t, r, sigma)
104 |             try:
105 |                 iv = implied_volatility(C, S, K, t, r, 'c')
106 |                 self.assertAlmostEqual(sigma, iv, delta=0.0001)
107 |             except:
108 |                 print('could not calculate iv for ', C, S, K, t, r, 'c')
109 |             iv = implied_volatility(P, S, K, t, r, 'p')
110 |             self.assertTrue(iv == 0.0) if iv == 0.0 else self.assertAlmostEqual(sigma, iv, delta=0.001)
111 | 
112 | 
113 | if __name__ == '__main__':
114 |     unittest.main()
115 | 


--------------------------------------------------------------------------------
/tests/test_black_scholes_greeks.py:
--------------------------------------------------------------------------------
 1 | # -----------------------------------------------------------------------------
 2 | # IMPORTS
 3 | 
 4 | # Standard library imports
 5 | from __future__ import print_function
 6 | from itertools import product
 7 | import unittest
 8 | 
 9 | # Related third party imports
10 | import numpy
11 | 
12 | # Local application/library specific imports
13 | from py_vollib.black_scholes.greeks.analytical import delta
14 | from py_vollib.black_scholes.greeks.analytical import gamma
15 | from py_vollib.black_scholes.greeks.analytical import theta
16 | from py_vollib.black_scholes.greeks.analytical import vega
17 | from py_vollib.black_scholes.greeks.analytical import rho
18 | from py_vollib.black_scholes.greeks.numerical import delta as ndelta
19 | from py_vollib.black_scholes.greeks.numerical import gamma as ngamma
20 | from py_vollib.black_scholes.greeks.numerical import theta as ntheta
21 | from py_vollib.black_scholes.greeks.numerical import vega as nvega
22 | from py_vollib.black_scholes.greeks.numerical import rho as nrho
23 | 
24 | 
25 | class TestBSGreeks(unittest.TestCase):
26 |     def setUp(self):
27 |         self.epsilon = 0.001
28 |         self.flags = ['c', 'p']
29 |         self.S = 100
30 |         self.Ks = numpy.linspace(20, 200, 10)
31 |         self.ts = numpy.linspace(0.01, 2, 10)
32 |         self.rs = numpy.linspace(0, 0.2, 10)
33 |         self.sigmas = numpy.linspace(0.1, 0.5, 10)
34 |         self.arg_combinations = list(product(self.flags, [self.S], self.Ks, self.ts, self.rs, self.sigmas))
35 | 
36 |     def diff_mean(self, left, right):
37 |         left_arr = numpy.array(left)
38 |         right_arr = numpy.array(right)
39 |         abs_diff = numpy.abs(left_arr - right_arr)
40 |         return numpy.mean(abs_diff)
41 | 
42 |     def test_theta(self):
43 |         thetas = [theta(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
44 |         nthetas = [ntheta(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
45 |         self.assertTrue(self.diff_mean(thetas, nthetas) < self.epsilon)
46 | 
47 |     def test_delta(self):
48 |         deltas = [delta(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
49 |         ndeltas = [ndelta(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
50 |         self.assertTrue(self.diff_mean(deltas, ndeltas) < self.epsilon)
51 | 
52 |     def test_gamma(self):
53 |         gammas = [gamma(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
54 |         ngammas = [ngamma(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
55 |         self.assertTrue(self.diff_mean(gammas, ngammas) < self.epsilon)
56 | 
57 |     def test_vega(self):
58 |         vegas = [vega(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
59 |         nvegas = [nvega(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
60 |         self.assertTrue(self.diff_mean(vegas, nvegas) < self.epsilon)
61 | 
62 |     def test_rho(self):
63 |         rhos = [rho(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
64 |         nrhos = [nrho(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
65 |         self.assertTrue(self.diff_mean(rhos, nrhos) < self.epsilon)
66 | 
67 | 
68 | if __name__ == '__main__':
69 |     unittest.main()
70 | 


--------------------------------------------------------------------------------
/tests/test_black_scholes_merton.py:
--------------------------------------------------------------------------------
  1 | # -----------------------------------------------------------------------------
  2 | # IMPORTS
  3 | 
  4 | # Standard library imports
  5 | from __future__ import print_function
  6 | import unittest
  7 | 
  8 | # Related third party imports
  9 | 
 10 | # Local application/library specific imports
 11 | from py_vollib.black_scholes_merton import black_scholes_merton
 12 | from py_vollib.black_scholes_merton.implied_volatility import implied_volatility
 13 | from py_vollib.black_scholes_merton.greeks import analytical
 14 | from py_vollib.black_scholes_merton.greeks import numerical
 15 | from tests.test_utils import IteratorForTestData
 16 | 
 17 | 
 18 | q = 0
 19 | 
 20 | 
 21 | class TestBlackScholesMertonAgainstBenchmarkValues(unittest.TestCase):
 22 |     def setUp(self):
 23 |         self.tdi = IteratorForTestData()
 24 | 
 25 |     def test_prices(self):
 26 |         while self.tdi.has_next():
 27 |             row = self.tdi.next_row()
 28 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 29 |             self.assertAlmostEqual(black_scholes_merton('c', S, K, t, r, sigma, q), row['bs_call'], delta=0.000001)
 30 |             self.assertAlmostEqual(black_scholes_merton('p', S, K, t, r, sigma, q), row['bs_put'], delta=0.000001)
 31 | 
 32 |     def test_analytical_delta(self):
 33 |         while self.tdi.has_next():
 34 |             row = self.tdi.next_row()
 35 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 36 |             self.assertAlmostEqual(analytical.delta('c', S, K, t, r, sigma, q), row['CD'], delta=0.000001)
 37 |             self.assertAlmostEqual(analytical.delta('p', S, K, t, r, sigma, q), row['PD'], delta=0.000001)
 38 | 
 39 |     def test_analytical_theta(self):
 40 |         while self.tdi.has_next():
 41 |             row = self.tdi.next_row()
 42 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 43 |             self.assertAlmostEqual(analytical.theta('c', S, K, t, r, sigma, q), row['CT'] / 365.0, delta=0.000001)
 44 |             self.assertAlmostEqual(analytical.theta('p', S, K, t, r, sigma, q), row['PT'] / 365.0, delta=0.000001)
 45 | 
 46 |     def test_analytical_gamma(self):
 47 |         while self.tdi.has_next():
 48 |             row = self.tdi.next_row()
 49 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 50 |             self.assertAlmostEqual(analytical.gamma('c', S, K, t, r, sigma, q), row['CG'], delta=0.000001)
 51 |             self.assertAlmostEqual(analytical.gamma('p', S, K, t, r, sigma, q), row['PG'], delta=0.000001)
 52 | 
 53 |     def test_analytical_vega(self):
 54 |         while self.tdi.has_next():
 55 |             row = self.tdi.next_row()
 56 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 57 |             self.assertAlmostEqual(analytical.vega('c', S, K, t, r, sigma, q), row['CV'] * .01, delta=0.000001)
 58 |             self.assertAlmostEqual(analytical.vega('p', S, K, t, r, sigma, q), row['PV'] * .01, delta=0.000001)
 59 | 
 60 |     def test_analytical_rho(self):
 61 |         while self.tdi.has_next():
 62 |             row = self.tdi.next_row()
 63 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 64 |             self.assertAlmostEqual(analytical.rho('c', S, K, t, r, sigma, q), row['CR'] * 0.01, delta=0.000000001)
 65 |             self.assertAlmostEqual(analytical.rho('p', S, K, t, r, sigma, q), row['PR'] * 0.01, delta=0.000000001)
 66 | 
 67 |     def test_numerical_delta(self):
 68 |         while self.tdi.has_next():
 69 |             row = self.tdi.next_row()
 70 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 71 |             self.assertAlmostEqual(numerical.delta('c', S, K, t, r, sigma, q), row['CD'], delta=0.000001)
 72 |             self.assertAlmostEqual(numerical.delta('p', S, K, t, r, sigma, q), row['PD'], delta=0.000001)
 73 | 
 74 |     def test_numerical_theta(self):
 75 |         while self.tdi.has_next():
 76 |             row = self.tdi.next_row()
 77 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 78 |             self.assertAlmostEqual(numerical.theta('c', S, K, t, r, sigma, q), row['CT'] / 365.0, delta=1)
 79 |             self.assertAlmostEqual(numerical.theta('p', S, K, t, r, sigma, q), row['PT'] / 365.0, delta=1)
 80 | 
 81 |     def test_numerical_gamma(self):
 82 |         while self.tdi.has_next():
 83 |             row = self.tdi.next_row()
 84 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 85 |             self.assertAlmostEqual(numerical.gamma('c', S, K, t, r, sigma, q), row['CG'], delta=0.000001)
 86 |             self.assertAlmostEqual(numerical.gamma('p', S, K, t, r, sigma, q), row['PG'], delta=0.000001)
 87 | 
 88 |     def test_numerical_vega(self):
 89 |         while self.tdi.has_next():
 90 |             row = self.tdi.next_row()
 91 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 92 |             self.assertAlmostEqual(numerical.vega('c', S, K, t, r, sigma, q), row['CV'] * 0.01, delta=0.01)
 93 |             self.assertAlmostEqual(numerical.vega('p', S, K, t, r, sigma, q), row['PV'] * 0.01, delta=0.01)
 94 | 
 95 |     def test_numerical_rho(self):
 96 |         while self.tdi.has_next():
 97 |             row = self.tdi.next_row()
 98 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 99 |             self.assertAlmostEqual(numerical.rho('c', S, K, t, r, sigma, q), row['CR'] * 0.01, delta=0.001)
100 |             self.assertAlmostEqual(numerical.rho('p', S, K, t, r, sigma, q), row['PR'] * 0.01, delta=0.001)
101 | 
102 |     def test_implied_volatility(self):
103 |         while self.tdi.has_next():
104 |             row = self.tdi.next_row()
105 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
106 |             C, P = black_scholes_merton('c', S, K, t, r, sigma, q), black_scholes_merton('p', S, K, t, r, sigma, q)
107 |             try:
108 |                 iv = implied_volatility(C, S, K, t, r, q, 'c')
109 |                 self.assertAlmostEqual(sigma, iv, delta=0.0001)
110 |             except:
111 |                 print('could not calculate iv for ', C, S, K, t, r, 'c')
112 |             iv = implied_volatility(P, S, K, t, r, q, 'p')
113 |             self.assertTrue(iv == 0.0) if iv == 0.0 else self.assertAlmostEqual(sigma, iv, delta=0.001)
114 | 
115 | 
116 | if __name__ == '__main__':
117 |     unittest.main()
118 | 


--------------------------------------------------------------------------------
/tests/test_black_scholes_merton_greeks.py:
--------------------------------------------------------------------------------
 1 | # -----------------------------------------------------------------------------
 2 | # IMPORTS
 3 | 
 4 | # Standard library imports
 5 | from __future__ import print_function
 6 | import unittest
 7 | from itertools import product
 8 | 
 9 | # Related third party imports
10 | import numpy
11 | 
12 | # Local application/library specific imports
13 | from py_vollib.black_scholes_merton.greeks.analytical import delta
14 | from py_vollib.black_scholes_merton.greeks.analytical import gamma
15 | from py_vollib.black_scholes_merton.greeks.analytical import theta
16 | from py_vollib.black_scholes_merton.greeks.analytical import vega
17 | from py_vollib.black_scholes_merton.greeks.analytical import rho
18 | from py_vollib.black_scholes_merton.greeks.numerical import delta as ndelta
19 | from py_vollib.black_scholes_merton.greeks.numerical import gamma as ngamma
20 | from py_vollib.black_scholes_merton.greeks.numerical import theta as ntheta
21 | from py_vollib.black_scholes_merton.greeks.numerical import vega as nvega
22 | from py_vollib.black_scholes_merton.greeks.numerical import rho as nrho
23 | 
24 | 
25 | class TestBSMGreeks(unittest.TestCase):
26 |     def setUp(self):
27 |         self.epsilon = 0.001
28 |         self.flags = ['c', 'p']
29 |         self.S = 100
30 |         self.Ks = numpy.linspace(20, 200, 10)
31 |         self.ts = numpy.linspace(0.01, 2, 10)
32 |         self.rs = numpy.linspace(0, 0.2, 10)
33 |         self.sigmas = numpy.linspace(0.1, 0.5, 10)
34 |         self.q = 0
35 |         self.arg_combinations = list(product(self.flags, [self.S], self.Ks, self.ts, self.rs, self.sigmas, [self.q]))
36 | 
37 |     def diff_mean(self, left, right):
38 |         left_arr = numpy.array(left)
39 |         right_arr = numpy.array(right)
40 |         abs_diff = numpy.abs(left_arr - right_arr)
41 |         return numpy.mean(abs_diff)
42 | 
43 |     def test_theta(self):
44 |         thetas = [theta(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
45 |         nthetas = [ntheta(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
46 |         self.assertTrue(self.diff_mean(thetas, nthetas) < self.epsilon)
47 | 
48 |     def test_delta(self):
49 |         deltas = [delta(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
50 |         ndeltas = [ndelta(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
51 |         self.assertTrue(self.diff_mean(deltas, ndeltas) < self.epsilon)
52 | 
53 |     def test_gamma(self):
54 |         gammas = [gamma(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
55 |         ngammas = [ngamma(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
56 |         self.assertTrue(self.diff_mean(gammas, ngammas) < self.epsilon)
57 | 
58 |     def test_vega(self):
59 |         vegas = [vega(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
60 |         nvegas = [nvega(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
61 |         self.assertTrue(self.diff_mean(vegas, nvegas) < self.epsilon)
62 | 
63 |     def test_rho(self):
64 |         rhos = [rho(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
65 |         nrhos = [nrho(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
66 |         self.assertTrue(self.diff_mean(rhos, nrhos) < self.epsilon)
67 | 
68 | 
69 | if __name__ == '__main__':
70 |     unittest.main()
71 | 


--------------------------------------------------------------------------------
/tests/test_ref_python/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/tests/test_ref_python/__init__.py


--------------------------------------------------------------------------------
/tests/test_ref_python/test_ref_python_black_scholes.py:
--------------------------------------------------------------------------------
  1 | # -----------------------------------------------------------------------------
  2 | # IMPORTS
  3 | 
  4 | # Standard library imports
  5 | from __future__ import print_function
  6 | import unittest
  7 | 
  8 | # Related third party imports
  9 | 
 10 | # Local application/library specific imports
 11 | from py_vollib.ref_python.black_scholes import black_scholes
 12 | from py_vollib.ref_python.black_scholes.implied_volatility import implied_volatility
 13 | from py_vollib.ref_python.black_scholes.greeks import analytical
 14 | from py_vollib.ref_python.black_scholes.greeks import numerical
 15 | from tests.test_utils import IteratorForTestData
 16 | 
 17 | 
 18 | class TestRefPythonBlackScholesAgainstBenchmarkValues(unittest.TestCase):
 19 |     def setUp(self):
 20 |         self.tdi = IteratorForTestData()
 21 | 
 22 |     def test_prices(self):
 23 |         while self.tdi.has_next():
 24 |             row = self.tdi.next_row()
 25 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 26 |             self.assertAlmostEqual(black_scholes('c', S, K, t, r, sigma), row['bs_call'], delta=0.000001)
 27 |             self.assertAlmostEqual(black_scholes('p', S, K, t, r, sigma), row['bs_put'], delta=0.000001)
 28 | 
 29 |     def test_analytical_delta(self):
 30 |         while self.tdi.has_next():
 31 |             row = self.tdi.next_row()
 32 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 33 |             self.assertAlmostEqual(analytical.delta('c', S, K, t, r, sigma), row['CD'], delta=0.000001)
 34 |             self.assertAlmostEqual(analytical.delta('p', S, K, t, r, sigma), row['PD'], delta=0.000001)
 35 | 
 36 |     def test_analytical_theta(self):
 37 |         while self.tdi.has_next():
 38 |             row = self.tdi.next_row()
 39 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 40 |             self.assertAlmostEqual(analytical.theta('c', S, K, t, r, sigma), row['CT'] / 365.0, delta=0.000001)
 41 |             self.assertAlmostEqual(analytical.theta('p', S, K, t, r, sigma), row['PT'] / 365.0, delta=0.000001)
 42 | 
 43 |     def test_analytical_gamma(self):
 44 |         while self.tdi.has_next():
 45 |             row = self.tdi.next_row()
 46 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 47 |             self.assertAlmostEqual(analytical.gamma('c', S, K, t, r, sigma), row['CG'], delta=0.000001)
 48 |             self.assertAlmostEqual(analytical.gamma('p', S, K, t, r, sigma), row['PG'], delta=0.000001)
 49 | 
 50 |     def test_analytical_vega(self):
 51 |         while self.tdi.has_next():
 52 |             row = self.tdi.next_row()
 53 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 54 |             self.assertAlmostEqual(analytical.vega('c', S, K, t, r, sigma), row['CV'] * .01, delta=0.000001)
 55 |             self.assertAlmostEqual(analytical.vega('p', S, K, t, r, sigma), row['PV'] * .01, delta=0.000001)
 56 | 
 57 |     def test_analytical_rho(self):
 58 |         while self.tdi.has_next():
 59 |             row = self.tdi.next_row()
 60 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 61 |             self.assertAlmostEqual(analytical.rho('c', S, K, t, r, sigma), row['CR'] * 0.01, delta=0.000000001)
 62 |             self.assertAlmostEqual(analytical.rho('p', S, K, t, r, sigma), row['PR'] * 0.01, delta=0.000000001)
 63 | 
 64 |     def test_numerical_delta(self):
 65 |         while self.tdi.has_next():
 66 |             row = self.tdi.next_row()
 67 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 68 |             self.assertAlmostEqual(numerical.delta('c', S, K, t, r, sigma), row['CD'], delta=0.000001)
 69 |             self.assertAlmostEqual(numerical.delta('p', S, K, t, r, sigma), row['PD'], delta=0.000001)
 70 | 
 71 |     def test_numerical_theta(self):
 72 |         while self.tdi.has_next():
 73 |             row = self.tdi.next_row()
 74 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 75 |             self.assertAlmostEqual(numerical.theta('c', S, K, t, r, sigma), row['CT'] / 365.0, delta=1)
 76 |             self.assertAlmostEqual(numerical.theta('p', S, K, t, r, sigma), row['PT'] / 365.0, delta=1)
 77 | 
 78 |     def test_numerical_gamma(self):
 79 |         while self.tdi.has_next():
 80 |             row = self.tdi.next_row()
 81 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 82 |             self.assertAlmostEqual(numerical.gamma('c', S, K, t, r, sigma), row['CG'], delta=0.000001)
 83 |             self.assertAlmostEqual(numerical.gamma('p', S, K, t, r, sigma), row['PG'], delta=0.000001)
 84 | 
 85 |     def test_numerical_vega(self):
 86 |         while self.tdi.has_next():
 87 |             row = self.tdi.next_row()
 88 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 89 |             self.assertAlmostEqual(numerical.vega('c', S, K, t, r, sigma), row['CV'] * 0.01, delta=0.01)
 90 |             self.assertAlmostEqual(numerical.vega('p', S, K, t, r, sigma), row['PV'] * 0.01, delta=0.01)
 91 | 
 92 |     def test_numerical_rho(self):
 93 |         while self.tdi.has_next():
 94 |             row = self.tdi.next_row()
 95 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 96 |             self.assertAlmostEqual(numerical.rho('c', S, K, t, r, sigma), row['CR'] * 0.01, delta=0.001)
 97 |             self.assertAlmostEqual(numerical.rho('p', S, K, t, r, sigma), row['PR'] * 0.01, delta=0.001)
 98 | 
 99 |     def test_implied_volatility(self):
100 |         while self.tdi.has_next():
101 |             row = self.tdi.next_row()
102 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
103 |             C, P = black_scholes('c', S, K, t, r, sigma), black_scholes('p', S, K, t, r, sigma)
104 |             try:
105 |                 iv = implied_volatility(C, S, K, t, r, 'c')
106 |                 self.assertAlmostEqual(sigma, iv, delta=0.0001)
107 |             except:
108 |                 print('could not calculate iv for ', C, S, K, t, r, 'c')
109 |             iv = implied_volatility(P, S, K, t, r, 'p')
110 |             self.assertTrue(iv == 1e-12) if iv == 1e-12 else self.assertAlmostEqual(sigma, iv, delta=0.001)
111 | 
112 | 
113 | if __name__ == '__main__':
114 |     unittest.main()
115 | 


--------------------------------------------------------------------------------
/tests/test_ref_python/test_ref_python_black_scholes_greeks.py:
--------------------------------------------------------------------------------
 1 | # -----------------------------------------------------------------------------
 2 | # IMPORTS
 3 | 
 4 | # Standard library imports
 5 | from __future__ import print_function
 6 | import unittest
 7 | from itertools import product
 8 | 
 9 | # Related third party imports
10 | import numpy
11 | 
12 | # Local application/library specific imports
13 | from py_vollib.ref_python.black_scholes.greeks.analytical import delta
14 | from py_vollib.ref_python.black_scholes.greeks.analytical import gamma
15 | from py_vollib.ref_python.black_scholes.greeks.analytical import theta
16 | from py_vollib.ref_python.black_scholes.greeks.analytical import vega
17 | from py_vollib.ref_python.black_scholes.greeks.analytical import rho
18 | from py_vollib.ref_python.black_scholes.greeks.numerical import delta as ndelta
19 | from py_vollib.ref_python.black_scholes.greeks.numerical import gamma as ngamma
20 | from py_vollib.ref_python.black_scholes.greeks.numerical import theta as ntheta
21 | from py_vollib.ref_python.black_scholes.greeks.numerical import vega as nvega
22 | from py_vollib.ref_python.black_scholes.greeks.numerical import rho as nrho
23 | 
24 | 
25 | class TestRefPythonBSGreeks(unittest.TestCase):
26 |     def setUp(self):
27 |         self.epsilon = 0.001
28 |         self.flags = ['c', 'p']
29 |         self.S = 100
30 |         self.Ks = numpy.linspace(20, 200, 10)
31 |         self.ts = numpy.linspace(0.01, 2, 10)
32 |         self.rs = numpy.linspace(0, 0.2, 10)
33 |         self.sigmas = numpy.linspace(0.1, 0.5, 10)
34 |         self.arg_combinations = list(product(self.flags, [self.S], self.Ks, self.ts, self.rs, self.sigmas))
35 | 
36 |     def diff_mean(self, left, right):
37 |         left_arr = numpy.array(left)
38 |         right_arr = numpy.array(right)
39 |         abs_diff = numpy.abs(left_arr - right_arr)
40 |         return numpy.mean(abs_diff)
41 | 
42 |     def test_theta(self):
43 |         thetas = [theta(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
44 |         nthetas = [ntheta(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
45 |         self.assertTrue(self.diff_mean(thetas, nthetas) < self.epsilon)
46 | 
47 |     def test_delta(self):
48 |         deltas = [delta(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
49 |         ndeltas = [ndelta(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
50 |         self.assertTrue(self.diff_mean(deltas, ndeltas) < self.epsilon)
51 | 
52 |     def test_gamma(self):
53 |         gammas = [gamma(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
54 |         ngammas = [ngamma(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
55 |         self.assertTrue(self.diff_mean(gammas, ngammas) < self.epsilon)
56 | 
57 |     def test_vega(self):
58 |         vegas = [vega(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
59 |         nvegas = [nvega(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
60 |         self.assertTrue(self.diff_mean(vegas, nvegas) < self.epsilon)
61 | 
62 |     def test_rho(self):
63 |         rhos = [rho(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
64 |         nrhos = [nrho(flag, S, K, t, r, sigma) for flag, S, K, t, r, sigma in self.arg_combinations]
65 |         self.assertTrue(self.diff_mean(rhos, nrhos) < self.epsilon)
66 | 
67 | 
68 | if __name__ == '__main__':
69 |     unittest.main()
70 | 


--------------------------------------------------------------------------------
/tests/test_ref_python/test_ref_python_black_scholes_merton.py:
--------------------------------------------------------------------------------
  1 | # -----------------------------------------------------------------------------
  2 | # IMPORTS
  3 | 
  4 | # Standard library imports
  5 | from __future__ import print_function
  6 | import unittest
  7 | 
  8 | # Related third party imports
  9 | 
 10 | # Local application/library specific imports
 11 | from py_vollib.ref_python.black_scholes_merton import black_scholes_merton
 12 | from py_vollib.ref_python.black_scholes_merton.implied_volatility import implied_volatility
 13 | from py_vollib.ref_python.black_scholes_merton.greeks import analytical
 14 | from py_vollib.ref_python.black_scholes_merton.greeks import numerical
 15 | from tests.test_utils import IteratorForTestData
 16 | 
 17 | 
 18 | q = 0
 19 | 
 20 | 
 21 | class TestRefPythonBlackScholesMertonAgainstBenchmarkValues(unittest.TestCase):
 22 |     def setUp(self):
 23 |         self.tdi = IteratorForTestData()
 24 | 
 25 |     def test_prices(self):
 26 |         while self.tdi.has_next():
 27 |             row = self.tdi.next_row()
 28 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 29 |             self.assertAlmostEqual(black_scholes_merton('c', S, K, t, r, sigma, q), row['bs_call'], delta=0.000001)
 30 |             self.assertAlmostEqual(black_scholes_merton('p', S, K, t, r, sigma, q), row['bs_put'], delta=0.000001)
 31 | 
 32 |     def test_analytical_delta(self):
 33 |         while self.tdi.has_next():
 34 |             row = self.tdi.next_row()
 35 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 36 |             self.assertAlmostEqual(analytical.delta('c', S, K, t, r, sigma, q), row['CD'], delta=0.000001)
 37 |             self.assertAlmostEqual(analytical.delta('p', S, K, t, r, sigma, q), row['PD'], delta=0.000001)
 38 | 
 39 |     def test_analytical_theta(self):
 40 |         while self.tdi.has_next():
 41 |             row = self.tdi.next_row()
 42 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 43 |             self.assertAlmostEqual(analytical.theta('c', S, K, t, r, sigma, q), row['CT'] / 365.0, delta=0.000001)
 44 |             self.assertAlmostEqual(analytical.theta('p', S, K, t, r, sigma, q), row['PT'] / 365.0, delta=0.000001)
 45 | 
 46 |     def test_analytical_gamma(self):
 47 |         while self.tdi.has_next():
 48 |             row = self.tdi.next_row()
 49 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 50 |             self.assertAlmostEqual(analytical.gamma('c', S, K, t, r, sigma, q), row['CG'], delta=0.000001)
 51 |             self.assertAlmostEqual(analytical.gamma('p', S, K, t, r, sigma, q), row['PG'], delta=0.000001)
 52 | 
 53 |     def test_analytical_vega(self):
 54 |         while self.tdi.has_next():
 55 |             row = self.tdi.next_row()
 56 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 57 |             self.assertAlmostEqual(analytical.vega('c', S, K, t, r, sigma, q), row['CV'] * .01, delta=0.000001)
 58 |             self.assertAlmostEqual(analytical.vega('p', S, K, t, r, sigma, q), row['PV'] * .01, delta=0.000001)
 59 | 
 60 |     def test_analytical_rho(self):
 61 |         while self.tdi.has_next():
 62 |             row = self.tdi.next_row()
 63 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 64 |             self.assertAlmostEqual(analytical.rho('c', S, K, t, r, sigma, q), row['CR'] * 0.01, delta=0.000000001)
 65 |             self.assertAlmostEqual(analytical.rho('p', S, K, t, r, sigma, q), row['PR'] * 0.01, delta=0.000000001)
 66 | 
 67 |     def test_numerical_delta(self):
 68 |         while self.tdi.has_next():
 69 |             row = self.tdi.next_row()
 70 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 71 |             self.assertAlmostEqual(numerical.delta('c', S, K, t, r, sigma, q), row['CD'], delta=0.000001)
 72 |             self.assertAlmostEqual(numerical.delta('p', S, K, t, r, sigma, q), row['PD'], delta=0.000001)
 73 | 
 74 |     def test_numerical_theta(self):
 75 |         while self.tdi.has_next():
 76 |             row = self.tdi.next_row()
 77 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 78 |             self.assertAlmostEqual(numerical.theta('c', S, K, t, r, sigma, q), row['CT'] / 365.0, delta=1)
 79 |             self.assertAlmostEqual(numerical.theta('p', S, K, t, r, sigma, q), row['PT'] / 365.0, delta=1)
 80 | 
 81 |     def test_numerical_gamma(self):
 82 |         while self.tdi.has_next():
 83 |             row = self.tdi.next_row()
 84 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 85 |             self.assertAlmostEqual(numerical.gamma('c', S, K, t, r, sigma, q), row['CG'], delta=0.000001)
 86 |             self.assertAlmostEqual(numerical.gamma('p', S, K, t, r, sigma, q), row['PG'], delta=0.000001)
 87 | 
 88 |     def test_numerical_vega(self):
 89 |         while self.tdi.has_next():
 90 |             row = self.tdi.next_row()
 91 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 92 |             self.assertAlmostEqual(numerical.vega('c', S, K, t, r, sigma, q), row['CV'] * 0.01, delta=0.01)
 93 |             self.assertAlmostEqual(numerical.vega('p', S, K, t, r, sigma, q), row['PV'] * 0.01, delta=0.01)
 94 | 
 95 |     def test_numerical_rho(self):
 96 |         while self.tdi.has_next():
 97 |             row = self.tdi.next_row()
 98 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
 99 |             self.assertAlmostEqual(numerical.rho('c', S, K, t, r, sigma, q), row['CR'] * 0.01, delta=0.001)
100 |             self.assertAlmostEqual(numerical.rho('p', S, K, t, r, sigma, q), row['PR'] * 0.01, delta=0.001)
101 | 
102 |     def test_implied_volatility(self):
103 |         while self.tdi.has_next():
104 |             row = self.tdi.next_row()
105 |             S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row['v']
106 |             C, P = black_scholes_merton('c', S, K, t, r, sigma, q), black_scholes_merton('p', S, K, t, r, sigma, q)
107 |             try:
108 |                 iv = implied_volatility(C, S, K, t, r, q, 'c')
109 |                 self.assertAlmostEqual(sigma, iv, delta=0.0001)
110 |             except:
111 |                 print('could not calculate iv for ', C, S, K, t, r, 'c')
112 |             iv = implied_volatility(P, S, K, t, r, q, 'p')
113 |             self.assertTrue(iv == 1e-12) if iv == 1e-12 else self.assertAlmostEqual(sigma, iv, delta=0.001)
114 | 
115 | 
116 | if __name__ == '__main__':
117 |     unittest.main()
118 | 


--------------------------------------------------------------------------------
/tests/test_ref_python/test_ref_python_black_scholes_merton_greeks.py:
--------------------------------------------------------------------------------
 1 | # -----------------------------------------------------------------------------
 2 | # IMPORTS
 3 | 
 4 | # Standard library imports
 5 | from __future__ import print_function
 6 | import unittest
 7 | from itertools import product
 8 | 
 9 | # Related third party imports
10 | import numpy
11 | 
12 | # Local application/library specific imports
13 | from py_vollib.ref_python.black_scholes_merton.greeks.analytical import delta
14 | from py_vollib.ref_python.black_scholes_merton.greeks.analytical import gamma
15 | from py_vollib.ref_python.black_scholes_merton.greeks.analytical import theta
16 | from py_vollib.ref_python.black_scholes_merton.greeks.analytical import vega
17 | from py_vollib.ref_python.black_scholes_merton.greeks.analytical import rho
18 | from py_vollib.ref_python.black_scholes_merton.greeks.numerical import delta as ndelta
19 | from py_vollib.ref_python.black_scholes_merton.greeks.numerical import gamma as ngamma
20 | from py_vollib.ref_python.black_scholes_merton.greeks.numerical import theta as ntheta
21 | from py_vollib.ref_python.black_scholes_merton.greeks.numerical import vega as nvega
22 | from py_vollib.ref_python.black_scholes_merton.greeks.numerical import rho as nrho
23 | 
24 | 
25 | class TestRefPythonBSMGreeks(unittest.TestCase):
26 |     def setUp(self):
27 |         self.epsilon = 0.001
28 |         self.flags = ['c', 'p']
29 |         self.S = 100
30 |         self.Ks = numpy.linspace(20, 200, 10)
31 |         self.ts = numpy.linspace(0.01, 2, 10)
32 |         self.rs = numpy.linspace(0, 0.2, 10)
33 |         self.sigmas = numpy.linspace(0.1, 0.5, 10)
34 |         self.q = 0
35 |         self.arg_combinations = list(product(self.flags, [self.S], self.Ks, self.ts, self.rs, self.sigmas, [self.q]))
36 | 
37 |     def diff_mean(self, left, right):
38 |         left_arr = numpy.array(left)
39 |         right_arr = numpy.array(right)
40 |         abs_diff = numpy.abs(left_arr - right_arr)
41 |         return numpy.mean(abs_diff)
42 | 
43 |     def test_theta(self):
44 |         thetas = [theta(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
45 |         nthetas = [ntheta(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
46 |         self.assertTrue(self.diff_mean(thetas, nthetas) < self.epsilon)
47 | 
48 |     def test_delta(self):
49 |         deltas = [delta(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
50 |         ndeltas = [ndelta(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
51 |         self.assertTrue(self.diff_mean(deltas, ndeltas) < self.epsilon)
52 | 
53 |     def test_gamma(self):
54 |         gammas = [gamma(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
55 |         ngammas = [ngamma(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
56 |         self.assertTrue(self.diff_mean(gammas, ngammas) < self.epsilon)
57 | 
58 |     def test_vega(self):
59 |         vegas = [vega(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
60 |         nvegas = [nvega(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
61 |         self.assertTrue(self.diff_mean(vegas, nvegas) < self.epsilon)
62 | 
63 |     def test_rho(self):
64 |         rhos = [rho(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
65 |         nrhos = [nrho(flag, S, K, t, r, sigma, q) for flag, S, K, t, r, sigma, q in self.arg_combinations]
66 |         self.assertTrue(self.diff_mean(rhos, nrhos) < self.epsilon)
67 | 
68 | 
69 | if __name__ == '__main__':
70 |     unittest.main()
71 | 


--------------------------------------------------------------------------------
/tests/test_utils.py:
--------------------------------------------------------------------------------
 1 | # -----------------------------------------------------------------------------
 2 | # IMPORTS
 3 | 
 4 | # Standard library imports
 5 | from collections import OrderedDict
 6 | import os
 7 | 
 8 | # Related third party imports
 9 | import simplejson as json
10 | import pandas
11 | 
12 | # Local application/library specific imports
13 | 
14 | 
15 | def almost_equal(a, b, epsilon=1.0e-7):
16 |     return abs(a - b) < epsilon
17 | 
18 | 
19 | class IteratorForTestData(object):
20 | 
21 |     """
22 |     >>> data_iterator = IteratorForTestData()
23 |     >>> print (data_iterator.has_next())
24 |     True
25 |     >>> r = data_iterator.next_row()
26 |     >>> print (r['S'])
27 |     100.0
28 |     """
29 |     
30 |     def __init__(self):
31 |         filepath = os.path.join(os.path.dirname(__file__), "test_data.json")
32 |         self.data = json.load(open(filepath,'rb'))
33 |         columns = self.data['columns']
34 |         grid_data = OrderedDict()
35 | 
36 |         for header in columns:
37 |             grid_data[header] = []
38 | 
39 |         for col in self.data['data']:
40 |             for i in range(len(columns)):
41 |                 grid_data[columns[i]].append(col[i])
42 | 
43 |         self.df = pandas.DataFrame(grid_data)
44 |         self.row_id = 0
45 |         self.row_count = self.df.S.count()
46 | 
47 |     def next_row(self):
48 |         if self.has_next():
49 |             row = self.df.ix[self.row_id].to_dict()
50 |             self.row_id += 1
51 |             return row
52 | 
53 |     def has_next(self):
54 |         return self.row_id < self.row_count
55 |     
56 |     
57 | # -----------------------------------------------------------------------------
58 | # MAIN
59 | if __name__=='__main__':  
60 |     import doctest
61 |     if not doctest.testmod().failed:
62 |         print ("Doctest passed")
63 | 


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/___init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/tests/test_vollib_vs_ref_python_values/___init__.py


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/tests/test_vollib_vs_ref_python_values/black/__init__.py


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black/test_greeks.py:
--------------------------------------------------------------------------------
  1 | # -----------------------------------------------------------------------------
  2 | # IMPORTS
  3 | 
  4 | # Standard library imports
  5 | import unittest
  6 | 
  7 | # Related third party imports
  8 | 
  9 | # Local application/library specific imports
 10 | from py_vollib.black.greeks import analytical as c_analytical
 11 | from py_vollib.black.greeks import numerical as c_numerical
 12 | from py_vollib.ref_python.black.greeks import analytical as py_analytical
 13 | from py_vollib.ref_python.black.greeks import numerical as py_numerical
 14 | from tests.test_utils import almost_equal
 15 | 
 16 | 
 17 | class TestGreeks(unittest.TestCase):
 18 | 
 19 |     def test_analytical_delta(self):
 20 |         F = 100
 21 |         K = 90
 22 |         sigma = .2
 23 |         r = .02
 24 |         t = .5
 25 | 
 26 |         flag = 'p'
 27 |         c_put = c_analytical.delta(flag, F, K, t, r, sigma)
 28 |         py_put = py_analytical.delta(flag, F, K, t, r, sigma)
 29 |         self.assertTrue(almost_equal(c_put, py_put))
 30 | 
 31 |         flag = 'c'
 32 |         c_call = c_analytical.delta(flag, F, K, t, r, sigma)
 33 |         py_call = py_analytical.delta(flag, F, K, t, r, sigma)
 34 |         self.assertTrue(almost_equal(c_call, py_call))
 35 | 
 36 |     def test_analytical_gamma(self):
 37 |         F = 100
 38 |         K = 90
 39 |         sigma = .2
 40 |         r = .02
 41 |         t = .5
 42 | 
 43 |         flag = 'p'
 44 |         c_put = c_analytical.gamma(flag, F, K, t, r, sigma)
 45 |         py_put = py_analytical.gamma(flag, F, K, t, r, sigma)
 46 |         self.assertTrue(almost_equal(c_put, py_put))
 47 | 
 48 |         flag = 'c'
 49 |         c_call = c_analytical.gamma(flag, F, K, t, r, sigma)
 50 |         py_call = py_analytical.gamma(flag, F, K, t, r, sigma)
 51 |         self.assertTrue(almost_equal(c_call, py_call))
 52 | 
 53 |     def test_analytical_rho(self):
 54 |         F = 100
 55 |         K = 90
 56 |         sigma = .2
 57 |         r = .02
 58 |         t = .5
 59 | 
 60 |         flag = 'p'
 61 |         c_put = c_analytical.rho(flag, F, K, t, r, sigma)
 62 |         py_put = py_analytical.rho(flag, F, K, t, r, sigma)
 63 |         self.assertTrue(almost_equal(c_put, py_put))
 64 | 
 65 |         flag = 'c'
 66 |         c_call = c_analytical.rho(flag, F, K, t, r, sigma)
 67 |         py_call = py_analytical.rho(flag, F, K, t, r, sigma)
 68 |         self.assertTrue(almost_equal(c_call, py_call))
 69 | 
 70 |     def test_analytical_theta(self):
 71 |         F = 100
 72 |         K = 90
 73 |         sigma = .2
 74 |         r = .02
 75 |         t = .5
 76 | 
 77 |         flag = 'p'
 78 |         c_put = c_analytical.theta(flag, F, K, t, r, sigma)
 79 |         py_put = py_analytical.theta(flag, F, K, t, r, sigma)
 80 |         self.assertTrue(almost_equal(c_put, py_put))
 81 | 
 82 |         flag = 'c'
 83 |         c_call = c_analytical.theta(flag, F, K, t, r, sigma)
 84 |         py_call = py_analytical.theta(flag, F, K, t, r, sigma)
 85 |         self.assertTrue(almost_equal(c_call, py_call))
 86 | 
 87 |     def test_analytical_vega(self):
 88 |         F = 100
 89 |         K = 90
 90 |         sigma = .2
 91 |         r = .02
 92 |         t = .5
 93 | 
 94 |         flag = 'p'
 95 |         c_put = c_analytical.vega(flag, F, K, t, r, sigma)
 96 |         py_put = py_analytical.vega(flag, F, K, t, r, sigma)
 97 |         self.assertTrue(almost_equal(c_put, py_put))
 98 | 
 99 |         flag = 'c'
100 |         c_call = c_analytical.vega(flag, F, K, t, r, sigma)
101 |         py_call = py_analytical.vega(flag, F, K, t, r, sigma)
102 |         self.assertTrue(almost_equal(c_call, py_call))
103 | 
104 |     def test_numerical_delta(self):
105 |         F = 100
106 |         K = 90
107 |         sigma = .2
108 |         r = .02
109 |         t = .5
110 | 
111 |         flag = 'p'
112 |         c_put = c_numerical.delta(flag, F, K, t, r, sigma)
113 |         py_put = py_numerical.delta(flag, F, K, t, r, sigma)
114 |         self.assertTrue(almost_equal(c_put, py_put))
115 | 
116 |         flag = 'c'
117 |         c_call = c_numerical.delta(flag, F, K, t, r, sigma)
118 |         py_call = py_numerical.delta(flag, F, K, t, r, sigma)
119 |         self.assertTrue(almost_equal(c_call, py_call))
120 | 
121 |     def test_numerical_gamma(self):
122 |         F = 100
123 |         K = 90
124 |         sigma = .2
125 |         r = .02
126 |         t = .5
127 | 
128 |         flag = 'p'
129 |         c_put = c_numerical.gamma(flag, F, K, t, r, sigma)
130 |         py_put = py_numerical.gamma(flag, F, K, t, r, sigma)
131 |         self.assertTrue(almost_equal(c_put, py_put))
132 | 
133 |         flag = 'c'
134 |         c_call = c_numerical.gamma(flag, F, K, t, r, sigma)
135 |         py_call = py_numerical.gamma(flag, F, K, t, r, sigma)
136 |         self.assertTrue(almost_equal(c_call, py_call))
137 | 
138 |     def test_numerical_rho(self):
139 |         F = 100
140 |         K = 90
141 |         sigma = .2
142 |         r = .02
143 |         t = .5
144 | 
145 |         flag = 'p'
146 |         c_put = c_numerical.rho(flag, F, K, t, r, sigma)
147 |         py_put = py_numerical.rho(flag, F, K, t, r, sigma)
148 |         self.assertTrue(almost_equal(c_put, py_put))
149 | 
150 |         flag = 'c'
151 |         c_call = c_numerical.rho(flag, F, K, t, r, sigma)
152 |         py_call = py_numerical.rho(flag, F, K, t, r, sigma)
153 |         self.assertTrue(almost_equal(c_call, py_call))
154 | 
155 |     def test_numerical_theta(self):
156 |         F = 100
157 |         K = 90
158 |         sigma = .2
159 |         r = .02
160 |         t = .5
161 | 
162 |         flag = 'p'
163 |         c_put = c_numerical.theta(flag, F, K, t, r, sigma)
164 |         py_put = py_numerical.theta(flag, F, K, t, r, sigma)
165 |         self.assertTrue(almost_equal(c_put, py_put))
166 | 
167 |         flag = 'c'
168 |         c_call = c_numerical.theta(flag, F, K, t, r, sigma)
169 |         py_call = py_numerical.theta(flag, F, K, t, r, sigma)
170 |         self.assertTrue(almost_equal(c_call, py_call))
171 | 
172 |     def test_numerical_vega(self):
173 |         F = 100
174 |         K = 90
175 |         sigma = .2
176 |         r = .02
177 |         t = .5
178 | 
179 |         flag = 'p'
180 |         c_put = c_numerical.vega(flag, F, K, t, r, sigma)
181 |         py_put = py_numerical.vega(flag, F, K, t, r, sigma)
182 |         self.assertTrue(almost_equal(c_put, py_put))
183 | 
184 |         flag = 'c'
185 |         c_call = c_numerical.vega(flag, F, K, t, r, sigma)
186 |         py_call = py_numerical.vega(flag, F, K, t, r, sigma)
187 |         self.assertTrue(almost_equal(c_call, py_call))
188 | 
189 | 
190 | if __name__ == '__main__':
191 |     unittest.main()
192 | 


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black/test_implied_volatility.py:
--------------------------------------------------------------------------------
 1 | # -----------------------------------------------------------------------------
 2 | # IMPORTS
 3 | 
 4 | # Standard library imports
 5 | import unittest
 6 | 
 7 | # Related third party imports
 8 | 
 9 | # Local application/library specific imports
10 | from py_vollib.black import black as c_black
11 | from py_vollib.black.implied_volatility import implied_volatility_of_discounted_option_price as c_implied_volatility
12 | from py_vollib.ref_python.black import black as py_black
13 | from py_vollib.ref_python.black.implied_volatility import implied_volatility as py_implied_volatility
14 | from tests.test_utils import almost_equal
15 | 
16 | 
17 | class TestImpliedVolatility(unittest.TestCase):
18 | 
19 |     def test_implied_volatility_put(self):
20 |         F = 100
21 |         K = 100
22 |         sigma = .2
23 |         t = .5
24 |         r = .02
25 |         flag = 'p'
26 | 
27 |         c_price = c_black(flag, F, K, t, r, sigma)
28 |         py_price = py_black(flag, F, K, t, r, sigma)
29 | 
30 |         c_iv = c_implied_volatility(c_price, F, K, t, r, flag)
31 |         py_iv = py_implied_volatility(py_price, F, K, t, r, flag)
32 |         self.assertTrue(almost_equal(c_iv, py_iv))
33 | 
34 |     def test_implied_volatility_call(self):
35 |         F = 100
36 |         K = 100
37 |         sigma = .2
38 |         t = .5
39 |         r = .02
40 |         flag = 'c'
41 | 
42 |         c_price = c_black(flag, F, K, t, r, sigma)
43 |         py_price = py_black(flag, F, K, t, r, sigma)
44 | 
45 |         c_iv = c_implied_volatility(c_price, F, K, t, r, flag)
46 |         py_iv = py_implied_volatility(py_price, F, K, t, r, flag)
47 |         self.assertTrue(almost_equal(c_iv, py_iv))
48 | 
49 | 
50 | if __name__ == '__main__':
51 |     unittest.main()
52 | 


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black/test_price.py:
--------------------------------------------------------------------------------
 1 | # -----------------------------------------------------------------------------
 2 | # IMPORTS
 3 | 
 4 | # Standard library imports
 5 | import unittest
 6 | 
 7 | # Related third party imports
 8 | 
 9 | # Local application/library specific imports
10 | from py_vollib.black import black as c_black
11 | from py_vollib.ref_python.black import black as py_black
12 | from tests.test_utils import almost_equal
13 | 
14 | 
15 | class TestPrice(unittest.TestCase):
16 | 
17 |     def test_black_put(self):
18 |         F = 100
19 |         K = 90
20 |         sigma = .2
21 |         r = .02
22 |         t = .5
23 |         flag = 'p'
24 | 
25 |         c_price = c_black(flag, F, K, t, r, sigma)
26 |         py_price = py_black(flag, F, K, t, r, sigma)
27 |         self.assertTrue(almost_equal(c_price, py_price))
28 | 
29 |     def test_black_call(self):
30 |         F = 100
31 |         K = 90
32 |         sigma = .2
33 |         r = .02
34 |         t = .5
35 |         flag = 'c'
36 | 
37 |         c_price = c_black(flag, F, K, t, r, sigma)
38 |         py_price = py_black(flag, F, K, t, r, sigma)
39 |         self.assertTrue(almost_equal(c_price, py_price))
40 | 
41 | 
42 | if __name__ == '__main__':
43 |     unittest.main()
44 | 


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black_scholes/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/tests/test_vollib_vs_ref_python_values/black_scholes/__init__.py


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black_scholes/test_greeks.py:
--------------------------------------------------------------------------------
  1 | # -----------------------------------------------------------------------------
  2 | # IMPORTS
  3 | 
  4 | # Standard library imports
  5 | import unittest
  6 | 
  7 | # Related third party imports
  8 | 
  9 | # Local application/library specific imports
 10 | from py_vollib.black_scholes.greeks import analytical as c_analytical
 11 | from py_vollib.black_scholes.greeks import numerical as c_numerical
 12 | from py_vollib.ref_python.black_scholes.greeks import analytical as py_analytical
 13 | from py_vollib.ref_python.black_scholes.greeks import numerical as py_numerical
 14 | from tests.test_utils import almost_equal
 15 | 
 16 | 
 17 | class TestGreeks(unittest.TestCase):
 18 |     def test_analytical_delta(self):
 19 |         S = 49
 20 |         K = 50
 21 |         sigma = .2
 22 |         r = .05
 23 |         t = 0.3846
 24 | 
 25 |         flag = 'p'
 26 |         c_put = c_analytical.delta(flag, S, K, t, r, sigma)
 27 |         py_put = py_analytical.delta(flag, S, K, t, r, sigma)
 28 |         self.assertTrue(almost_equal(c_put, py_put))
 29 | 
 30 |         flag = 'c'
 31 |         c_call = c_analytical.delta(flag, S, K, t, r, sigma)
 32 |         py_call = py_analytical.delta(flag, S, K, t, r, sigma)
 33 |         self.assertTrue(almost_equal(c_call, py_call))
 34 | 
 35 |     def test_analytical_gamma(self):
 36 |         S = 49
 37 |         K = 50
 38 |         sigma = .2
 39 |         r = .05
 40 |         t = 0.3846
 41 | 
 42 |         flag = 'p'
 43 |         c_put = c_analytical.gamma(flag, S, K, t, r, sigma)
 44 |         py_put = py_analytical.gamma(flag, S, K, t, r, sigma)
 45 |         self.assertTrue(almost_equal(c_put, py_put))
 46 | 
 47 |         flag = 'c'
 48 |         c_call = c_analytical.gamma(flag, S, K, t, r, sigma)
 49 |         py_call = py_analytical.gamma(flag, S, K, t, r, sigma)
 50 |         self.assertTrue(almost_equal(c_call, py_call))
 51 | 
 52 |     def test_analytical_rho(self):
 53 |         S = 49
 54 |         K = 50
 55 |         sigma = .2
 56 |         r = .05
 57 |         t = 0.3846
 58 | 
 59 |         flag = 'p'
 60 |         c_put = c_analytical.rho(flag, S, K, t, r, sigma)
 61 |         py_put = py_analytical.rho(flag, S, K, t, r, sigma)
 62 |         self.assertTrue(almost_equal(c_put, py_put))
 63 | 
 64 |         flag = 'c'
 65 |         c_call = c_analytical.rho(flag, S, K, t, r, sigma)
 66 |         py_call = py_analytical.rho(flag, S, K, t, r, sigma)
 67 |         self.assertTrue(almost_equal(c_call, py_call))
 68 | 
 69 |     def test_analytical_theta(self):
 70 |         S = 49
 71 |         K = 50
 72 |         sigma = .2
 73 |         r = .05
 74 |         t = 0.3846
 75 | 
 76 |         flag = 'p'
 77 |         c_put = c_analytical.theta(flag, S, K, t, r, sigma)
 78 |         py_put = py_analytical.theta(flag, S, K, t, r, sigma)
 79 |         self.assertTrue(almost_equal(c_put, py_put))
 80 | 
 81 |         flag = 'c'
 82 |         c_call = c_analytical.theta(flag, S, K, t, r, sigma)
 83 |         py_call = py_analytical.theta(flag, S, K, t, r, sigma)
 84 |         self.assertTrue(almost_equal(c_call, py_call))
 85 | 
 86 |     def test_analytical_vega(self):
 87 |         S = 49
 88 |         K = 50
 89 |         sigma = .2
 90 |         r = .05
 91 |         t = 0.3846
 92 | 
 93 |         flag = 'p'
 94 |         c_put = c_analytical.vega(flag, S, K, t, r, sigma)
 95 |         py_put = py_analytical.vega(flag, S, K, t, r, sigma)
 96 |         self.assertTrue(almost_equal(c_put, py_put))
 97 | 
 98 |         flag = 'c'
 99 |         c_call = c_analytical.vega(flag, S, K, t, r, sigma)
100 |         py_call = py_analytical.vega(flag, S, K, t, r, sigma)
101 |         self.assertTrue(almost_equal(c_call, py_call))
102 | 
103 |     def test_numerical_delta(self):
104 |         S = 49
105 |         K = 50
106 |         sigma = .2
107 |         r = .05
108 |         t = 0.3846
109 | 
110 |         flag = 'p'
111 |         c_put = c_numerical.delta(flag, S, K, t, r, sigma)
112 |         py_put = py_numerical.delta(flag, S, K, t, r, sigma)
113 |         self.assertTrue(almost_equal(c_put, py_put))
114 | 
115 |         flag = 'c'
116 |         c_call = c_numerical.delta(flag, S, K, t, r, sigma)
117 |         py_call = py_numerical.delta(flag, S, K, t, r, sigma)
118 |         self.assertTrue(almost_equal(c_call, py_call))
119 | 
120 |     def test_numerical_gamma(self):
121 |         S = 49
122 |         K = 50
123 |         sigma = .2
124 |         r = .05
125 |         t = 0.3846
126 | 
127 |         flag = 'p'
128 |         c_put = c_numerical.gamma(flag, S, K, t, r, sigma)
129 |         py_put = py_numerical.gamma(flag, S, K, t, r, sigma)
130 |         self.assertTrue(almost_equal(c_put, py_put))
131 | 
132 |         flag = 'c'
133 |         c_call = c_numerical.gamma(flag, S, K, t, r, sigma)
134 |         py_call = py_numerical.gamma(flag, S, K, t, r, sigma)
135 |         self.assertTrue(almost_equal(c_call, py_call))
136 | 
137 |     def test_numerical_rho(self):
138 |         S = 49
139 |         K = 50
140 |         sigma = .2
141 |         r = .05
142 |         t = 0.3846
143 | 
144 |         flag = 'p'
145 |         c_put = c_numerical.rho(flag, S, K, t, r, sigma)
146 |         py_put = py_numerical.rho(flag, S, K, t, r, sigma)
147 |         self.assertTrue(almost_equal(c_put, py_put))
148 | 
149 |         flag = 'c'
150 |         c_call = c_numerical.rho(flag, S, K, t, r, sigma)
151 |         py_call = py_numerical.rho(flag, S, K, t, r, sigma)
152 |         self.assertTrue(almost_equal(c_call, py_call))
153 | 
154 |     def test_numerical_theta(self):
155 |         S = 49
156 |         K = 50
157 |         sigma = .2
158 |         r = .05
159 |         t = 0.3846
160 | 
161 |         flag = 'p'
162 |         c_put = c_numerical.theta(flag, S, K, t, r, sigma)
163 |         py_put = py_numerical.theta(flag, S, K, t, r, sigma)
164 |         self.assertTrue(almost_equal(c_put, py_put))
165 | 
166 |         flag = 'c'
167 |         c_call = c_numerical.theta(flag, S, K, t, r, sigma)
168 |         py_call = py_numerical.theta(flag, S, K, t, r, sigma)
169 |         self.assertTrue(almost_equal(c_call, py_call))
170 | 
171 |     def test_numerical_vega(self):
172 |         S = 49
173 |         K = 50
174 |         sigma = .2
175 |         r = .05
176 |         t = 0.3846
177 | 
178 |         flag = 'p'
179 |         c_put = c_numerical.vega(flag, S, K, t, r, sigma)
180 |         py_put = py_numerical.vega(flag, S, K, t, r, sigma)
181 |         self.assertTrue(almost_equal(c_put, py_put))
182 | 
183 |         flag = 'c'
184 |         c_call = c_numerical.vega(flag, S, K, t, r, sigma)
185 |         py_call = py_numerical.vega(flag, S, K, t, r, sigma)
186 |         self.assertTrue(almost_equal(c_call, py_call))
187 | 
188 | 
189 | if __name__ == '__main__':
190 |     unittest.main()
191 | 


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black_scholes/test_implied_volatility.py:
--------------------------------------------------------------------------------
 1 | # -----------------------------------------------------------------------------
 2 | # IMPORTS
 3 | 
 4 | # Standard library imports
 5 | import unittest
 6 | 
 7 | # Related third party imports
 8 | 
 9 | # Local application/library specific imports
10 | from py_vollib.black_scholes import black_scholes as c_black_scholes
11 | from py_vollib.black_scholes.implied_volatility import implied_volatility as c_implied_volatility
12 | from py_vollib.ref_python.black_scholes import black_scholes as py_black_scholes
13 | from py_vollib.ref_python.black_scholes.implied_volatility import implied_volatility as py_implied_volatility
14 | from tests.test_utils import almost_equal
15 | 
16 | 
17 | class TestImpliedVolatility(unittest.TestCase):
18 | 
19 |     def test_implied_volatility_put(self):
20 |         S = 100
21 |         K = 100
22 |         sigma = .232323232
23 |         t = .5
24 |         r = .01
25 |         flag = 'p'
26 | 
27 |         c_price = c_black_scholes(flag, S, K, t, r, sigma)
28 |         py_price = py_black_scholes(flag, S, K, t, r, sigma)
29 | 
30 |         c_iv = c_implied_volatility(c_price, S, K, t, r, flag)
31 |         py_iv = py_implied_volatility(py_price, S, K, t, r, flag)
32 |         self.assertTrue(almost_equal(c_iv, py_iv))
33 | 
34 |     def test_implied_volatility_call(self):
35 |         S = 100
36 |         K = 100
37 |         sigma = .232323232
38 |         t = .5
39 |         r = .01
40 |         flag = 'c'
41 | 
42 |         c_price = c_black_scholes(flag, S, K, t, r, sigma)
43 |         py_price = py_black_scholes(flag, S, K, t, r, sigma)
44 | 
45 |         c_iv = c_implied_volatility(c_price, S, K, t, r, flag)
46 |         py_iv = py_implied_volatility(py_price, S, K, t, r, flag)
47 |         self.assertTrue(almost_equal(c_iv, py_iv))
48 | 
49 | 
50 | if __name__ == '__main__':
51 |     unittest.main()
52 | 


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black_scholes/test_price.py:
--------------------------------------------------------------------------------
 1 | # -----------------------------------------------------------------------------
 2 | # IMPORTS
 3 | 
 4 | # Standard library imports
 5 | import unittest
 6 | 
 7 | # Related third party imports
 8 | 
 9 | # Local application/library specific imports
10 | from py_vollib.black_scholes import black_scholes as c_black_scholes
11 | from py_vollib.ref_python.black_scholes import black_scholes as py_black_scholes
12 | from tests.test_utils import almost_equal
13 | 
14 | 
15 | class TestPrice(unittest.TestCase):
16 | 
17 |     def test_black_scholes_put(self):
18 |         S = 100
19 |         K = 90
20 |         r = .01
21 |         t = .5
22 |         sigma = .2
23 |         flag = 'p'
24 | 
25 |         c_price = c_black_scholes(flag, S, K, t, r, sigma)
26 |         py_price = py_black_scholes(flag, S, K, t, r, sigma)
27 |         self.assertTrue(almost_equal(c_price, py_price))
28 | 
29 |     def test_black_scholes_call(self):
30 |         S = 100
31 |         K = 90
32 |         r = .01
33 |         t = .5
34 |         sigma = .2
35 |         flag = 'c'
36 | 
37 |         c_price = c_black_scholes(flag, S, K, t, r, sigma)
38 |         py_price = py_black_scholes(flag, S, K, t, r, sigma)
39 |         self.assertTrue(almost_equal(c_price, py_price))
40 | 
41 | 
42 | if __name__ == '__main__':
43 |     unittest.main()
44 | 


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black_scholes_merton/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vollib/py_vollib/9fbc623dbc8d7241b935da440a722b49186b9bb1/tests/test_vollib_vs_ref_python_values/black_scholes_merton/__init__.py


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black_scholes_merton/test_greeks.py:
--------------------------------------------------------------------------------
  1 | # -----------------------------------------------------------------------------
  2 | # IMPORTS
  3 | 
  4 | # Standard library imports
  5 | import unittest
  6 | 
  7 | # Related third party imports
  8 | 
  9 | # Local application/library specific imports
 10 | from py_vollib.black_scholes_merton.greeks import analytical as c_analytical
 11 | from py_vollib.black_scholes_merton.greeks import numerical as c_numerical
 12 | from py_vollib.ref_python.black_scholes_merton.greeks import analytical as py_analytical
 13 | from py_vollib.ref_python.black_scholes_merton.greeks import numerical as py_numerical
 14 | from tests.test_utils import almost_equal
 15 | 
 16 | 
 17 | class TestGreeks(unittest.TestCase):
 18 |     def test_analytical_delta(self):
 19 |         S = 49
 20 |         K = 50
 21 |         sigma = .2
 22 |         r = .05
 23 |         t = 0.3846
 24 |         q = 0.2
 25 | 
 26 |         flag = 'p'
 27 |         c_put = c_analytical.delta(flag, S, K, t, r, sigma, q)
 28 |         py_put = py_analytical.delta(flag, S, K, t, r, sigma, q)
 29 |         self.assertTrue(almost_equal(c_put, py_put))
 30 | 
 31 |         flag = 'c'
 32 |         c_call = c_analytical.delta(flag, S, K, t, r, sigma, q)
 33 |         py_call = py_analytical.delta(flag, S, K, t, r, sigma, q)
 34 |         self.assertTrue(almost_equal(c_call, py_call))
 35 | 
 36 |     def test_analytical_gamma(self):
 37 |         S = 49
 38 |         K = 50
 39 |         sigma = .2
 40 |         r = .05
 41 |         t = 0.3846
 42 |         q = 0.2
 43 | 
 44 |         flag = 'p'
 45 |         c_put = c_analytical.gamma(flag, S, K, t, r, sigma, q)
 46 |         py_put = py_analytical.gamma(flag, S, K, t, r, sigma, q)
 47 |         self.assertTrue(almost_equal(c_put, py_put))
 48 | 
 49 |         flag = 'c'
 50 |         c_call = c_analytical.gamma(flag, S, K, t, r, sigma, q)
 51 |         py_call = py_analytical.gamma(flag, S, K, t, r, sigma, q)
 52 |         self.assertTrue(almost_equal(c_call, py_call))
 53 | 
 54 |     def test_analytical_rho(self):
 55 |         S = 49
 56 |         K = 50
 57 |         sigma = .2
 58 |         r = .05
 59 |         t = 0.3846
 60 |         q = 0.2
 61 | 
 62 |         flag = 'p'
 63 |         c_put = c_analytical.rho(flag, S, K, t, r, sigma, q)
 64 |         py_put = py_analytical.rho(flag, S, K, t, r, sigma, q)
 65 |         self.assertTrue(almost_equal(c_put, py_put))
 66 | 
 67 |         flag = 'c'
 68 |         c_call = c_analytical.rho(flag, S, K, t, r, sigma, q)
 69 |         py_call = py_analytical.rho(flag, S, K, t, r, sigma, q)
 70 |         self.assertTrue(almost_equal(c_call, py_call))
 71 | 
 72 |     def test_analytical_theta(self):
 73 |         S = 49
 74 |         K = 50
 75 |         sigma = .2
 76 |         r = .05
 77 |         t = 0.3846
 78 |         q = 0.2
 79 | 
 80 |         flag = 'p'
 81 |         c_put = c_analytical.theta(flag, S, K, t, r, sigma, q)
 82 |         py_put = py_analytical.theta(flag, S, K, t, r, sigma, q)
 83 |         self.assertTrue(almost_equal(c_put, py_put))
 84 | 
 85 |         flag = 'c'
 86 |         c_call = c_analytical.theta(flag, S, K, t, r, sigma, q)
 87 |         py_call = py_analytical.theta(flag, S, K, t, r, sigma, q)
 88 |         self.assertTrue(almost_equal(c_call, py_call))
 89 | 
 90 |     def test_analytical_vega(self):
 91 |         S = 49
 92 |         K = 50
 93 |         sigma = .2
 94 |         r = .05
 95 |         t = 0.3846
 96 |         q = 0.2
 97 | 
 98 |         flag = 'p'
 99 |         c_put = c_analytical.vega(flag, S, K, t, r, sigma, q)
100 |         py_put = py_analytical.vega(flag, S, K, t, r, sigma, q)
101 |         self.assertTrue(almost_equal(c_put, py_put))
102 | 
103 |         flag = 'c'
104 |         c_call = c_analytical.vega(flag, S, K, t, r, sigma, q)
105 |         py_call = py_analytical.vega(flag, S, K, t, r, sigma, q)
106 |         self.assertTrue(almost_equal(c_call, py_call))
107 | 
108 |     def test_numerical_delta(self):
109 |         S = 49
110 |         K = 50
111 |         sigma = .2
112 |         r = .05
113 |         t = 0.3846
114 |         q = 0.2
115 | 
116 |         flag = 'p'
117 |         c_put = c_numerical.delta(flag, S, K, t, r, sigma, q)
118 |         py_put = py_numerical.delta(flag, S, K, t, r, sigma, q)
119 |         self.assertTrue(almost_equal(c_put, py_put))
120 | 
121 |         flag = 'c'
122 |         c_call = c_numerical.delta(flag, S, K, t, r, sigma, q)
123 |         py_call = py_numerical.delta(flag, S, K, t, r, sigma, q)
124 |         self.assertTrue(almost_equal(c_call, py_call))
125 | 
126 |     def test_numerical_gamma(self):
127 |         S = 49
128 |         K = 50
129 |         sigma = .2
130 |         r = .05
131 |         t = 0.3846
132 |         q = 0.2
133 | 
134 |         flag = 'p'
135 |         c_put = c_numerical.gamma(flag, S, K, t, r, sigma, q)
136 |         py_put = py_numerical.gamma(flag, S, K, t, r, sigma, q)
137 |         self.assertTrue(almost_equal(c_put, py_put))
138 | 
139 |         flag = 'c'
140 |         c_call = c_numerical.gamma(flag, S, K, t, r, sigma, q)
141 |         py_call = py_numerical.gamma(flag, S, K, t, r, sigma, q)
142 |         self.assertTrue(almost_equal(c_call, py_call))
143 | 
144 |     def test_numerical_rho(self):
145 |         S = 49
146 |         K = 50
147 |         sigma = .2
148 |         r = .05
149 |         t = 0.3846
150 |         q = 0.2
151 | 
152 |         flag = 'p'
153 |         c_put = c_numerical.rho(flag, S, K, t, r, sigma, q)
154 |         py_put = py_numerical.rho(flag, S, K, t, r, sigma, q)
155 |         self.assertTrue(almost_equal(c_put, py_put))
156 | 
157 |         flag = 'c'
158 |         c_call = c_numerical.rho(flag, S, K, t, r, sigma, q)
159 |         py_call = py_numerical.rho(flag, S, K, t, r, sigma, q)
160 |         self.assertTrue(almost_equal(c_call, py_call))
161 | 
162 |     def test_numerical_theta(self):
163 |         S = 49
164 |         K = 50
165 |         sigma = .2
166 |         r = .05
167 |         t = 0.3846
168 |         q = 0.2
169 | 
170 |         flag = 'p'
171 |         c_put = c_numerical.theta(flag, S, K, t, r, sigma, q)
172 |         py_put = py_numerical.theta(flag, S, K, t, r, sigma, q)
173 |         self.assertTrue(almost_equal(c_put, py_put))
174 | 
175 |         flag = 'c'
176 |         c_call = c_numerical.theta(flag, S, K, t, r, sigma, q)
177 |         py_call = py_numerical.theta(flag, S, K, t, r, sigma, q)
178 |         self.assertTrue(almost_equal(c_call, py_call))
179 | 
180 |     def test_numerical_vega(self):
181 |         S = 49
182 |         K = 50
183 |         sigma = .2
184 |         r = .05
185 |         t = 0.3846
186 |         q = 0.2
187 | 
188 |         flag = 'p'
189 |         c_put = c_numerical.vega(flag, S, K, t, r, sigma, q)
190 |         py_put = py_numerical.vega(flag, S, K, t, r, sigma, q)
191 |         self.assertTrue(almost_equal(c_put, py_put))
192 | 
193 |         flag = 'c'
194 |         c_call = c_numerical.vega(flag, S, K, t, r, sigma, q)
195 |         py_call = py_numerical.vega(flag, S, K, t, r, sigma, q)
196 |         self.assertTrue(almost_equal(c_call, py_call))
197 | 
198 | 
199 | if __name__ == '__main__':
200 |     unittest.main()
201 | 


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black_scholes_merton/test_implied_volatility.py:
--------------------------------------------------------------------------------
 1 | # -----------------------------------------------------------------------------
 2 | # IMPORTS
 3 | 
 4 | # Standard library imports
 5 | import unittest
 6 | 
 7 | # Related third party imports
 8 | 
 9 | # Local application/library specific imports
10 | from py_vollib.black_scholes_merton import black_scholes_merton as c_black_scholes_merton
11 | from py_vollib.black_scholes_merton.implied_volatility import implied_volatility as c_implied_volatility
12 | from py_vollib.ref_python.black_scholes_merton import black_scholes_merton as py_black_scholes_merton
13 | from py_vollib.ref_python.black_scholes_merton.implied_volatility import implied_volatility as py_implied_volatility
14 | from tests.test_utils import almost_equal
15 | 
16 | 
17 | class TestImpliedVolatility(unittest.TestCase):
18 | 
19 |     def test_implied_volatility_put(self):
20 |         S = 100
21 |         K = 100
22 |         sigma = .232323232
23 |         t = .5
24 |         r = .01
25 |         q = .05
26 |         flag = 'p'
27 | 
28 |         c_price = c_black_scholes_merton(flag, S, K, t, r, sigma, q)
29 |         py_price = py_black_scholes_merton(flag, S, K, t, r, sigma, q)
30 | 
31 |         c_iv = c_implied_volatility(c_price, S, K, t, r, q, flag)
32 |         py_iv = py_implied_volatility(py_price, S, K, t, r, q, flag)
33 |         self.assertTrue(almost_equal(c_iv, py_iv))
34 | 
35 |     def test_implied_volatility_call(self):
36 |         S = 100
37 |         K = 100
38 |         sigma = .232323232
39 |         t = .5
40 |         r = .01
41 |         q = .05
42 |         flag = 'c'
43 | 
44 |         c_price = c_black_scholes_merton(flag, S, K, t, r, sigma, q)
45 |         py_price = py_black_scholes_merton(flag, S, K, t, r, sigma, q)
46 | 
47 |         c_iv = c_implied_volatility(c_price, S, K, t, r, q, flag)
48 |         py_iv = py_implied_volatility(py_price, S, K, t, r, q, flag)
49 |         self.assertTrue(almost_equal(c_iv, py_iv))
50 | 
51 | 
52 | if __name__ == '__main__':
53 |     unittest.main()
54 | 


--------------------------------------------------------------------------------
/tests/test_vollib_vs_ref_python_values/black_scholes_merton/test_price.py:
--------------------------------------------------------------------------------
 1 | # -----------------------------------------------------------------------------
 2 | # IMPORTS
 3 | 
 4 | # Standard library imports
 5 | import unittest
 6 | 
 7 | # Related third party imports
 8 | 
 9 | # Local application/library specific imports
10 | from py_vollib.black_scholes_merton import black_scholes_merton as c_black_scholes_merton
11 | from py_vollib.ref_python.black_scholes_merton import black_scholes_merton as py_black_scholes_merton
12 | from tests.test_utils import almost_equal
13 | 
14 | 
15 | class TestPrice(unittest.TestCase):
16 | 
17 |     def test_black_put(self):
18 |         S = 100
19 |         K = 95
20 |         r = .01
21 |         q = .05
22 |         t = .5
23 |         sigma = .2
24 |         flag = 'p'
25 | 
26 |         c_price = c_black_scholes_merton(flag, S, K, t, r, sigma, q)
27 |         py_price = py_black_scholes_merton(flag, S, K, t, r, sigma, q)
28 |         self.assertTrue(almost_equal(c_price, py_price))
29 | 
30 |     def test_black_call(self):
31 |         S = 100
32 |         K = 95
33 |         r = .01
34 |         q = .05
35 |         t = .5
36 |         sigma = .2
37 |         flag = 'c'
38 | 
39 |         c_price = c_black_scholes_merton(flag, S, K, t, r, sigma, q)
40 |         py_price = py_black_scholes_merton(flag, S, K, t, r, sigma, q)
41 |         self.assertTrue(almost_equal(c_price, py_price))
42 | 
43 | 
44 | if __name__ == '__main__':
45 |     unittest.main()
46 | 


--------------------------------------------------------------------------------