Si usted toma Quantuple las cosas un poco más, usted puede realmente ver si va a largo de sesgo. Puede ver fácilmente que la dependencia de la convexidad demasiado (aunque debería ser obvio que va a largo convexidad).
Así, en primer lugar, necesitamos algunos sonrisa parametrisation que nos permite controlar fácilmente la convexidad y el sesgo. Me fui con un uno;
$$\mathrm{convexidad} = \mathrm{C} = \left. \frac{\partial^2 \sigma}{\partial K^2} \right|_{K=F} \\
\mathrm{sesgar} = \mathrm{S} = \left. \frac{\partial \sigma}{\partial K} \derecho|_{K=F} \\
\sigma_{\mathrm{atm}} = \sigma(F)
$$
lo que da:
$$
\frac{1}{2} C (K-F)^2 + S(K-F) + \sigma_\mathrm{atm}
$$
*Tenga en cuenta que entiendo que este no es un buen sonrisa, estoy usando como un simple ejemplo.
Entonces, si usted mira una bonita gama extrema de las sonrisas;
$$
-0.001 \leqslant \mathrm{S} \leqslant 0.001\\
0 \leqslant \mathrm{C} \leqslant 0.0001\\
\sigma_\mathrm{atm} = 20\%
$$
tienes un montón de imágenes como Quantuple en la otra respuesta:
Pero, que podemos hacer mejor:
Así que, sí, son mucho sesgo. Pero sólo una muy pequeña cantidad - es mucho más que la convexidad.
Aquí está el código de python para esto si quieres tener un lío con ella.
import numpy as np
def CND(X):
a1,a2,a3,a4,a5 = 0.31938153, -0.356563782, 1.781477937, -1.821255978, 1.330274429
L = np.abs(X)
K = 1.0 / (1.0 + 0.2316419 * L)
w = 1.0 - 1.0 / np.sqrt(2*np.pi)*np.exp(-L*L/2.) * (a1*K + a2*K*K + a3*np.power(K,3) + a4*np.power(K,4) + a5*np.power(K,5))
if X<0:
w = 1.0-w
return w
def BlackSholes(cp,S,X,T,r,v):
d1 = (np.log(S/X)+(r+v*v/2.)*T)/(v*np.sqrt(T))
d2 = d1-v*np.sqrt(T)
if cp=='c':
return S*CND(d1)-X*np.exp(-r*T)*CND(d2)
else:
return X*np.exp(-r*T)*CND(-d2)-S*CND(-d1)
def C(S,X,T,r,v):
return BlackSholes("c", S, X, T, r, v)
def P(S,X,T,r,v):
return BlackSholes("p", S, X, T, r, v)
def B(r,t):
return np.exp(-r*t)
def vol(k, vol_atm, convexity, skew, atm=100, max_vol=1):
v = 0.5*convexity*k**2 + (skew - convexity*atm)*k + vol_atm + 0.5*convexity*atm**2 - skew*atm
return max(1e-5,min(v, max_vol))
import scipy.integrate as integrate
import scipy.special as special
def var_swap(S,T,r,atm_vol, convexity, skew):
F = S/B(r,T)
return np.sqrt((2 / (T*B(r,T))) * (integrate.quad(lambda k: P(S, k, T, r, vol(k, atm_vol, convexity, skew, atm=F)) * k**-2, 0, F)[0] + integrate.quad(lambda k: C(S, k, T, r, vol(k, atm_vol, convexity, skew, atm=F)) * k**-2, F, F*5)[0]))
r = 0.0
T = 1.0
S = 100.0
F = S/B(r,T)
print F
atm_vol = 0.2
convexity = 0.0001
skew = 0.001
ks = [k for k in range(1, int(F*2))]
n_scenarios = 20
skews = np.linspace(-skew, skew, n_scenarios)
convexities = np.linspace(0, convexity, n_scenarios)
plot_smiles = False
if plot_smiles:
import colorsys
blues = [colorsys.hsv_to_rgb(h, 1, 1) for h in np.linspace(0.5, 0.65, n_scenarios)]
reds = [colorsys.hsv_to_rgb(h, 1, 1) for h in np.linspace(0.0, 0.15, n_scenarios)]
from matplotlib import pyplot
fig = pyplot.figure()
ax_smiles = fig.add_subplot(1,1,1)
ax_opts = ax_smiles.twinx()
for i, (convexity, skew) in enumerate(zip(convexities, skews)):
vols = [vol(k, atm_vol, convexity, skew, atm=F) for k in ks]
opts = [BlackSholes("p" if k < F else "c", S, k, T, r, vol(k, atm_vol, convexity, skew, atm=F)) * k**-2 for k in ks]
ax_smiles.plot(ks, vols, color=blues[i])
ax_opts.plot(ks, opts, color=reds[i])
pyplot.show()
else:
CC = np.linspace(0, convexity,n_scenarios)
SS = np.linspace(-skew, skew,n_scenarios)
CC, SS = np.meshgrid(CC, SS)
VV = np.empty(CC.shape)
for i in range(CC.shape[0]):
for j in range(CC.shape[1]):
VV[i,j] = var_swap(S, T, r, atm_vol, CC[i,j], SS[i,j])
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(CC, SS, VV, rstride=1, cstride=1, cmap=cm.jet, linewidth=0, antialiased=True)
ax.set_xlabel("Convexity")
ax.set_ylabel("Skew")
ax.set_zlabel("Var. Swap par rate")
ax.set_ylim(ax.get_ylim()[::-1])
plt.show()
Hay un problema aquí, sin embargo - este es el valor teórico de una variación de intercambio. El mercado no es el comercio de estas de acuerdo con el valor teórico, hay una diferencia que no he visto una forma de contabilizar todavía. La solución a esto es que puede almacenar una tabla de varswap la par de los diferenciales de tasas que pueden ser interpelados y se aplica a varswaps en las correspondientes fechas de inicio y fin.
Esta difusión no viene de la estocástico vol, me parece ser una especie de seguro contra el desagradablemente grandes costos cuando algo sucede. La alternativa es el comercio de corredor de swaps de varianza (es decir, la varianza sólo se devenga cuando el índice está dentro de un corredor), para limitar la probabilidad de este inconveniente.
Usted puede conseguir fácilmente sesgar la exposición con oficios como el de arriba, aunque, si la varianza es sólo acumular cuando el subyacente está por encima/por debajo de un cierto nivel, entonces usted va a ser largo/corto de sesgo cuando el subyacente es cerca de la barrera - porque cuando sólo estás buscando en uno de los lados de un punto, el sesgo y la convexidad tener efectos similares.