Tag

ativos financeiros Archives - Análise Macro

Calculando o Historical VaR

By | mercado financeiro

O Historical Value at Risk é um método de calculo para mensurar da perda monetária de um determinado portfólio, utilizando como base os valores passados dos ativos e de seus respectivos retornos, criando uma série de Profits e Losses (P&L) que é tomada a um dado nível de intervalo para mensurar a perda potencial.

Assim como o Gaussian Value at Risk, o método Historical é uma das formas mais simples para se calcular o VaR. A diferença é que para o segundo método é necessário que haja mais dados. Neste post, iremos coletar dados de 4 ações para compor nosso portfólio, com dados diários de 1 de janeiro de 2013 até o dia atual.

Primeiro carregamos os pacotes, coletamos os preços e transformamos em retornos.

library(tidyquant)
library(timetk)
library(tidyverse)

 


# Define os ativos que irão ser coletados

tickers <- c("PETR4.SA", "ITUB4.SA", "ABEV3.SA", "JBSS3.SA")

# Define a data de início da coleta

start <- "2012-12-01"

# Realiza a coleta dos preços diários

prices <- getSymbols(tickers,
auto.assign = TRUE,
warnings = FALSE,
from = start,
src = "yahoo") %>%
map(~Cl(get(.))) %>%
reduce(merge) %>%
`colnames<-`(tickers)

# Calcula os retornos mensais

asset_returns <- Return.calculate(prices,
method = "log") %>%
na.omit()

 

Estaremos então interessados em conhecer o valor diário dos nossos ativos dentro do nosso portfólio. Podemos fazer isso através da função Return.portfolio(). A função calcula o retorno do nosso portfólio com base nos retornos dos nossos ativos. Por padrão, a função considera que temos um portfólio com pesos iguais (que é o que utilizaremos aqui, cada ativo terá o peso de 25%). Se utilizarmos o argumento verbose = TRUE, a função também calcula o peso e os valores dos ativos ao longo do tempo.

Suponha então que nosso portfólio possuía um valor monetário de 4563 no primeiro dia, a função retornará uma lista com os retornos do portfólio, os pesos dos ativos e os valores monetários ao longo do tempo.


# Calcula o retorno do portfolio

portfolio_returns <- Return.portfolio(asset_returns, verbose = TRUE, value = 4563)

# Calcular o valor

value <- portfolio_returns$EOP.Value * asset_returns

&nbsp;

p_l <- value[,1] + value[,2] + value[,3] + value[,4]

p_l <- `colnames<-`(p_l, "pl")

var_01_historical <- quantile(-p_l$pl, 0.99)

var_05_historical <- quantile(-p_l$pl, 0.95)

 

Calculamos o P&L como a soma dos valores diários dos ativos ponderados pelos seus respectivos retornos. Por fim, calculamos o quartil para o intervalo de confiança em 99% ou 95%.

 

________________________

(*) Para entender mais sobre Mercado Financeiro e medidas de risco, confira nosso curso de R para o Mercado Financeiro.
________________________

Analisando a performance de ativos financeiros

By | mercado financeiro

Sabe-se muito bem que a escolha de ativos financeiros pode ser considerada difícil, afinal, o processo acaba seguindo alguns passos complicados, que talvez muitas pessoas não dominem: definir o objetivo de investimento; escolher a classe de ativos; a política de investimento; definir a forma de alocação dos ativos e por fim, a definição de técnicas para a avaliação de performance dos ativos financeiros escolhidos. Sabe-se que cada pessoa possui formas e gostos diferentes de investir, porém, técnicas de avaliação podem (e devem) superar a subjetividade. No post de hoje mostraremos como podemos simplificar esse processo de avaliação no R.

Assim como nos últimos posts, trabalharemos com quatro ações, apenas para exemplificar o processo. Também trabalharemos com o índice bovespa e com uma taxa de juros livre de risco. Nessa primeira parte iremos coletar o preços e transformar em retornos.

library(quantmod)
library(timetk)
library(tidyverse)
library(PerformanceAnalytics)
library(Hmisc)

 

 

</pre>
# Define os ativos que irão ser coletados

tickers <- c("PETR4.SA", "ITUB4.SA", "ABEV3.SA", "JBSS3.SA")

# Define a data de início da coleta

start <- "2020-12-01"

# Realiza a coleta dos preços diários

prices <- getSymbols(tickers,
auto.assign = TRUE,
warnings = FALSE,
from = start,
src = "yahoo") %>%
map(~Cl(get(.))) %>%
reduce(merge) %>%
`colnames<-`(tickers)

# Transfroma os preços diários em mensais

prices_monthly <- to.monthly(prices,
indexAt = "lastof",
OHLC = FALSE)

# Calcula os retornos mensais

asset_returns <- Return.calculate(prices_monthly,
method = "log") %>%
na.omit()

# Coleta os dados do ibovespa

getSymbols("^BVSP",
warnings = FALSE,
from = start,
src = "yahoo")

# Calcula os retornos mensais

bvsp_returns <- Ad(BVSP) %>%
to.monthly(indexAt = "lastof",
OHLC = FALSE) %>%
Return.calculate(method = "log") %>%
na.omit() %>%
`colnames<-`("ibovespa")

# Define taxa de juros livre de risco

rf <- 0.0925/12
<pre>

Feito a coleta e tratamento de dados, podemos enfim analisar nossas escolhas de ativos, mas antes, iremos criar uma função para que possamos exportar nossos resultados do R para uma imagem.

</pre>
# Cria uma função para transformar os resultados de um data frame para texto

df_to_text <- function (result){
textplot(format.df(t(result), na.blank = TRUE, numeric.dollar = FALSE,
cdec = c(3,3,1)), rmar = 0.8, cmar = 2, max.cex = 9,
halign = "center", valign = "top", row.valign = "center",
wrap.rownames = 20, wrap.colnames = 10,
col.rownames = c(rep("darkblue", 5), rep("orange", 2)),
mar = c(0, 0, 3, 0)+ 0.1)
}
<pre>

 

A análise dos ativos são facilitadas pelas funções do tipo table. do pacote PerformanceAnalytics{}. A primeira que podemos utilizar será a table.Stats, que fornece as estatísticas básicas dos nossos ativos.

</pre>
# Resultados estatísticos dos ativos

statistic_result <- table.Stats(asset_returns, digits = 3)

df_to_text(statistic_result)

title(main = list("Estatística dos ativos", cex = 1.5, col = "darkblue"))
<pre>

Veja que é retornado diversas informações estatísticas, desde o número de observações, até a assimetria e curtose, cada um com sua devida interpretação.

Outra função de performance se encontra na table.AnnualizedReturns(), que demonstra o retorno, o desvio padrão e o Índice de Sharpe anualizado.


# Resultados das métricas de performance

performance_result <- table.AnnualizedReturns(asset_returns, Rf = rf, digits = 2)


df_to_text(performance_result)

title(main = list("Performance dos ativos", cex = 2, col = "darkblue"))

Por fim, podemos avançar mais nas técnicas utilizadas, sendo possível ver resultados obtidos pelo Capital Asset Pricing Model.


# Resultados do CAPM

capm_result <- table.CAPM(asset_returns, bvsp_returns, Rf = rf, digits = 2)

df_to_text(capm_result)

title(main = list("CAPM", cex = 2, col = "darkblue"))


Existem diversas outras funções úteis da família table. do pacote PerformanceAnalytics{}, tais como table.DownsideRisk(), table.Drawdowns() e também a função table.Arbritary(), que permite montar, a gosto de cada um, um data frame com os resultados.

 

________________________

(*) Para entender mais sobre Mercado Financeiro e medidas de risco, confira nosso curso de R para o Mercado Financeiro.
________________________

Criando uma função de correlação móvel entre ativos financeiros

By | mercado financeiro

No post de hoje, iremos mostrar como é possível calcular a correlação móvel entre ativos financeiros. O objetivo do calculo é acompanhar a relação entre os ativos ao longo do tempo, de forma que, para quem possua uma carteira de ativos saiba quais deles eventualmente se tornem negativamente correlacionado, e portanto, tenham uma carteira diversificada e com baixo risco.

Para quem não sabe, a correlação mede a associação linear entre duas variáveis, ou seja, se há uma correlação positiva entre dois ativos, então ambos, eventualmente se direcionam para a mesma direção, e vice-versa. Importante lembrar que isto não significa qualquer ideia de causalidade.

Para uma carteira de investimentos, estamos obviamente interessados em ativos que se correlacionam negativamente, afim de diminuir o risco da carteira.

Carregamos os pacotes essenciais.

library(Quandl)
library(quantmod)
library(tidyverse)
library(timetk)
library(tidyquant)

Para nosso código, primeiro, devemos buscar os preços dos nossos ativos. Neste post, buscamos 3 ações, o dólar e também a ibovespa.

# Define os tickers das ações coletadas

tickers = c('PETR4.SA', 'ABEV3.SA', 'BBDC4.SA')

# Define o período da coleta

start = '2016-01-01'

# Coleta os preços das ações

prices = getSymbols(tickers, src='yahoo',
                    from= start,
                    warning=FALSE) %>%
  map(~Ad(get(.))) %>%
  reduce(merge) %>%
  `colnames<-` (tickers)

# Transforma os preços diários em mensais, e os transforma em tibble

prices_monthly <- prices %>% 
  to.monthly(indexAt = "lastof",
             OHLC = FALSE) %>% 
  tk_tbl(preserve_index = TRUE,
         rename_index = "date")


# Coleta os dados do IBOVESPA

ibov <- getSymbols("^BVSP", src = "yahoo",
                   from = start,
                   warning = FALSE,
                   auto.assign = FALSE) %>% 
  Ad()


# Transforma o IBOV diário em mensal, e o transforma em tibble

ibov_monthly <- ibov %>% 
  to.monthly(indexAt = "lastof",
             OHLC = FALSE) %>% 
  tk_tbl(preserve_index = TRUE,
         rename_index = "date")


# Coleta o preço do Dólar e o transforma em tibble

cambio = Quandl('BCB/3697',
                order='asc', 
                start_date = start) %>% 
  as.tibble()
  


# Junta todos os preços em um tibble

all_prices <- ibov_monthly %>% 
  inner_join(cambio, by = c("date" = "Date")) %>% 
  inner_join(prices_monthly) %>% 
  rename(cambio = "Value",
         ibov = "BVSP.Adjusted") 

Após realizar toda a coleta e tratamento dos dados, iremos calcular os retornos desses ativos.

# Calcula o retorno contínuo

returns_long <- all_prices %>% 
  pivot_longer(names_to = "asset",
               values_to = "prices",
               -date) %>% 
  group_by(asset) %>% 
  tq_transmute(mutate_fun = periodReturn,
               type = "log")

Por fim, criamos a nossa função de correlação móvel, utilizando a função slidify do pacote {timetk}. Em seguida, calculamos a correlação dos ativos em relação ao Ibovespa e visualizamos no gráfico o resultado.

# Cria uma função de correlação móvel

rolling_cor <- slidify(~cor(.x, .y, use = "complete.obs"), .period = 6, .align = "right")


# Transforma em formato wide

returns_wide <- returns_long %>% 
  pivot_wider(names_from = "asset",
                       values_from = "monthly.returns") 


# Calcula a correlação móvel de cada ativo em relação ao Ibovespa

corr_ibov <- returns_wide %>% 
  transmute(date  = date,
    Dólar = rolling_cor(ibov, cambio),
         PETR4 = rolling_cor(ibov, PETR4.SA),
         ABEV3 = rolling_cor(ibov, ABEV3.SA),
         BBDC4 = rolling_cor(ibov, BBDC4.SA))


# Plota

corr_ibov %>% 
  drop_na() %>% 
  pivot_longer(-date) %>% 
ggplot(aes(x = date, y = value, color = name))+
  geom_line(size = 1)+
  theme_minimal()+
  labs(x = "",
       y = "Correlação",
       title = " Correlação móvel com o IBOVESPA Mensal",
       cation = "Dados: Yahoo Finance e Banco Central do Brasil | Elaboração: analisemacro.com.br",
       color = "Ativo")

________________________

(*) Quer saber mais sobre Mercado Financeiro? Confira nossos curso de Finanças Quantitativas.

________________________

Como calcular o retorno de um portfólio de investimentos

By | mercado financeiro

No post de hoje, como parte do que ensinamos no nosso curso R para o Mercado Financeiro, continuaremos a mostrar como podemos realizar cálculos úteis para avaliações de investimentos. No post passado, mostramos como podemos realizar cálculos dos retorno de ativos individualmente, porém, no mundo real, nem sempre iremos investir nosso dinheiro todo em um único ativo. Por isso, deve-se ser necessário o entendimento de como podemos calcular o retorno de um portfólio de ativos.

Sem muito suspense, o retorno de um portfólio é simplesmente a soma do retorno ponderado pelo peso dos ativos baseado no total de dinheiro investido. De outra forma, podemos definir através de uma equação:

(1)   \begin{equation*} r_p = \frac{I_1}{I_1-I_2} * r_1 + \frac{I_2}{I_1+I_2} * r_2 = w_1 *r_1 + w_2 * r_2 \end{equation*}

onde r_p é o retorno do portfólio, I_1 o dinheiro investido no ativo 1, I_2 o dinheiro investido no ativo 2, r_1 o retorno do ativo 1 e r_2 o retorno do ativo 2.

Nesse caso, utilizamos apenas dois ativos como exemplo na equação, mas o mesmo funciona para caso houver mais ativos no portfólio, sendo necessário apenas expandir a equação.

Mas, como podemos realizar isso no R? É bem simples!

Primeiro iremos carregar os pacotes necessários.

library(quantmod)
library(Quandl)
library(PerformanceAnalytics)
library(tidyverse)
library(timetk)

Em seguida, podemos seguir para o nosso código.


# Define os ativos que irão ser coletados

tickers <- c("PETR4.SA", "ITUB4.SA", "ABEV3.SA", "JBSS3.SA")

# Define a data de início da coleta

start <- "2016-12-01"

# Realiza a coleta dos preços diários

prices <- getSymbols(tickers,
                     auto.assign = TRUE,
                     warnings = FALSE,
                     from = start,
                     src = "yahoo") %>% 
  map(~Cl(get(.))) %>% 
  reduce(merge) %>% 
  `colnames<-`(tickers)

# Transfroma os preços diários em mensais

prices_monthly <- to.monthly(prices,
                           indexAt = "lastof",
                           OHLC = FALSE)

# Calcula os retornos mensais

asset_returns <- Return.calculate(prices_monthly,
                                  method = "log") %>% 
  na.omit()

Veja que até aqui somente tratamos de calcular os retornos individuais dos nossos ativos. Agora, será o momento que devemos realizar o cálculo do retorno do portfólio. Para isso, iremos construir quatro portfólio diferentes, de forma que possamos validar qual a melhor estratégia que podemos utilizar.

Iremos fazer da seguinte forma, através de 4 ativos, com pesos escolhidos aleatoriamente, definimos: PETR4 com peso de 50%; ITUB4 com peso de 27%; ABEV3 com peso de 13% e JBSS3 com peso de 10%.

# Define os pesos dos respectivos ativos

w <- c(0.50, 0.27, 0.13, 0.10)

# Calcula o retorno do portfolio baseado no peso de cada ativo

portfolio_return <- Return.portfolio(asset_returns,
                                      weights = w) %>% 
  `colnames<-`("port_returns")

Através da função Return.portfolio(), calculamos o retorno do portfolio com os retornos individuais e com os pesos escolhidos.

No segundo portfólio, iremos utilizar as mesmas métricas, porém, deixaremos que a função faça um rebalanceamento.

# Calcula o retorno do portfolio baseado no peso de cada ativo com rebalanceamento

portfolio_return_reb <- Return.portfolio(asset_returns,
                               weights = w,
                               rebalance_on = "quarters") %>% 
  `colnames<-`("port_return_reb")

No terceiro portfólio, iremos construir o que a literatura conhece como equally weighted portfolio, no qual estabelece que todos os ativos possuem o mesmo peso.

# Calcula o Equally Weighted Portfolio

portfolio_return_ew <- Return.portfolio(asset_returns) %>% 
  `colnames<-`("ewp")

E por fim, no quarto portfólio, criamos novamente o equally weighted portfolio, porém, com rebalanceamento.

# Calcula o Equally Weighted Portfolio com rebalanceamento

portfolio_return_ew_reb <- Return.portfolio(asset_returns,
                                            rebalance_on = "quarters") %>% 
  `colnames<-`("ewp_reb")

Podemos então visualizar a performance do nosso portfólio através do retorno acumulado, comparando-os entre si, e também com CDI.

Parece que teremos que revisar nossas estratégias.

________________________

(*) Para entender mais sobre Mercado Financeiro e aprender como realizar a coleta, tratamento e visualização de dados financeiros, confira nosso curso de R para o Mercado Financeiro.
________________________

Receba diretamente em seu e-mail gratuitamente nossas promoções especiais
e conteúdos exclusivos sobre Análise de Dados!

Assinar Gratuitamente