py_vollib_vectorized

https://py-vollib-vectorized.readthedocs.io
Admin
py_vollib_vectorized is a Python library that provides vectorized option pricing and Greeks...
Tokens:5,213
Snippets:29
Trust Score:8.3
Update:8 months ago
Show doc for...
Tokens:
Raw
### Demonstrate Monkey-Patching in py_vollib_vectorized

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/quick_start

This example demonstrates how py_vollib_vectorized monkey-patches the `py_vollib.black.black()` function to accept vectorized inputs. It shows the confirmation of the patch and a sample calculation using vectorized inputs, returning a numpy array.

```python
>>> from py_vollib.black import black
>>> import py_vollib_vectorized
>>> black # check if the monkey-patch is applied.
Vectorized <vectorized_black()>
>>> flag = 'c'  # 'c' for call, 'p' for put
>>> S = 95  # price of the underlying
>>> K = 100  # strike
>>> t = .2  # annualized time to expiration
>>> r = .2  # interest-free rate
>>> sigma = .2  # implied volatility
>>> black_scholes(flag, S, K, t, r, sigma, return_as='numpy')
array([2.89558836])
```

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

### Install py_vollib_vectorized from source

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/installation

These commands clone the py_vollib_vectorized repository from GitHub, navigate into the directory, and then install it using the setup.py script. This method is useful for development or when you need the latest unreleased version.

```bash
git clone https://github.com/marcdemers/py_vollib_vectorized
cd py_vollib_vectorized
python setup.py
```

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

### Vectorized Option Greeks Calculation with Mixed Data Types

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/quick_start

This example illustrates the data format handling in py_vollib_vectorized, specifically for the `implied_volatility` function. It shows how mixed input types (list, tuple, pandas Series) are accepted and how the output can be returned as a pandas Series, handling cases where results might be NaN.

```python
>>> from py_vollib.black_scholes.implied_volatility import implied_volatility
>>> import py_vollib_vectorized
>>> price = 0.2
>>> flag = ['c', 'p']  # 'c' for call, 'p' for put
>>> S = (95, 10)  # price of the underlying
>>> K = 100  # strike
>>> t = pd.Series([.2])  # annualized time to expiration
>>> r = .2  # interest-free rate
>>> sigma = .2  # implied volatility
>>> implied_volatility(price, S, K, t, r, flag, return_as='series')
0    0.034543
1         NaN
Name: IV, dtype: float64
```

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

### Install py_vollib_vectorized via pip

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/installation

This command installs the py_vollib_vectorized library using the pip package manager. Ensure you have pip installed and Python 3.5+ is available.

```bash
pip install py_vollib_vectorized
```

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

### Get All Greeks with py_vollib_vectorized API

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/api/api

Calculates all option greeks (delta, gamma, theta, rho, vega) for a given set of parameters using specified pricing models. It supports broadcasting for input arrays and can return results as a DataFrame, JSON, or dictionary.

```python
from py_vollib_vectorized.api import get_all_greeks

flag = ['c', 'p']
S = 95
K = [100, 90]
t = .2
r = .2
sigma = .2

result = get_all_all_greeks(flag, S, K, t, r, sigma, model='black_scholes', return_as='dict')
print(result)
```

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

### Calculate Gamma using py-vollib-vectorized

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/greeks

Calculates the gamma of an option contract using specified pricing models. Broadcasting is applied to inputs for efficient computation. Requires py_vollib and py_vollib_vectorized libraries.

```python
import py_vollib.black_scholes.greeks.numerical
import py_vollib_vectorized

flag = ['c', 'p']
S = 95
K = [100, 90]
t = .2
r = .2
sigma = .2

# Using numerical calculation (for comparison)
print(py_vollib.black_scholes.greeks.numerical.gamma(flag, S, K, t, r, sigma, return_as='numpy'))

# Using vectorized calculation
print(py_vollib_vectorized.vectorized_gamma(flag, S, K, t, r, sigma, model='black_scholes', return_as='numpy'))
```

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

### Calculate Vega using py-vollib-vectorized

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/greeks

Calculates the vega of an option contract using the specified pricing model. Broadcasting is applied to inputs. Supports returning results as pandas Series, DataFrame, or numpy array.

```python
import py_vollib.black_scholes.greeks.numerical
import py_vollib_vectorized

flag = ['c', 'p']
S = 95
K = [100, 90]
t = .2
r = .2
sigma = .2

# Using numerical vega
print(py_vollib.black_scholes.greeks.numerical.vega(flag, S, K, t, r, sigma, return_as='numpy'))

# Using vectorized vega (equivalent)
print(py_vollib_vectorized.vectorized_vega(flag, S, K, t, r, sigma, model='black_scholes', return_as='numpy'))
```

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

### Calculate Delta using py-vollib-vectorized

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/greeks

Calculates the delta of an option contract using specified pricing models. Broadcasting is applied to inputs for efficient computation. Requires py_vollib and py_vollib_vectorized libraries.

```python
import py_vollib.black_scholes.greeks.numerical
import py_vollib_vectorized

flag = ['c', 'p']
S = 95
K = [100, 90]
t = .2
r = .2
sigma = .2

# Using numerical calculation (for comparison)
print(py_vollib.black_scholes.greeks.numerical.delta(flag, S, K, t, r, sigma, return_as='numpy'))

# Using vectorized calculation
print(py_vollib_vectorized.vectorized_delta(flag, S, K, t, r, sigma, model='black_scholes', return_as='numpy'))
```

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

### Vectorized Black-Scholes-Merton Model

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/models

Prices an option using the vectorized Black-Scholes-Merton model. Broadcasting is applied to the inputs.

```APIDOC
## POST /models/vectorized_black_scholes_merton

### Description
Prices an option using the vectorized Black-Scholes-Merton model. Broadcasting is applied on the inputs.

### Method
POST

### Endpoint
/models/vectorized_black_scholes_merton

### Parameters
#### Request Body
- **flag** (list[str]) - Required - For each contract, this should be specified as 'c' for a call option and 'p' for a put option.
- **S** (list[float]) - Required - The underlying asset price.
- **K** (list[float]) - Required - The strike price.
- **t** (float) - Required - The annualized time to expiration. Must be positive. For small TTEs, use a small value (1e-3).
- **r** (float) - Required - The interest free rate.
- **sigma** (float) - Required - The Implied Volatility (as a decimal, i.e. 0.10 for 10%).
- **q** (float) - Required - The annualized continuous dividend yield.
- **return_as** (str) - Optional - To return as a `pd.Series` object, use "series". To return as a `pd.DataFrame` object, use "dataframe". Any other value will return a `numpy.array` object. Defaults to 'dataframe'.
- **dtype** (type) - Optional - Data type. Defaults to `numpy.float64`.

### Request Example
```json
{
  "flag": ["c", "p"],
  "S": [95, 99],
  "K": [100, 90],
  "t": 0.2,
  "r": 0.2,
  "sigma": 0.2,
  "q": 0,
  "return_as": "numpy"
}
```

### Response
#### Success Response (200)
- **prices** (numpy.array or pd.Series or pd.DataFrame) - The price of the option.

#### Response Example
```json
{
  "prices": [2.89558836, 0.23536284]
}
```
```

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

### Vectorized Black-Scholes Model

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/models

Prices an option using the vectorized Black-Scholes model. Broadcasting is applied to the inputs.

```APIDOC
## POST /models/vectorized_black_scholes

### Description
Prices an option using the vectorized Black-Scholes model. Broadcasting is applied on the inputs.

### Method
POST

### Endpoint
/models/vectorized_black_scholes

### Parameters
#### Request Body
- **flag** (list[str]) - Required - For each contract, this should be specified as 'c' for a call option and 'p' for a put option.
- **S** (float) - Required - The underlying asset price.
- **K** (list[float]) - Required - The strike price.
- **t** (float) - Required - The annualized time to expiration. Must be positive. For small TTEs, use a small value (1e-3).
- **r** (float) - Required - The interest free rate.
- **sigma** (float) - Required - The Implied Volatility (as a decimal, i.e. 0.10 for 10%).
- **return_as** (str) - Optional - To return as a `pd.Series` object, use "series". To return as a `pd.DataFrame` object, use "dataframe". Any other value will return a `numpy.array` object. Defaults to 'dataframe'.
- **dtype** (type) - Optional - Data type. Defaults to `numpy.float64`.

### Request Example
```json
{
  "flag": ["c", "p"],
  "S": 95,
  "K": [100, 90],
  "t": 0.2,
  "r": 0.2,
  "sigma": 0.2,
  "return_as": "numpy"
}
```

### Response
#### Success Response (200)
- **prices** (numpy.array or pd.Series or pd.DataFrame) - The price of the option.

#### Response Example
```json
{
  "prices": [2.89558836, 0.61109351]
}
```
```

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

### Calculate Rho using py-vollib-vectorized

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/greeks

Calculates the rho of an option contract using specified pricing models. Broadcasting is applied to inputs for efficient computation. Requires py_vollib and py_vollib_vectorized libraries.

```python
import py_vollib.black_scholes.greeks.numerical
import py_vollib_vectorized

flag = ['c', 'p']
S = 95
K = [100, 90]
t = .2
r = .2
sigma = .2

# Using numerical calculation (for comparison)
print(py_vollib.black_scholes.greeks.numerical.rho(flag, S, K, t, r, sigma, return_as='numpy'))

# Using vectorized calculation
print(py_vollib_vectorized.vectorized_rho(flag, S, K, t, r, sigma, model='black_scholes', return_as='numpy'))
```

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

### Price Options using Vectorized Black-Scholes-Merton Model (Python)

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/models

Calculates option prices using the vectorized Black-Scholes-Merton model, which accounts for dividend yields. The function supports broadcasting and allows the output format to be a DataFrame, Series, or NumPy array. It depends on the py_vollib_vectorized library.

```python
import py_vollib_vectorized

flag = ['c', 'p']
S = [95, 99]
K = [100, 90]
t = .2
r = .2
sigma = .2
q = 0

prices = py_vollib_vectorized.vectorized_black_scholes_merton(flag, S, K, t, r, sigma, q, return_as='numpy')
print(prices)
```

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

### Price Options using Vectorized Black-Scholes Model (Python)

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/models

Computes the price of an option using the vectorized Black-Scholes model. This function handles broadcasting for inputs and can return results as a pandas DataFrame, Series, or a NumPy array. It requires the py_vollib_vectorized library.

```python
import py_vollib_vectorized

flag = ['c', 'p']
S = 95
K = [100, 90]
t = .2
r = .2
sigma = .2

prices = py_vollib_vectorized.vectorized_black_scholes(flag, S, K, t, r, sigma, return_as='numpy')
print(prices)
```

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

### Calculate Theta using py-vollib-vectorized

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/greeks

Calculates the theta of an option contract using the specified pricing model. Broadcasting is applied to inputs. Supports returning results as pandas Series, DataFrame, or numpy array.

```python
import py_vollib.black_scholes.greeks.numerical
import py_vollib_vectorized

flag = ['c', 'p']
S = 95
K = [100, 90]
t = .2
r = .2
sigma = .2

# Using numerical theta
print(py_vollib.black_scholes.greeks.numerical.theta(flag, S, K, t, r, sigma, return_as='numpy'))

# Using vectorized theta (equivalent)
print(py_vollib_vectorized.vectorized_theta(flag, S, K, t, r, sigma, model='black_scholes', return_as='numpy'))
```

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

### Price Future Options using Vectorized Black Model (Python)

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/models

Calculates the price of a future option using the vectorized Black model. It supports broadcasting on input parameters and allows specifying the return type as a DataFrame, Series, or NumPy array. Dependencies include py_vollib_vectorized and numpy.

```python
import py_vollib_vectorized

flag = ['c', 'p']
F = 95
K = [100, 90]
t = .2
r = .2
sigma = .2

prices = py_vollib_vectorized.vectorized_black(flag, F, K, t, r, sigma, return_as='numpy')
print(prices)
```

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

### Vectorized Black Model

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/models

Prices a Future option using the vectorized Black model. Broadcasting is applied to the inputs.

```APIDOC
## POST /models/vectorized_black

### Description
Prices a Future option using the vectorized Black model. Broadcasting is applied on the inputs.

### Method
POST

### Endpoint
/models/vectorized_black

### Parameters
#### Request Body
- **flag** (list[str]) - Required - For each contract, this should be specified as 'c' for a call option and 'p' for a put option.
- **F** (float) - Required - The price of the underlying asset.
- **K** (list[float]) - Required - The strike price.
- **t** (float) - Required - The annualized time to expiration. Must be positive. For small TTEs, use a small value (1e-3).
- **r** (float) - Required - The interest free rate.
- **sigma** (float) - Required - The Implied Volatility (as a decimal, i.e. 0.10 for 10%).
- **return_as** (str) - Optional - To return as a `pd.Series` object, use "series". To return as a `pd.DataFrame` object, use "dataframe". Any other value will return a `numpy.array` object. Defaults to 'dataframe'.
- **dtype** (type) - Optional - Data type. Defaults to `numpy.float64`.

### Request Example
```json
{
  "flag": ["c", "p"],
  "F": 95,
  "K": [100, 90],
  "t": 0.2,
  "r": 0.2,
  "sigma": 0.2,
  "return_as": "numpy"
}
```

### Response
#### Success Response (200)
- **prices** (numpy.array or pd.Series or pd.DataFrame) - The price of the option.

#### Response Example
```json
{
  "prices": [1.53408169, 1.38409245]
}
```
```

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

### Price DataFrame with py_vollib_vectorized API

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/api/api

Prices a DataFrame of option contracts by specifying column names for each input parameter. This function can calculate option prices, implied volatilities, and greeks in a single call, depending on which columns are provided. It supports in-place modification of the DataFrame.

```python
import pandas as pd
from py_vollib_vectorized.api import price_dataframe

df = pd.DataFrame()
df['Flag'] = ['c', 'p']
df['S'] = 95
df['K'] = [100, 90]
df['T'] = 0.2
df['R'] = 0.2
df['IV'] = 0.2

result_df = price_dataframe(df, flag_col='Flag', underlying_price_col='S', strike_col='K', annualized_tte_col='T', riskfree_rate_col='R', sigma_col='IV', model='black_scholes', inplace=False)
print(result_df)
```

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

### Calculate Implied Volatility (Black Model) - py-vollib-vectorized

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/iv

Calculates implied volatility using the Black model, specifically for option/future contracts. This function is optimized for speed and accuracy, accepting diverse input formats and utilizing broadcasting. It requires the forward price (F) as an input.

```python
import py_vollib.black.implied_volatility
import py_vollib_vectorized

price = 0.10
F = 95
K = [100, 90]
t = .2
r = .2
flag = ['c', 'p']

# Using py_vollib.black
print(py_vollib.black.implied_volatility.implied_volatility(price, F, K, r, t, flag, return_as='numpy'))

# Using py_vollib_vectorized (equivalent)
print(py_vollib_vectorized.vectorized_implied_volatility_black(price, F, K, r, t, flag, return_as='numpy'))
```

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

### Calculate Implied Volatility (Black-Scholes-Merton) - py-vollib-vectorized

Source: https://py-vollib-vectorized.readthedocs.io/en/latest/pkg_ref/iv

Calculates implied volatility using the Black-Scholes-Merton model. It accepts various input types like lists, tuples, floats, pd.Series, or numpy.arrays, applying broadcasting for efficiency. The function supports specifying dividend yield and error handling.

```python
import py_vollib.black_scholes_merton.implied_volatility
import py_vollib_vectorized

price = 0.10
S = 95
K = [100, 90]
t = .2
r = .2
flag = ['c', 'p']

# Using py_vollib.black_scholes_merton
print(py_vollib.black_scholes_merton.implied_volatility.implied_volatility(price, S, K, t, r, flag, q=0, return_as='numpy'))

# Using py_vollib_vectorized (equivalent)
print(py_vollib_vectorized.vectorized_implied_volatility(price, S, K, t, r, flag, q=0, model='black_scholes_merton', return_as='numpy'))
```
Tokens:
Raw