CEO da NBA África entra na administração da Mota-Engil

[rjac]

Boas,

excelentes notícias! Esta semana tenho que dar uma espreitadela nesta nova feature do R.

É por isto que adoro esta tecnologia: vai evoluindo com a boa vontade das pessoas.

Em relação aos estrangeirismos: pacote é a tradução que se pode fazer mas normalmente, só se usam estes termos nos meios mais académicos. A programação é um péssimo lugar para tentar fugir aos estrangeirismos. Abraça-os sem pudor!

Também já experimentei o highcharter. TOP! Obrigado pela dica.

[VirtuaGod]

Olha ai o pacote

Para instalar:

Código: Selecionar todos

install.packages(c("quantmod", "devtools", "stringr")) # Apagar os pacotes que já se tem
library(devtools)
install_github("VirtuaGod/AnaliseFI")

Exemplo:

Código: Selecionar todos

library(quantmod)
library(stringr)
library(AnaliseFI)

MSid       <- c("F0GBR04EAN", "F000000FH0", "F0GBR05ZUY")
MSid.names <- c("FCI", "GS_SmallCaps", "MFSTR")

getFI_best(MSid, Begin_End = "2007-12-31/2017-01-20")

colnames(Fundos) <- MSid.names
plot(Fundos$MFSTR, main = "MFS Global Total Return")

Notas: A função getFI_best() tem um argumento "Begin_End" com o formato "2007-12-31/2017-01-20". Caso não seja colocada tem default em 1999-12-31/2017-12-31. Cria objectos XTS de todos os Morningstar Ids (versão "pura" das cotações da morningstar) e um objecto "Fundos", com todas as cotações dos fundos alinhadas (ainda está em versão experimental e inclui os fim de semana mas vou corrigir isso. É uma versão "alterada" das cotações que acrescenta dias, de forma a alinhar as cotações). Usa a feed do Best por isso só funciona com fundos que eles comercializam.

[VirtuaGod]

@rjac Deste-me um boost gigante. Muito obrigado mesmo. Estou com boas perspectivas para coisas interessantes para breve

[VirtuaGod]

Sorry, sei que parece um bocado confuso, mas não sou assim tão bom ao ponto de conseguir explicar isto de uma forma mais clara.

Sem stresses Mal olhei para o código percebi o que fizeste, acho que tenho alma de programador Já tinha lido algo sobre isso dos environments mas nunca pensei que fosse o problema.

Muito obr. Um passo grande para desenvolver o package. Esquece lá esse packages compilados em C++, isso é demasiado TOP. A grande maioria dos pacotes não são mais do que várias funções juntas.

Vais ver que antes do final do mês já tenho um pacote instalável, via GitHub, com pelo menos esta função

P.S. Há algum termo de programação para packages? Já uso mil e um estrangeirismos em finanças e gostava que este lado mais pessoal fosse diferente Mas "pacotes" tb não me soa bem.

P.S.2. Tb ando maravilhado com Shiny Apps. Para mim é a forma ideal do pessoal sem conhecimentos de programação ter acesso aos outputs dos meus scripts em R.

[rjac]

Bom,

não há nada de errado na função, simplesmente não disseste onde querias criar os teus objectos.

Talvez não te tenhas deparado com esta questão porque tipicamente, as funções atuam sobre objectos que estão ou vão estar registados no ambiente de trabalho.

Neste caso, estás a querer criar objectos, mas não estás a especificar onde os queres criar.

Sorry, sei que parece um bocado confuso, mas não sou assim tão bom ao ponto de conseguir explicar isto de uma forma mais clara.

De qualquer forma, o stackoverflow responde aqui:
http://stackoverflow.com/questions/3969 ... oesnt-work

a tua função precisa de uma pequena alteração.

Código: Selecionar todos

getFI <- function(x){
  for (i in x) {
    fund <- read.csv2(paste0("https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=",i,
                             "&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=12/31/1900&outputType=CSV"))
    assign(i, fund,envir=.GlobalEnv)
    rm(fund)
  }
}

assim já funca.

[VirtuaGod]

Deixo aqui o código para se souberes ajudar:

Loop (a funcionar perfeitamente)

Código: Selecionar todos

MSid <- c("F0GBR04EAN", "F000000FH0")

for (i in MSid) {
  fund <- read.csv2(paste0("https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=",i,
                             "&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=12/31/1900&outputType=CSV"))
  assign(i, fund)
  rm(fund)
  }

O MSid são os códigos da Morningstar. Tenho um CSV com 85 MSid que o R vai ler antes de fazer o loop

Função (tentativa fracassada)

Código: Selecionar todos

getFI <- function(x){
  for (i in x) {
    fund <- read.csv2(paste0("https://lt.morningstar.com/api/rest.svc/timeseries_price/okhysb8aoh?id=",i,
                             "&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=12/31/1900&outputType=CSV"))
  assign(i, fund)
  rm(fund)
  }
}

getFI("F0GBR04EAN")

getFI é a minha versão de "Get Fundo de Investimento"

[VirtuaGod]

Não sei se percebi. Não sabes definir uma função em R ou não sabes criar uma biblioteca? No meu conhecimento limitado, os pacotes/bibliotecas exigem um jiujitsu de programação bem mais avançado. Penso que maior parte deles, por motivos de performance, até são programas desenvolvidos e compilados em C. Se for apenas definir uma função em R, basta qualquer coisa do estilo

Código: Selecionar todos

 funcao_teste <- function(arg1, argN) { #corpo da função }

Criar a função com loop devido à abstração necessária a um loop está a ser mais complicada mas vou lá chegar. Mas é sempre bom saber que há quem saiba mais que eu de R para me ajudar se necessário.

Desconhecendo o tutorial mas conhecendo o desafio da kaggle do titanic, parece-me uma abordagem muito redutora ao Machine Learning.

Sim. Pessoalmente nem achei propriamente Machine Learning, se bem que ainda não sei bem o conceito. Mas não é mais do que um modelo estatístico (semelhante aos que eu fazia em econometria) e ele vai vendo se a variável é relevante.

Para aprender os fundamentos de Machine Learning, o melhor curso online (ou pelo menos o mais cotado de longe), é o do Andrew Ng. O Andrew é muito bom a explicar os conceitos de Machine Learning.

Tenho ouvido maravilhas desse curso mas não me apetece aprender matlab no futuro próximo (ainda não foi actualizado e o curso já tem 5/6 anos ) Penso que as ideias devem ser brutais mas ele podia actualizar o curso!! Nos últimos anos teem aparecido bibliotecas que acho que são bastante boas para ML.

Outra opção que também recomendo (este já em R) é um curso que faz parte da especialização em Data Science do coursera.
https://www.coursera.org/learn/practica ... e-learning

Estou a pensar (para daqui a uns 2/3 anos) tirar https://www.udacity.com/course/machine-learning-engineer-nanodegree--nd009. Deve demorar umas 300/400 horas a tirar. Sempre me parece algo mais completo. Depois do CFA é no que me vou concentrar.

Se sabes R posso falar mais à vontade do que tens de fazer:

Para sacares o fundos directamente para o R só tens de fazer simples read.csv da API morningstar pelo Feed deles. Exemplo para o Fidelity Consumer Industries. http://www.morningstar.pt/pt/funds/snapshot/snapshot.aspx?id=F0GBR04EAN

FCI<- read.csv2(url("https://lt.morningstar.com/api/rest.svc/timeseries_price/2nhcdckzon?id=F0GBR04EAN&currencyId=BAS&idtype=Morningstar&frequency=daily&startDate=12/31/1900&outputType=CSV"))

Para alterares para outros fundos só tens de alterar o id da morningstar: F0GBR04EAN

Saca com uma terceira coluna/artefacto desnecessário, colocas as datas como datas etc etc acho que essa manipulação sabes fazer. Transforma em XTS se queres fazer um highchart com ele, mas deixa estar em data.frame se quiseres usar o plotly. A plotly é muito porrreira pela junção com qualquer gráfico em ggplot2 via a função ggplotly().

[rjac]

Sim. Há coisas que são super simples. Outras pessoas já fizeram o código por nós e colocaram-nos em funções/pacotes Eu queria ver se fazia um aqui para o tópico, que pretendo reformular completamente e ter uma abordagem mais user friendly, mas está complicado fazer algumas funções com loop. Basicamente já tenho o 'for-loop' para sacar o histórico dos fundos via feed do Best mas não estou a conseguir transformar isso numa função. Queria que fazer o gráfico de um fundo fosse tão simples como fazer o gráfico de uma acção americana via Quantmod.

Não sei se percebi. Não sabes definir uma função em R ou não sabes criar uma biblioteca? No meu conhecimento limitado, os pacotes/bibliotecas exigem um jiujitsu de programação bem mais avançado. Penso que maior parte deles, por motivos de performance, até são programas desenvolvidos e compilados em C. Se for apenas definir uma função em R, basta qualquer coisa do estilo

Código: Selecionar todos

 funcao_teste <- function(arg1, argN) { #corpo da função }

Se quiseres podemos trocar umas bolas sobre isso. Até pq, essa parte de sacar o histórico dos fundos via feed do Best parece-me muito interessante.

De qualquer forma, como já alguém disse, o stackoverflow é o melhor para encontrar respostas para dúvidas concretas sobre R (ou qualquer outra linguagem de programação).

Vou dar uma checkada nas tuas sugestões de cursos para ver se me chamam a atenção. Mas como disse, neste momento, o curso que referi foi bom no sentido de conhecer a biblioteca quantmod. A parte do R já está +- dominada há algum tempo por motivos profissionais.

Se gostas dos gráficos do quantmod o nível seguinte são os gráficos (OHLC) da highcharts:

Highstock Examples

Muito promissor. Hoje vou já instalar a biblioteca para explorar um pouco. Obrigado pela dica.

Ontem por divertimento inscrevi-me no Kaggle para fazer uma "competição" para desenvolver um algoritmo de previsão de sobreviventes do Titanic: Titanic: Machine Learning from Disaster. Claro que não percebendo eu (ainda) nada de machine learning segui a ajuda do datacamp (que é grátis): Kaggle R Tutorial on Machine Learning [for the titanic challenge]

Desconhecendo o tutorial mas conhecendo o desafio da kaggle do titanic, parece-me uma abordagem muito redutora ao Machine Learning.

Para aprender os fundamentos de Machine Learning, o melhor curso online (ou pelo menos o mais cotado de longe), é o do Andrew Ng. O Andrew é muito bom a explicar os conceitos de Machine Learning.

https://www.coursera.org/learn/machine- ... me/welcome

Quando o experimentei, não podia ser feito em R. As tecnologias disponíveis eram Matlab ou Octave. De qualquer forma, não é entrave.

Outra opção que também recomendo (este já em R) é um curso que faz parte da especialização em Data Science do coursera.
https://www.coursera.org/learn/practica ... e-learning

[VirtuaGod]

R geeks in da house?! Love it!

Partilho convosco um link sobre um curso simples e útil nesta área.

https://www.udemy.com/practical-data-sc ... ata-with-r

Gostei muito deste curso. Apresentou-me ao quantmod (biblioteca para análise técnica) e abriu-me os horizontes para algumas possibilidades que ainda não imaginava que fossem possíveis de uma forma tão fácil.

Enjoy!

Esse curso chamou-me tão pouco a atenção que nem na promoção dos 10 euros (inicio de ano) o comprei.

Sim. Há coisas que são super simples. Outras pessoas já fizeram o código por nós e colocaram-nos em funções/pacotes Eu queria ver se fazia um aqui para o tópico, que pretendo reformular completamente e ter uma abordagem mais user friendly, mas está complicado fazer algumas funções com loop. Basicamente já tenho o 'for-loop' para sacar o histórico dos fundos via feed do Best mas não estou a conseguir transformar isso numa função. Queria que fazer o gráfico de um fundo fosse tão simples como fazer o gráfico de uma acção americana via Quantmod.

Em termos de conhecimento onde aprendi mais foi:

Analyzing Financial Data and Implementing Financial Models Using R (Springer Texts in Business and Economics) (livro)
Introduction to Portfolio Analysis in R (datacamp) PerformanceAnalytics - Backtest e report de carteiras de investimento

neste momento estou a tirar:

Financial Trading in R (datacamp) Quantstart - Backtest e Report de sistemas de trading

Se gostas dos gráficos do quantmod o nível seguinte são os gráficos (OHLC) da highcharts:

Highstock Examples

Atenção que estes gráficos não correm automáticamente com um simples "source" do script. Tens de correr directamente e apenas o código do gráfico (Control, Shift, Enter na primeira linha) ou, agora que penso nisso, um print() tb é capaz de funcionar.

Ontem por divertimento inscrevi-me no Kaggle para fazer uma "competição" para desenvolver um algoritmo de previsão de sobreviventes do Titanic: Titanic: Machine Learning from Disaster. Claro que não percebendo eu (ainda) nada de machine learning segui a ajuda do datacamp (que é grátis): Kaggle R Tutorial on Machine Learning [for the titanic challenge]

P.S. O Datacamp não é barato. Se quiseres envia PM que dou-te um passe de 48 horas. Sempre dá para "roubar" o código e tentares entender depois por ti!!

[rjac]

R geeks in da house?! Love it!

Partilho convosco um link sobre um curso simples e útil nesta área.

https://www.udemy.com/practical-data-sc ... ata-with-r

Gostei muito deste curso. Apresentou-me ao quantmod (biblioteca para análise técnica) e abriu-me os horizontes para algumas possibilidades que ainda não imaginava que fossem possíveis de uma forma tão fácil.

Enjoy!

[VirtuaGod]

Gostaria de deixar as seguintes perguntas sobre o interactive brokers:
1) Podes comprar/vender acções directamente por eles?
2) Tens acesso ao código? podes incluir os teus módulos?
3) Por exemplo, a https://www.lynxbroker.com/ usa IB e tem comissões baixinhas quase ao nível da DeGiro.
Conheces? tens opinião?

Infelizmente não estou a conseguir dar o acompanhamento que pretendia a este tópico por falta de tempo mas havemos de lá chegar ao trading... eventualmente.

A IB é muito usada devido ao API. Basicamente consegues ligar tudo para trasaccionar na IB, seja Java, C++, Python, Matlab, Mathematica, R etc etc

Em termos de trading em R o pacote mais usado é provavelmente o Quantstrat. Tens uma 'curso' no datacamp feito pelo criador:

https://www.datacamp.com/courses/financial-trading-in-r

Podes encontrar outra info relevante aqui:

https://quantstrattrader.wordpress.com/2014/09/09/nuts-and-bolts-of-quantstrat-part-i/
https://cran.r-project.org/web/packages/IBrokers/vignettes/IBrokers.pdf
https://www.datacamp.com/courses/model-a-quantitative-trading-strategy-in-r/

Outra forma engraçada de brincar é usando plataformas como o Quantopian que correm Python e têm ligação à IB. Vai ver o Site. Se quiseres aprender tens aqui algo que me parece interessante (mas não sei a qualidade): https://pythonprogramming.net/finance-programming-python-zipline-quantopian-intro/

Como podes ver, para coisas que não envolvam high frequency trading as linguagens de programação de alto nível são mais usadas devido à sua simplicidade de criação dos modelos. Depois podem ser traduzidas para baixo nível mas nós (pessoas normais cujos sistemas não fazem mais de um trade por segundo) não precisamos disso.

[LoneWolf]

Caro VirtuaGod,

Antes de mais, parabéns por este contributo. Estás a fazer um excelente trabalho.
O meu background é de engª de software e trabalho na área médica. Nunca trabalhei com R (ou python ou matlab)
mas tive muitos colegas a trabalhar com essas ferramentas para extracção de dados estatisticos, machine learning
e segmentação (de orgãos ou features) automatica. O meu background é C/C++.
Sempre tive muito interesse em aprender esta área, mas infelizmente, está-me no sangue chegar a casa depois do
trabalho e jogar joguinhos. Algo que quero mudar agora q tenho volume financeiro para começar a investir.

Nos últimos meses tenho olhado para plataformas de trading, páginas e blogs de quant trading, livros e forums (caldeirão).
Guardei bastantes links e gostaria de partilhar alguns q acho apropriados à discussão, apesar de não serem especificamente para R:
http://quantlib.org/index.shtml
https://www.quantconnect.com/
https://www.r-bloggers.com/search/trading/

Gostaria também de deixar o link para o maior "forum" gratuito onde todo o tipo de programadores fazem perguntas. Pode ser muito
útil quando voltares a passar 5 horas atrás dum bug:
http://stackoverflow.com/search?q=r+programming
E dentro do stack overflow existem subsecções como esta: http://quant.stackexchange.com/


Gostaria de deixar as seguintes perguntas sobre o interactive brokers:
1) Podes comprar/vender acções directamente por eles?
2) Tens acesso ao código? podes incluir os teus módulos?
3) Por exemplo, a https://www.lynxbroker.com/ usa IB e tem comissões baixinhas quase ao nível da DeGiro.
Conheces? tens opinião?


Obrigado
LoneWolf

[Youmeu]

Boas malta, estou a ter a cadeira de econometria na licenciatura de economia da Nova. Se alguém quiser aprofundar os seus conhecimentos de econometria mande-me mensagem privada que eu envio-lhe os power points e exercícios da cadeira por email. Como alternatica existem também cursos grátis de econometria na internet (ex: youtube)

Abraço

[VirtuaGod]

Aula 1_11: Importação e tratamento básico de dados: Parte 1 (15 minutos)

Código em cor avermelhada: Script
Código em cor azulada: Consola

Esta aula é bastante importante e introduz uma quantidade considerável de novos comandos, assim como a importação de novas bibliotecas (add-ons do R).

Vamos aqui importar cotações do SPY e fazer o mínimo de tratamento dos mesmos para que fiquem com o formato com que pretendemos trabalhar.

Passo 1:Ir ao Yahoo finance buscar as cotações de SPY (2013//2014//2015)

Deixo aqui um PrintScreen que penso ser elucidativo sobre como fazer o download dos dados em .csv. O Ficheiro .csv deverá ficar na pasta criada para estas aulas e onde vai ficar o Script do R que vão usar.



Passo 2:Importar os dados para o R

Após abrirem o RStudio e criarem um novo Script em branco vamos dar comandos para a importação do ficheiro .CSV

Primeiro comando a escrever é o setwd(), que como disse numa aula anterior informa o R sobre qual é o directório em que estamos a trabalhar. Neste directório deveremos ter o ficheiro CSV com as cotações do SPY e de preferência o próprio script que estamos a fazer.

Assim:

1. setwd("C:/Users/a/Dropbox/_Programacao/R/Caldeirao/R_para_Finanças")

No vosso caso deverão alterar o código para o directório que vocês estão a usar. Lembrem-se de usar / pois o \ está reservado para outras coisas em R e o programa entra em confito.

Se quiserem confirmar se tudo correu bem podem testar escrevendo getwd() na consola.

2.

Para ler o CSV o comando é um relativamente simples read.csv()

SPY <- read.csv("SPY.csv", header = TRUE)

Neste caso temos 3 coisas a saber. Primeiro que chamei SPY.csv ao ficheiro com as cotações do SPY que saquei do yahoo Finance. Em segundo lugar, vou chamar SPY ao objecto R com as cotações do SPY. Por último o header = TRUE significa que a primeira linha das cotações é o cabeçalho e não deve ser considerado como cotações mas sim como nomes das colunas.

Se não deu erro nenhum na leitura podem querer confirmar que as cotações foram bem importadas. Para isso podem usar o comando head() e tail().

Escrevendo head(SPY) na consola deveremos ver o topo das cotações:

> head(SPY)
Date Open High Low Close Volume Adj.Close
1 2015-12-31 205.13 205.89 203.87 203.87 102929500 200.7605
2 2015-12-30 207.11 207.21 205.76 205.93 63317700 202.7890
3 2015-12-29 206.51 207.79 206.47 207.40 92640700 204.2366
4 2015-12-28 204.86 205.26 203.94 205.21 65899900 202.0800
5 2015-12-24 205.72 206.33 205.42 205.68 48539600 202.5429
6 2015-12-23 204.69 206.07 204.58 206.02 110987200 202.8777

Se a seguir fizermos tail (SPY) veremos o fim das cotações:

> tail(SPY)
Date Open High Low Close Volume Adj.Close
752 2013-01-08 145.71 145.91 144.98 145.55 121265100 135.0143
753 2013-01-07 145.85 146.11 145.43 145.97 110002500 135.4039
754 2013-01-04 145.97 146.61 145.67 146.37 116817700 135.7749
755 2013-01-03 145.99 146.37 145.34 145.73 144761800 135.1812
756 2013-01-02 145.11 146.15 144.73 146.06 192059000 135.4873
757 2012-12-31 139.66 142.56 139.54 142.41 243935200 132.1016

Pessoalmente prefiro fazer 'batota' e escrever uma linha de código que me mostra as primeira 3 cotações e também a última.

> print(SPY[c(1:3,nrow(SPY)),])
Date Open High Low Close Volume Adj.Close
1 2015-12-31 205.13 205.89 203.87 203.87 102929500 200.7605
2 2015-12-30 207.11 207.21 205.76 205.93 63317700 202.7890
3 2015-12-29 206.51 207.79 206.47 207.40 92640700 204.2366
757 2012-12-31 139.66 142.56 139.54 142.41 243935200 132.1016

Passo 3:Tratamento dos dados

Assumindo que eu apenas pretendo fazer uma série temporal e que as colunas Open High Low Close Volume, não me interessam e pretendo apaga-las.

Para isso vamos usar uma biblioteca que nos simplifica bastante a tarefa. Trata-se do dplyr. Vamos ter de primeiro instalar essa biblioteca no R com o seguinte comando na consola.

> install.packages("dplyr")
Installing package into ‘C:/Users/a/Documents/R/win-library/3.3’
(as ‘lib’ is unspecified)
trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.3/dplyr_0.5.0.zip'
Content type 'application/zip' length 2407553 bytes (2.3 MB)
downloaded 2.3 MB

package ‘dplyr’ successfully unpacked and MD5 sums checked

The downloaded binary packages are in
C:\Users\a\AppData\Local\Temp\RtmpWCjn8U\downloaded_packages

Pode, como é óbvio mudar alguns directórios etc, mas deverá SEMPRE aparecer: package ‘dplyr’ successfully unpacked and MD5 sums checked

Nunca mais vamos ter de instalar o dplyr mas vamos sempre ter de o importar sempre que o quisermos usar, usando o comando library(). Pelo que recomendo que no Script coloquem logo library(dplyr) no topo.

Com esta biblioteca o tratamentos dos dados torna-se super simples e apenas temos de informar ao R qual as colunas com que pretendemos ficar:

SPY <- select(SPY, Date, Close, Adj.Close)

Se quisermos confirmar que está tudo como pretendemos podemos usar o comando para visualização das cotações:

> print(SPY[c(1:3,nrow(SPY)),])
Date Close Adj.Close
1 2015-12-31 203.87 200.7605
2 2015-12-30 205.93 202.7890
3 2015-12-29 207.40 204.2366
757 2012-12-31 142.41 132.1016

Depois de deliberarmos de devemos usar o Close ou o Adj.Close decidimos usar o fecho ajustado pois inclui as mais valias dos dividendos e por isso representa mais correctamente os ganhos de um investidor em SPY. Vamos então apagar o coluna Close com o comando anterior ligeiramente modificado:

SPY <- select(SPY, -Close)

desta vez em vez de seleccionarmos as colunas com que queremos ficar, excluímos aquela que não queremos.

De novo podemos testar para ver se está tudo como esperado:

> print(SPY[c(1:3,nrow(SPY)),])
Date Adj.Close
1 2015-12-31 200.7605
2 2015-12-30 202.7890
3 2015-12-29 204.2366
757 2012-12-31 132.1016

Acabamos assim a primeira parte, ficando (aparentemente) com os dados como pretendemos. Vou no final da segunda parte anexar o meu ficheiro .R (com o código) que recomendo que tenham aberto ao mesmo tempo que lêem o texto pois penso que visualizando o código simplifica em muito a compreensão do que estou a dizer.

[VirtuaGod]

Aula 1_10: Valores lógicos e operadores relacionais(15 minutos)

Vamos começar por aprender os operadores relacionais:



Reparem como se for comparação temos de usar dois iguais (==).

Até aqui tudo simples e intuitivo, assim como será o próximo passo:

1 > 5
[1] FALSE
6 == 7
[1] FALSE
6 > 4
[1] TRUE
5 !=8
[1] TRUE

Sabendo que TRUE quer dizer Verdadeiro e FALSE quer dizer Falso faz todo o sentido.

Até aqui tudo simples e completamente intuitivo. O próximo passo poderá ser o mais complicado e envolve Lógica.

Assim e combinado diferentes TRUE e FALSE vai-se ter um TRUE ou FALSE final. Para as combinações vou apresentar dois novos símbolos:

& - O 'E' comercial representa um simples 'e'. No sentido de "O S&P é um índice de acções e um dos índices accionistas mais famosos do mundo". Para a frase ser verdadeira ambas as proposições têm de ser verdadeiras. Se um for falsa toda a frase se torna falsa. Por exemplo: "O S&P é um índice accionista e representa 500 acções russas." Viram como se uma das proposições for falsa toda a frase se torna falsa?

| - A Barra vertical significa OU. Pegando na frase acima e alterando o & por OU temos " O S&P é um índice accionista OU representa 500 acções russas". Neste caso apenas a primeira proposição OU a segunda tem de ser verdadeira para que a frase como um todo seja verdadeira.

Vamos testar alguns exemplos no R:

3 < 6 & 8 != 9
[1] TRUE
3 < 6 & 8 > 9
[1] FALSE
2 > -1 | 7 > 9
[1] TRUE

Reparam como no caso do & ambas as proposições têm de ser verdadeiras mas como caso do | (OU) apenas uma tem de ser verdadeira para as frases serem verdadeiras como um todo?

Intuitivamente e lendo para nós penso que a maioria das pessoas se aperceberá facilmente deste facto.

Penso que é este post é o que por fim precisamos para passarmos para algo mais interessante no que diz respeito a tratamento de dados. Próximos posts serão sobre importação e tratamento de dados.

[VirtuaGod]

Aula 1_09: Matriz (15 minutos)

Criar uma matriz

Para criar uma matriz usa-se o comando matrix() (matriz em inglês).

Mas como sabemos uma matriz não tem necessariamente uma só coluna e/ou linha. Desta forma ao escrever o comando devemos dizer quantas colunas (ncol) ou linhas (nrow) queremos. Row é inglês para linha (neste caso).

Assim:

>m1 <- matrix(1:20, ncol = 4)
# Cria uma matriz com os números de 1 a 20 e 4 colunas
>m1
[,1] [,2] [,3] [,4]
[1,] 1 6 11 16
[2,] 2 7 12 17
[3,] 3 8 13 18
[4,] 4 9 14 19
[5,] 5 10 15 20

O que acontece se não identificarmos o números de colunas ou linhas é que o R assume ncol = 1. Experimentem na consola e vejam por vocês mesmos.

Se quisermos os números dispostos por linhas e não por colunas temos de informar o R.

>m2 <- matrix(1:20, ncol = 4, byrow = TRUE)
>m2
[,1] [,2] [,3] [,4]
[1,] 1 2 3 4
[2,] 5 6 7 8
[3,] 9 10 11 12
[4,] 13 14 15 16
[5,] 17 18 19 20

Se por acaso quiserem um número de linhas ou colunas que não se adeqúe o R dá erro.

m3 <- matrix(1:30, ncol = 4, byrow = TRUE)
m3
[,1] [,2] [,3] [,4]
[1,] 1 2 3 4
[2,] 5 6 7 8
[3,] 9 10 11 12
[4,] 13 14 15 16
[5,] 17 18 19 20
[6,] 21 22 23 24
[7,] 25 26 27 28
[8,] 29 30 1 2
Warning message:
In matrix(1:30, ncol = 4, byrow = TRUE) :
data length [30] is not a sub-multiple or multiple of the number of rows [8]

Acrescentar uma coluna (ou linha) a uma matriz

Voltando às nossas matrizes iniciais. Para o exemplo vamos usar m1.

> m1
[,1] [,2] [,3] [,4]
[1,] 1 6 11 16
[2,] 2 7 12 17
[3,] 3 8 13 18
[4,] 4 9 14 19
[5,] 5 10 15 20

Imaginemos que temos uma coluna que queremos acrescentar a m1.

Coluna a acrescentar a m1:

m4 <- matriz(21:25)
m4
[,1]
[1,] 21
[2,] 22
[3,] 23
[4,] 24
[5,] 25

Para acrescentarmos a coluna (matriz 4) a m1 (matriz 1) usamos a função cbind():

> cbind(m1, m4)
[,1] [,2] [,3] [,4] [,5]
[1,] 1 6 11 16 21
[2,] 2 7 12 17 22
[3,] 3 8 13 18 23
[4,] 4 9 14 19 24
[5,] 5 10 15 20 25

Se quisermos adicionar uma linha (row) a função é rbind() (bind em inglês quer dizer unir)

Criação de matrizes através de vectores

Ao longo do livro/curso vamos usar muito o SPY e o TLT. Dois ETFs de que gosto bastante pelas suas características. O SPY é um tracker do S&P e o TLT são treasuries de longo prazo (com cerca de 20 anos de maturidade).

Vamos buscar os valores de fecho nesta última semana destes ETFs:

SPY

Aug 05, 2016: 218.18
Aug 04, 2016: 216.41
Aug 03, 2016: 216.18
Aug 02, 2016: 215.55
Aug 01, 2016: 216.94

TLT

Aug 05, 2016: 138.00
Aug 04, 2016: 139.45
Aug 03, 2016: 138.41
Aug 02, 2016: 138.33
Aug 01, 2016: 139.77


# Criar vector com os valores de fecho de SPY
SPY <- c(216.94, 215.55, 216.18, 216.41, 218.18)

# Criar Vector com os valores de fecho de TLT
TLT <- c(139.77, 138.33, 138.41, 139.45, 138.00)

# Combinar os vectores para criar a matrix
ETFs <- rbind(SPY, TLT)
print(ETFs)

print(is.matrix(ETFs)) #confirmar que ETFs é uma matrix

na Consola deverá aparecer:

> source('C:/.../Programação em R para Finanças/Aula_1_09.R')
[,1] [,2] [,3] [,4] [,5]
SPY 216.94 215.55 216.18 216.41 218.18
TLT 139.77 138.33 138.41 139.45 138.00
[1] TRUE

Dar nomes às colunas

Para dar nomes às colunas devemos usar a função colnames() (estilo "colunas nomes"). Caso quiséssemos alterar as linhas usaríamos rownames()

# Criar vector com o nome que queremos que as colunas tenham
dias <- c("Seg", "Ter", "Qua", "Qui", "Sex")
# Queremos que os nomes das colunas da matrix 'ETFs' sejam o vector 'dias'
colnames(ETFs) <- dias
print(ETFs)

Ao correm o Script na consola aparecerá tudo o que fizemos:

source('C:/.../Programação em R para Finanças/Aula_1_09.R')
[,1] [,2] [,3] [,4] [,5]
SPY 216.94 215.55 216.18 216.41 218.18
TLT 139.77 138.33 138.41 139.45 138.00
[1] TRUE
Seg Ter Qua Qui Sex
SPY 216.94 215.55 216.18 216.41 218.18
TLT 139.77 138.33 138.41 139.45 138.00

[VirtuaGod]

Aula 1_08: Vectores (15 minutos)

Como viram na aula anterior o vector é uma estrutura de dados que é em formato de linha.

>v1<- c(1, 2, 3, 4, 5) # cria o vector 1
>v1
[1] 1 2 3 4 5

Operações com vectores

>2 * v1 # Multiplica por 2 todos os elementos do vector 1
[1] 2 4 6 8 10

>v2 <- c(2, 4, 3, 1, 5)
>v2
[1] 2 4 3 1 5

>v1 + v2
# Soma o elemento 1 do vector 1 com o elemento 1 do vector 2 e assim sucessivamente
[1] 3 6 6 5 10

> sum(v1) # soma todos os elementos do vector_1
[1] 15

Formas especiais de criar vectores

Criar vector de 1 a 50 sem escrever os números todos:

> v3 <- 1:50
> v3
[1] 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] 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] 49 50

Criar vector com números pares de 2 a 50:

> v4 <- seq(from = 2, to = 50, by = 2)
# escolhe-se o valor inicial, o valor final e o intervalo
> v4
[1] 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50

Vector com a repetição de um número ou sequência

>v5 <- rep(x = 1, 5) # vector com o número 1 repetido 5 vezes
>v5
[1] 1 1 1 1 1

>v6 <- rep(x = c(1, 2, 3), 5) # Repetir 5 vezes o vector [1, 2, 3]
>v6
[1] 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3

Ordenar um vector

>sort(v6, decreasing = FALSE)
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3

>sort(v6, decreasing = TRUE)
[1] 3 3 3 3 3 2 2 2 2 2 1 1 1 1 1

Tamanho de um vector

>length(v6)
[1] 15

Elementos individuais

>v6 # Relembrar o vector 6
[1] 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3

>v6[5] # Selecciona o quinto elemento do vector 6
[1] 2

>v7 <- v6[-5] # Eliminar o quinto elemento do vector_6
>v7
[1] 1 2 3 1 3 1 2 3 1 2 3 1 2 3

>length(v7)
[1] 14


Simples tratamento de dados com vectores

Vamos fazer um “Quadro” com as diferentes temperaturas ao longo da semana.

# Primeiro fazermos um vector com as diferentes temperaturas

> temperaturas <- c(24, 27, 23, 27, 25, 26, 24)

# depois fazemos um vector com os diferentes dias da semana

> dias <- c("Seg", "Ter", "Qua", "Qui", "Sex", "Sab", "Dom")

# usamos a função names() para associar as diferentes temperaturas aos respectivos dias

> names(temperaturas) <- dias

# Depois de associados os dias da semana vamos ficar como ficou os nosso vector temperaturas

> temperaturas
Seg Ter Qua Qui Sex Sab Dom
24 27 23 27 25 26 24

Eu sei que provavelmente estas aulas iniciais de estrutura de dados são um pouco chatas e abstractas. Mais à frente, quando efectivamente tivemos a tratar com dados, é que vão realmente começar a usar as funções de que falo acima. Por enquanto é necessário pelo menos saber o que se pode fazer com cada estrutura de dados e escrever estes códigos exemplo para depois facilmente sabermos como fazer algo (ou adaptarmos o código consoante as nossas necessidades).

A grande vantagem da vida real face ao nosso tipo de ensino é que ninguém tem de decorar nada. Mais à frente se precisarmos de acrescentar uma coluna a uma matriz e não sabermos como (mas sabemos que é possível) basta ir ao índice e clicar na aula sobre matrizes onde estará explicado como fazer o que pretendemos. Com o tempo, se fizermos muito tratamento de dados, acabamos por decorar as funções naturalmente.

[VirtuaGod]

Aula 1_07: Estrutura de dados (2 minutos)

Esta pequena aula é só para apresentar as diferentes estruturas de dados e ficarem com uma noção geral do que vai ser apresentado nas aulas seguintes.

O R tem diferentes formas e estruturas para guardar/apresentar os dados. Já vimos uma, as variáveis. Ao dizermos x <- 2 estamos a dizer ao R para "guardar" o 2 como valor numérico de x.

Mas e se quisermos guardar uma coluna? Uma linha? Uma matrix (semelhante ao formato que vemos no excel)? Isso é o que vamos ver mais à frente mas deixo aqui uma imagem que vos pode ilucidar, e podem sempre voltar a esta imagem que se calhar vão tendo uma visão diferente depois de efectivamente trabalharem com as diferentes estruturas de dados.


Fonte: Kabacoof, R in Action, 2nd edition

Estas estruturas de dados são chamadas de Objectos.

[VirtuaGod]

Aula 1_06: O nosso primeiro Script (10 minutos)

Ora bem, primeira palavra esquisita. Um Script não é nada mais que um ficheiro de R onde escrevemos o código. Não faz sentido estar a escrever tudo na consola onde dificilmente pode ser reaproveitado. Como vimos na aula anterior tivemos de dizer à máquina para recalcular o valor de z depois de alterarmos o valor de x.

Ora não é nada eficiente estar sempre a rescrever x <- 5 e x <- 10 sempre que quisermos alterar o valor de x. Depois ainda temos de dizer ao R que recalcule z???

Entra o Script para nos salvar. Em vez de usarmos a 'Consola' directamente devemos usar o editor, ou 'Source' do RStudio.

Antes de avançarmos vamos já começar com boas políticas de trabalho. Assim:

1º: Gravar logo o ficheiro do editor. Sim, em branco. Primeira coisa a fazer antes de começar a escrever código é fazer ctrl+s e gravar o ficheiro num directório à escolha com um bom nome para identificarmos logo o que está no Script.

2º: No topo de qualquer Script devemos ter a função setwd(). A função setwd() é para informarmos o R do directório onde estamos a trabalhar. wd de working directory. Neste caso não seria necessário mas irá ser no futuro e mais vale fazer sempre.

Desta forma devemos iniciar os Scripts com:

setwd("'C:/...'")

O que está entre parênteses a seguir ao setwd é o directório do vosso computador onde o ficheiro está gravado. Atenção porque o windows usa \ que devemos transformar em / no R. Depois sempre que fizermos 'source' o R vai regravar (ver aula 1_02 se não têm essa opção ligada) e dificilmente perdemos o nosso trabalho.

Assim no editor, tendo em consideração a última aula podemos escrever logo tudo:

setwd("'C:/.../Programação em R para Finanças/'")

x <- 5
y <- 3
z <- x + y
print(z)

Devemos ter em atenção que ao contrário da consola aqui temos mesmo de dar a ordem print(z) para o R saber o que tem de colocar como resultado na Consola. Se só colocarem z nada aparentemente acontece pois o R não escreve o valor de z na Consola.

Se escrevermos o que se encontra acima no editor e pressionarmos F5 (caso tenham o atalho) vamos ver na Consola:

> source('C:/.../Programação em R para Finanças/Aula 1_06.R')
[1] 8

Desta vez quando quiserem alterar o valor de x e consequentemente o de z só têm de alterar um número e carregar de novo em F5:

setwd("'C:/.../Programação em R para Finanças/'")

x <- 10
y <- 3
z <- x + y
print(z)

na consola aparece:

> source('C:/.../Programação em R para Finanças/Aula 1_06.R')
[1] 13

Daqui para a frente poderei não dizer se algo está escrito na consola ou no editor. Se está em vermelho bordô está escrito no editor. Se por outro lado estiver a azul está escrito na Consola. Devem ter também sempre em atenção ao > ou ao [1] que mostra bem que está na consola.

[VirtuaGod]

Aula 1_05: Variáveis (5 minutos)

R tem a capacidade de atribuir um valor a variáveis. Para isso usamos o símbolo <-. Não há o símbolo no teclado. É uma construção de < mais -

Irei usar alguns exemplos com álgebra simples para compreenderem:

> x <- 5
> y <- 3
> x + y
[1] 8

Para associar o resultado a qualquer outra variável podemos fazer:

>z <- x + y
>z
[1] 8

Neste último exemplo estamos a dizer que z é igual a x + y. Contudo se alteramos x ou y na consola NÂO tem impacto no valor de z.

> x <- 10
> z
[1] 8

Parece contra intuitivo mas faz literalmente sentido (como não podia deixar de ser nas máquinas). Isto porque ao colocar 'z' na consola estão a dizer 'escreve o valor de z' e não 'recalcula z', pelo que a máquina vai buscar o valor já calculado de z, que era 8. Se quisermos recalcular z tendo em consideração o novo valor de x temos de dar ordens para 'recalcular z'. Assim:

> z <- x + y
> z
[1] 13

Podemos também fazer contas com z:

> z * 2
[1] 26

> z + y
[1] 16

Podemos até alterar o valor de z novamente:

> z <- z + z
> z
[1] 26

* Na aula seguinte vamos ver como alterando x ou y se tem impacto em z

[VirtuaGod]

@NM_2 A ideia é ser o mais simples possível. Fico feliz por estar a conseguir transmitir isso. Penso que a maioria do conhecimento considerado complicado (matemática, programação etc) é muito simples se excluirmos o seu uso a nível mais avançado* mas infelizmente acho que não é ensinado da forma mais correcta e só perpetua o mito de que são coisas complicadas/difíceis.

Posso escrever algo em python aqui que toda a gente percebe:


Acho que é compreensível o que a consola vai escrever caso se mantenham o valor de a = 2 ou se alterarmos para a = 4. Isto é um pouco um aparte para quem nos lê e acha isto complicado.

Se tiveres dúvidas ou questões como se podem fazer coisas que não sejam ditas explicitamente na literatura expõe a questão e tento ajudar!

Agradeço e aceito a ajuda até de outra forma. Sempre que vires algo desnecessário no código ou tiveres um truque avisa. Como sou autodidacta tenho imensos truques que nem sei se são os mais correctos. Aprendo código mais numa de desenrasca do que de seguir as linhas 'normais' de programador. Vai dando dicas se puderes/quiseres. Um dos truques que uso e sempre tive dúvidas se será a forma mais simples é o uso do Word para a função "substituição de texto". Às vezes em R tenho bons bocados de código em que só pretendo alterar os tickers de activos financeiros de SPY para TLT e uso o Word e faço isso em 15/20 linhas de código praticamente instantaneamente.

* acho que ng acha matemática pura ou física teórica simples

P.S. Para quem não sabe inglês tradução livre seria 'if' quer dizer 'se' e 'else' quer dizer 'senão'

[NM_2]

Muito bom!!!!!

Mesmo eu já tendo conhecimento do R e vindo a usá-lo desde 2012 vi coisas úteis na simplicidade com que colocas!!!

Obrigado e dos tópicos mais úteis aqui do Caldeirão!!!!

Se tiveres dúvidas ou questões como se podem fazer coisas que não sejam ditas explicitamente na literatura expõe a questão e tento ajudar!

PS: Tinha a versão 0.98 instalada e para "code" settings existem muito mais opções na 0.99...

[VirtuaGod]

Aula 1_03: Aritmética (10 minutos)

Vamos começar por alguma aritmética simples. Qualquer pessoa que já trabalhou com uma TI84 ou uma TI89/Voyage™ 200 sabe como trabalhar com R a este nível.

Operadores:

+ Soma
- Subtracção
* Multiplicação
/ Divisão
^ Expoente

O R não tem o símbolo de raiz quadrada. Teremos de fazer a transformação matemática: √3 = 3^(1/2) ou usar a função sqrt.

Seguem aqui alguns exemplos de cálculos na Consola:

> 2 + 2
[1] 4

> 4 - 3
[1] 1

> 5 * 2
[1] 10

> 6 / 3
[1] 2

> 5 ^ 2
[1] 25

> sqrt (25)
[1] 5

> 25 ^ (1/2)
[1] 5

R segue as regras da matemática sobre prioridades de operações. Assim:

> 4 / 2 + 5
[1] 7

> 4 / (2 + 5)
[1] 0.5714286

Algumas fórmulas/contas aritméticas acabam por se tornar em linhas de código algo complicadas. Felizmente não mais complicadas que a introdução das contas numa calculadora avançada.

Assim, vamos por exemplo calcular em R a seguinte conta:



O código para cálculo desta conta é:

> 10 ^2 + 3 * 60/8 - 3
[1] 119.5

Dica: Se por acaso quiserem confirmar se a conta está como pretendido, visualizando no formato comum, podem testar no Wolfram Alpha.

[VirtuaGod]

Aula 1_02 - Personalização do ambiente de trabalho (10 minutos)

Depois de instalados os programas provavelmente vão querer personaliza-los. Podemos perder mais ou menos tempo mas acredito que um ambiente agradável aos olhos, com as janelas nos locais que preferimos e com os atalhos de teclados certos podemos aumentar significativamente a nossa eficiência e semi-automatizar as tarefas mais chatas tornando a programação mais agradável.

Primeira coisa que faço mal instalo um IDE é ir às definições e customizar as coisas à minha maneira. No caso do RStudio podem encontrar as definições em: Tools -> Global options. Muitas das definições de origem são já bastante boas. Irei contudo colocar aqui as pequenas alterações que fiz*:


Code -> Editing

Em 'Execution' coloquei um visto em 'Always save R scripts before sourcing' para que quando corremos o código ele grave sempre.

Code -> Display

Show Margin - Check
Margin Column: 80 (este 80 vem de Python e achei que fazia sentido fazer o mesmo em R)

Code -> Completion

Tenho auto completion depois de 2 characters e com 50ms depois de o teclado estar parado (gosto bastante da função )

Code -> Diagnostics

Liguei (coloquei visto em) tudo pois ensina a escrever bem em R

Appearance

Uso em Monokai com fonte 'Consolas' de tamanho 10

Pane layout

Uso o Editor e a Consola em lados diferentes do ecrã (talvez depois a programar se vão habituando a ver como se dão melhor)

No que diz respectivo à visualização penso que está tudo.

Depois altero os atalho de teclado em Tools -> Keyboard Shortcuts onde apenas alterei o 'Source Active Document' para F5 de forma a que o código corra todo apenas com o pressionar da tecla F5

Por último uso um software que normalmente deixo ligado no computador mesmo quando não estou a programar que é o AutoHotkey. Uso o F2 como ctrl+x, F3 como ctrl+c, f4 como ctrl+v (cut, copy e paste respectivamente) e "º" (está ao lado do ~) como '<-' que é um símbolo que vamos usar muito em R.

Deixo em anexo o sript em versão .AHK** que podem usar depois de instalar o AutohotKey: Link DropBox para AutoHotKey (atalhos para R). Em alternativa têm aqui o código que uso e para quem quiser customizar os atalhos não deverá ser muito complicado de alterar (algumas pessoas poderão querer usar um atalho para o '=' por exemplo).

#z::suspend

F2::Send, ^x

F3::Send, ^c

F4::Send, ^v

º:: Send, <-


* algumas das opções poderão já estar por defeito. Não me recordo de TODAS as alterações que fiz
** Depois podem alterar o ficheiro .AHK para .EXE de forma a funcionar em qualquer computador Windows mas não quero partilhar um ficheiro .EXE

[VirtuaGod]

Aula 1_01: Instalação de R e RStudio (10 minutos)

Vamos começar pelo início. Penso que ninguém terá muita dificuldade nestes passos.

Deveremos primeiro instalar o R. Devem ir até ao espelho português que é da Radical Development: http://cran.radicaldevelop.com/. Aqui selecionem a versão pretendida (Linux/Mac/Windows). Se optarem pela versão Windows não se esqueçam que a opção seguinte é "Install R for the first time" para ir ter à aplicação em si. A versão actual na altura que escrevo é a 3.3.1

Depois de terem instalado o R devemos instalar o RStudio que é o IDE (Ambiente de desenvolvimento integrado) onde vamos trabalhar. RStudio: https://www.rstudio.com/products/rstudio/download2/. A opção que deverão seleccionar é 'RStudio Desktop (Free License)' e depois escolher a versão consoante o computador. A versão actual na altura que escrevo é a 0.99.903

Assim que abrirem o RStudio devem visualizar 4 janelas em que numa delas (a consola) aparecerá a seguinte mensagem:

"R version 3.3.1 (2016-06-21) -- "Bug in Your Hair"
Copyright (C) 2016 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64 (64-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R."

Se tiverem a sacar uma versão futura obviamente o texto que vêem não será exactamente igual mas provavelmente só variará no primeiro paragrafo (texto a itálico).

Qualquer dúvida nesta "aula" nem vale a pena perguntar. Fechem o tópico e esqueçam que um dia pensaram em aprender programação Algum erro em links ou assim agradeço que avisem para se ir actualizando.