Invirtiendo la fórmula Black para el precio del Cap para encontrar la volatilidad implícita Black

Question

Estoy resolviendo el siguiente problema como parte de Modelos de tipos de interés clase en Coursera

Estoy teniendo dificultades para utilizar el solucionador de root no lineal para invertir la fórmula de Black para el precio de Cap con el fin de obtener una volatilidad implícita de Black que se utilizará más para fines de calibración. Mi código de Python se adjunta a continuación.

import numpy as np
import math
import scipy
from scipy import optimize
from scipy import stats

Time = [0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4]
ForwardRates = [0.06, 0.08, 0.09, 0.10, 0.10, 0.10, 0.09, 0.09]
CapPrices = [0.20, 0.80, 1.20, 1.60]
SimpleRates = []
DiscountFactors = []

SimpleRates.append(ForwardRates[0])
DiscountFactors.append(1/(1+Time[0]*SimpleRates[0]))

for i in range(1, len(Time)):
    SimpleRates.append(((1+0.5*ForwardRates[i])*(1+Time[i-1]*SimpleRates[i-1])-1)/Time[i])
    DiscountFactors.append(1/(1+Time[i]*SimpleRates[i]))

SwapRates = []
for k in range(1, len(Time)):
    s = sum(DiscountFactors[i] for i in range(1, k + 1))
    SwapRates.append((DiscountFactors[0] - DiscountFactors[k])/(0.5*s))

def d1(i, sigma):
    return (np.log(ForwardRates[i]/SwapRates[i])+0.5*math.pow(sigma, 2)*Time[i-1])/(sigma*math.sqrt(Time[i-1]))

def d2(i, sigma):
    return (np.log(ForwardRates[i]/SwapRates[i])+math.pow(sigma, 2)*Time[i-1])/(sigma*math.sqrt(Time[i-1])) - sigma*math.sqrt(Time[i-1])

def caplet(begin, end, sigma):
    return 0.5*DiscountFactors[end]*(ForwardRates[end]*scipy.stats.norm.cdf(d1(end, sigma))-SwapRates[end]*scipy.stats.norm.cdf(d2(end, sigma)))

def cap(end, sigma):
    price = 0
    for j in range(1, end + 1):
        price += caplet(j - 1, j, sigma)
    return price

s = scipy.optimize.bisect(lambda sigma: cap(1, sigma) - CapPrices[0], 0.0005, 0.5)

Me da error que f(a) y f(b) deben tener signos diferentes independientemente de mi elección de intervalo. ¿Qué método de resolución de raíces debo utilizar en Python para evitarlo? ¿Hay algo más que esté haciendo mal?

Answer 1

Tenga en cuenta que los precios máximos se dan en %, por lo que su vector de precios máximos debería ser

CapPrices = [0.002, 0.008, 0.012, 0.016]

mientras tienes

CapPrices = [0.20, 0.80, 1.20, 1.60]

El código debería encontrar la solución sin problemas para estos precios máximos.

Fíjate que para tus CapPrices mal dados no hay solución. Aviso:

${Caplet(F,\sigma,t) \to F} $ como $\sigma \to \infty$ . Por lo tanto, el valor más alto de la cápsula es $F$ pero usted está tratando de encontrar una solución para aproximadamente $2.5F$ es decir, (0,20 / 0,08 = 2,5), por lo que el solucionador falla.

También he observado que tienes un error en tu fórmula en d2, debería ser igual a:

return (np.log(ForwardRates[i]/SwapRates[i])+0.5*math.pow(sigma, 2)*Time[i-1])/(sigma*math.sqrt(Time[i-1])) - sigma*math.sqrt(Time[i-1])

mientras que usted tiene (falta multiplicar por 0,5)

return (np.log(ForwardRates[i]/SwapRates[i])+math.pow(sigma, 2)*Time[i-1])/(sigma*math.sqrt(Time[i-1])) - sigma*math.sqrt(Time[i-1])