Griegos mixtos en Python - Cómo trazar lo siguiente

Question

Estoy interesado en los griegos con Black-Scholes. En este caso, tengo la fórmula de python para calcular el griego llamado "Vanna", es decir: $\frac{\partial^2 P}{\partial \sigma \partial S}$ la sensibilidad del valor de la opción P con respecto a un movimiento conjunto del subyacente y la volatilidad.

Consideremos ahora el siguiente ejemplo, con S = [100,120] una lista de 50 puntos equiespaciados y $\sigma$ = [0.05,0.7] otra lista de 50 puntos equiespaciados, en el código siguiente soy capaz de generar el gráfico de esta grieta, con respecto a cada elemento de S y $\sigma$ es decir, con respecto al primer elemento de S y al primer elemento de $\sigma$ después con respecto al segundo elemento de ambas listas, hasta el último elemento de ambas listas.

Mi pregunta es: ¿Cómo puedo tomar todas las combinaciones posibles, entre estas 2 listas? ¿Tal vez se pueda hacer con un gráfico tridimensional? ¿Cómo puedo hacer esto en Python?

import numpy as np
import matplotlib.pyplot as plt
underlying = np.linspace(100,120,50)
K = 100
T = 1
r = 0
sigma = np.linspace(0.05,0.7,50)
def Vanna_(S, K, T, r, sigma):
    lista = []
    d1 = (np.log(S / K) + (r + 1/2 * sigma ** 2) * T) / (sigma * np.sqrt(T))
    d2 = d1-vol*T**(1/2)
    return (1 / np.sqrt(2 * np.pi) * S  * np.exp(-d1 ** 2 * 1/2) * np.sqrt(T))/S * (1- d1/(sigma*np.sqrt(T)))
plt.plot(Vanna_(underlying, K, T, r, sigma))

Answer 1

¿Algo así?

from mpl_toolkits import mplot3d
from itertools import product

S = np.linspace(100,120)
vols = np.linspace(0.05,0.7)
combs = list(product(S, vols))

values = [Vanna_(underlying, K, T, r, sigma) for underlying, sigma in combs]
x, y = np.hsplit(np.array(combs), 2)

fig = plt.figure()
ax = plt.axes(projection="3d")
ax.scatter3D(x, y, values, c=values);

Answer 2

Aquí hay otra solución utilizando Plotly .

En primer lugar permítame corregir un error tipográfico en su código

def Vanna_(S, K, T, r, sigma):
    lista = []
    d1 = (np.log(S / K) + (r + 1/2 * sigma ** 2) * T) / (sigma * np.sqrt(T))
    d2 = d1-sigma*T**(1/2)
    return (1 / np.sqrt(2 * np.pi) * S  * np.exp(-d1 ** 2 * 1/2) * np.sqrt(T))/S * (1- d1/(sigma*np.sqrt(T)))

Entonces déjame usar pandas para formatear el resultado

import numpy as np
import pandas

K = 100
T = 1
r = 0

underlying_1d = np.linspace(100,120,25)
sigma_1d     = np.linspace(0.05,0.3,50)

underlying, sigma = np.meshgrid(underlying_1d, sigma_1d)

Vanna_df = pandas.DataFrame(
    Vanna_(underlying, K, T, r, sigma),
    columns=underlying_1d,
    index=sigma_1d
    )
Vanna_df.index.name  = 'volatility'
Vanna_df.columns.name = 'Strike'
Vanna_df.iloc[:10,:10]

Ahora un gráfico de contorno

import plotly.graph_objects as go

fig = go.Figure(data =
    go.Contour(
        z=Vanna_df.values,
        x=underlying_1d,
        y=sigma_1d
    ))
fig.update_layout(title='Vanna', autosize=False, 
                  xaxis_title='volatility', yaxis_title='strike',
                  width=700, height=500)
fig.show()

y su parcela de superficie

import plotly.graph_objects as go

fig = go.Figure(data =
    go.Surface(
        z=Vanna_df.values,
        x=underlying_1d,
        y=sigma_1d
    ))
fig.update_traces(contours_z=dict(show=True, usecolormap=True,
                                  highlightcolor="limegreen", project_z=True))

fig.update_layout(title='Vanna', autosize=False,
                  width=700, height=500)
fig.show()

(Nota: no es mi costumbre publicar código en quant.stackexchange pero me estoy entrenando para usar Plotly hoy en día...)