Cálculo de Opção de Contração.

Question

1) VCR Internacional possui 4 plantas que produzem VCR’s. Desde o surgimento dos DVD’s a demanda por VCR vem caindo, de forma que a empresa está considerando uma opção para fechar três das suas 4 plantas se a tendência de queda continuar. Esta opção de contrair sua operação de quatro plantas para apenas uma irá resultar em uma economia de 200 milhões. Usando a análise tradicional do fluxo de caixa descontado e uma taxa de desconto ajustada pelo risco, o valor presente do fluxo de caixa livre futuro para a operação foi avaliada em 400 milhões. A volatilidade anual dos retornos logarítmicos para o fluxo de caixa futuro foi calculado em 30% e a taxa de juros livre de risco considerada durante a validade do contrato é de 5%. Qual seria o valor da opção de contração?

2) Recalcule o valor da opção de contração usando os valores 50%, 40%, 20% e 10% para a volatilidade anual dos retornos logarítmicos.

Questões 7.7 e 7.8 do livro Project Valuation Using Real Options - KODUKULA, Prasad; PAPUDESU, Chandra.

Answer 1

Uma firma que possui uma opção de contração tem o direito de reduzir (contrair) sua escala de produção em determinada fração caso as condições de mercado são piores que as esperadas. O exercício não informa a validade do contrato, então iremos assumir uma validade de 5 anos, pois é o padrão adotado no livro.

Vamos resolver o problema usando Python. O código a seguir irá montar a Árvore Binomial com valor do ativo em cada nó. Em seguida irá calcular o valor da opção em cada nó final. Depois irá calcular, retroativamente o valor da opção nos outros nós, ou seja, o maior valor entre continuar a operação e manter a opção aberta ou exercer o direito de contração.
Os parâmetros são: n é numero de períodos, S0 é o valor presente do fluxo de caixa livre, X é o valor adquirido caso a opção seja exercida, r é a taxa de juros livre de risco, v é a volatilidade, c é a fração que a operação irá reduzir caso a opção seja exercida e t é o tempo de validade da opção.

def Arvore_Binomial_Contração(n, S0, X, r, v, c, t): 
   import numpy as np
   At=n/t
   u=np.exp(v*np.sqrt(At))
   d=1/u
   p=(np.exp(r*At)-d)/(u-d)

   assetvalue=np.zeros((n+1,n+1))  #Valor do Ativo em cada nó da Árvore começando por S0
   assetvalue[0,0]=S0               
   for i in range (1,n+1):
       assetvalue[0,i]=assetvalue[0,i-1]*u
       for j in range (1,i+1):
           assetvalue[j,i]=assetvalue[j-1,i-1]*d

   optionvalue=np.zeros((n+1,n+1))    #Valor da opçao nos últimos nós da Árvore
   for j in range(n+1):
       optionvalue[j,n]=max(assetvalue[j,n], (assetvalue[j,n]*c)+X) 

   for i in range (n-1,-1,-1):   #Calcula valor da opção retroativamente 
       for j in range(i+1):
           optionvalue[j,i]=max(0,  c*assetvalue[j,i]+X, np.exp(-r*At)*(p*optionvalue[j,i+1]+(1-p)*optionvalue[j+1,i+1]))

   return assetvalue.round(1), optionvalue.round(1)


if __name__=='__main__':
   print(Arvore_Binomial_Contração(5, 400, 200, 0.05, 0.3, 0.75, 5))

A primeira matriz é a árvore binomial com valor do ativo, a segunda matriz é a árvore binomial com valor da opção:

Para o item 2 vamos utilizar o mesmo código, mudando apenas o parâmetro v. Lembre que queremos apenas a árvore binomial com os valores da opção, ou seja, a segunda matriz que o código gera. As matrizes para v=0.5, 0.4, 0.2, 0.1 são, respectivamente:

Como era de se esperar, o gap entre o maior e o menor valor da opção diminui à medida que a volatilidade se reduz.

Answer 2

Gustavo, refiz o exercício e encontrei os mesmos resultados. Meu código ficou ligeiramente diferente do seu, mas a ideia é a mesma.

import numpy as np
import pandas as pd

def binom_tree(N, T, S0, sig, r, K, c):
    """Parâmetros: N: número de intervalos de tempo, T: tempo para maturidade, 
    S0: preço inicial, sig: variancia, r: taxa de juros livre de risco, K: preço 
    de exercício, c = fração reduzida casa a opção seja exercida.
    Retorna: nada, mas imprime duas tabelas. Uma com a árvore binomial com 
    o valor do ativo e outra com os valores da opção."""

    #Calculando parâmetros iniciais
    dt = T/N
    u = np.exp(sig*np.sqrt(dt))
    d = 1/u 
    p = (np.exp(r*dt)-d)/(u-d)

    #Guardando a árvore binomial em uma matriz quadrada.
    price_tree = np.zeros([N+1, N+1])

    #Calculando o preço da ação em cada nó:
    for i in range(N+1):
        for j in range(i+1):
            price_tree[j,i] = S0*(d**j)*(u**(i-j))

    #Determinando a opção:
    option = np.zeros([N+1, N+1])

    #Determinando o valor da opção de compra:
    option[:, N] = np.maximum(price_tree[:, N], price_tree[:, N]*c + K)

    #O valor da opção de compra é determinado retroativamente:
    for i in np.arange(N-1, -1, -1):
        for j in np.arange(0, i+1):
            option[j,i] = max(0, c*price_tree[j,i]+K, np.exp(-r*dt)*(p*option[j,i+1]+(1- 
 p)*option[j+1, i+1]))

    print("Volatilidade = ", sig)
    print("Árvore Binomial - Ativo:")
    print(pd.DataFrame(price_tree))
    print("Árvore Binomial - Opção:")
    print(pd.DataFrame(option))

#Parte a
binom_tree(5, 5, 400, 0.3, 0.05, 200,  0.75)

#Parte b
binom_tree(5, 5, 400, 0.5, 0.05, 200,  0.75)  
binom_tree(5, 5, 400, 0.4, 0.05, 200,  0.75)
binom_tree(5, 5, 400, 0.2, 0.05, 200,  0.75)
binom_tree(5, 5, 400, 0.1, 0.05, 200,  0.75)

A saída é: