-
Notifications
You must be signed in to change notification settings - Fork 0
/
derivativosempy03.py
90 lines (75 loc) · 3.57 KB
/
derivativosempy03.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
# Precificando um Straddle - Derivativos em Py #03
import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as plt
# Função para calcular o payoff do straddle
def straddle_payoff(stock_price, strike_price, call_price, put_price):
call_payoff = max(stock_price - strike_price, 0) - call_price
put_payoff = max(strike_price - stock_price, 0) - put_price
return call_payoff + put_payoff
# K e preços das calls e puts
strike_price = 73.32
call_price = 1.24
put_price = 1.15
# Cálculo do payoff do straddle para um intervalo dos preços do ativo subjacente
stock_prices = np.arange(int(0.5 * strike_price), int(1.5 * strike_price), 0.1)
payoffs = [straddle_payoff(price, strike_price, call_price, put_price) for price in stock_prices]
# Plot do payoff do straddle
plt.plot(stock_prices, payoffs)
plt.title('Payoff do Straddle')
plt.xlabel('Preço do ativo subjacente')
plt.ylabel('Payoff')
plt.grid(True)
plt.show()
# Straddle - Gregas
###################
# Funções para cálculo das gregas - delta, gamma, vega, theta
def delta(S, K, T, r, sigma, option_type):
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
if option_type == 'call':
return norm.cdf(d1)
elif option_type == 'put':
return norm.cdf(d1) - 1
def gamma(S, K, T, r, sigma):
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
return norm.pdf(d1) / (S * sigma * np.sqrt(T))
def vega(S, K, T, r, sigma):
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
return S * norm.pdf(d1) * np.sqrt(T) / 100
def theta(S, K, T, r, sigma, option_type):
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
if option_type == 'call':
return -(S * norm.pdf(d1) * sigma) / (2 * np.sqrt(T)) - r * K * np.exp(-r * T) * norm.cdf(d2)
elif option_type == 'put':
return -(S * norm.pdf(d1) * sigma) / (2 * np.sqrt(T)) + r * K * np.exp(-r * T) * norm.cdf(-d2)
# Parâmetros
S = 73.33 # Preço atual do ativo subjacente
K = strike_price # Preço de exercício
T = 7/252 # Vencimento em anos
r = 0.116571 # Taxa de juros livre de risco
sigma = 0.21 # Volatilidade
# Cálculo das gregas para call e put
call_delta = delta(S, K, T, r, sigma, 'call')
put_delta = delta(S, K, T, r, sigma, 'put')
call_gamma = gamma(S, K, T, r, sigma)
put_gamma = gamma(S, K, T, r, sigma)
call_vega = vega(S, K, T, r, sigma)
put_vega = vega(S, K, T, r, sigma)
call_theta = theta(S, K, T, r, sigma, 'call')
put_theta = theta(S, K, T, r, sigma, 'put')
# Cálculo das gregas do straddle, somando as gregas de call e put
straddle_delta = call_delta + put_delta
straddle_gamma = call_gamma + put_gamma
straddle_vega = call_vega + put_vega
straddle_theta = call_theta + put_theta
# Critério de conveniência da operação baseada em valores das gregas do straddle
convenient_delta = abs(straddle_delta) >= 0.1 # Exemplo. Ajustar de acordo com análise individual
convenient_gamma = abs(straddle_gamma) >= 0.3 # Exemplo. Ajustar de acordo com análise individual
convenient_vega = abs(straddle_vega) >= 0.10 # Exemplo. Ajustar de acordo com análise individual
convenient_theta = abs(straddle_theta) >= -35 # Exemplo. Ajustar de acordo com análise individual
# Checagem da conveniência do straddle
if convenient_delta and convenient_gamma and convenient_vega and convenient_theta:
print("Montar o straddle é conveniente de acordo com as regras de sua estratégia.")
else:
print("Montar o straddle NÃO é conveniente de acordo com as regras de sua estratégia.")