Linguagem R

R é uma linguagem e um ambiente de desenvolvimento integrado voltada para cálculos estatísticos, gráficos e "data miners", utilizada para análise financeira, de redes sociais, avaliação da acurácia de diagnósticos, epidemiologia, etc. A R disponibiliza uma ampla variedade de técnicas estatísticas e gráficas, incluindo modelagem linear e não linear, testes estatísticos clássicos, análise de séries temporais, classificação, agrupamento e outras. O nome provêm em parte das iniciais dos criadores e também de um jogo figurado com a linguagem S (da Bell Laboratories, antiga AT&T), daí seus recursos de programação orientada por objetos. A R é uma linguagem interpretada tipicamente utilizada através de um interpretador de comandos e sua estrutura inclui escalares, vetores, matrizes, quadros de dados (similares a tabelas numa base de dados relacional) e listas.

r_language_icon

O código fonte do R está disponível sob a licença GNU GPL e as versões binárias pré-compiladas são fornecidas para Windows, Macintosh, e muitos sistemas operacionais Unix/Linux.

Instalação

Como R e pacotes relacionados atualmente não fazem parte dos repositórios oficiais de backports do Debian como jessie-backports, as versões de R nas versões liberadas ou congeladas do Debian ficam desatualizadas. Esse é o caso também de manter uma versão mais antiga do Debian.

Assim, para instalar uma versão mais atualizada do R que a do repositório, inclua a seguinte linha no final do arquivo "/etc/apt/sources.list" como super usuário:

deb https://vps.fmvz.usp.br/CRAN/bin/linux/debian/ jessie-cran34/

Como é um endereço https, você precisará instalar o pacote "apt-transport-https" e então dar um update para depois realizar a instalação, conforme os comandos que seguem:

sudo apt-get install apt-transport-https
sudo apt-get update
sudo apt-get install r-base-dev

Para atualizar, basta usar "sudo apt-get upgrade r-base-dev". Caso queira a versão do próprio repositório Debian da sua versão, basta executar "sudo apt-get install r-base".

Utilização

Digite "R" (maiúsculo) para entrar no programa e "q()" para sair - é oferecida a opção se deseja salvar os comandos utilizados naquela utilização do programa. Existe também a opção de utilizar uma interface gráfica, o RStudio - clique no link para ver sua instalação no Linux, acessível depois pelo comando "rstudio"

Em R, o comentário é iniciado por "#". Veja uma sequência de comandos que exemplificam o uso da linguagem:

> x - c(1,2,3,4,5,6)	# Cria vetor de dados, pode usar "=" em vez de "-" > y - x^2 # Eleva ao quadrado os elementos de x > mean(y)		# Calcula média aritmética do vetor
> lm_1 - lm(y ~ x) # Aplica regressão linear ao vetor "y = f(x)" / "y = B0 + (B1 * x)" > print(lm_1)		# Imprime os resultados da regressão aplicada, guardados em lm_1
> summary(lm_1)		# Calcula e imprime os resultados da regressão linear
> par(mfrow=c(2, 2))	# Requere um plot 2x2
> plot(lm_1)		# Imprime gráfico da regressão linear

É possível escrever os comandos em um arquivo externo (comandos.R, por exemplo) no mesmo diretório, ele pode ser executado através de:

> source("commands.R")

Para rodar o script R a partir do shell, utilize:

$ Rscript commands.R

Também pode-se passar variáveis do shell script como argumento para uma rotina em R, bastando colocar os valores (ou variáveis) separados por espaço após o nome do script. Na rotina em R, deverá haver o seguinte comando para receber esses argumentos:

> args - commandArgs(trailingOnly = TRUE)

Use a seguinte sintaxe para imprimir os avisos ("warnings") assim que ocorrerem:

options(warn = 1)

Se o valor de 'warn' for igual ou maior que dois, os avisos são transformados em erros; se for negativo, os avisos são ignorados; se for zero (default), os avisos são guardados e impressos no final (se forem menos que 10) ou somente informado o total (nesse caso, se quiser imprimir deve usar o comando "warnings()").

Imprimir saída na tela

Uma das formas de imprimir uma string e/ou conteúdo de uma variável é através do comando print:

print("Hello world!")

No entanto, a linha aparece iniciada por "[1]" e o conteúdo fica entre aspas duplas. Caso deseje uma saída mais limpa, use o comando "cat" - "\n indica nova linha e \t é para tabulação:

cat("\tHello world!\n")
name = c("Monolito") 
cat("\tHello, I'm ", name ,".\n")

As duas linhas abaixo mostram como introduzir variáveis na string a ser impressa na tela.

Arrays

Os vetores e matrizes apresentam as posições numeradas a partir de 1. Para trabalhar com matrizes bidimensionais, veja esse exemplo de como gerar uma matriz de dimensão 4 linhas x 5 colunas ("dim=c(4,5)") numerada de 1 a 20 e ler seus elementos:

> x - array(1:20, dim=c(4,5)) > x[2,1] # acessa o elemento na linha 2, coluna 1
> x[2,] # acessa todos os elementos da linha 2
> x[, 2] # acessa todos os elementos da coluna 2
> linha$data # pega o campo da coluna "data" no vetor "linha"
> mtcars[, -which(names(mtcars) == "carb")]	#seleciona tudo exceto a coluna "carb"
> mtcars[, names(mtcars) != "carb"]		#seleciona tudo exceto a coluna "carb"
> mtcars[, !names(mtcars) %in% c("carb", "mpg")] #seleciona tudo exceto as colunas "carb" e "mpg"
> mtcars[, -match(c("carb", "mpg"), names(mtcars))]  #seleciona tudo exceto as colunas "carb" e "mpg"

É possível imprimir arrays dizendo o que NÃO mostrar usando o sinal negativo. Por exemplo, para não mostrar as colunas 1 e 2, utilize "A[, -(1:2)]".

Listas são como vetores porque podem agrupar dados em vetores unidimensionais, porém conseguem manter grupos individuais. Por exemplo, é possível construir uma lista contendo um vetor numérico de 100 a 130, um caractere de tamanho um na segunda posição e uma nova lista de tamanho dois na terceira posição:

list1 - list(100:130, "R", list(TRUE, FALSE))
list1
## [[1]]
## [1] 100 101 102 103 104 105 106 107 108 109 110 111 112
## [14] 113 114 115 116 117 118 119 120 121 122 123 124 125
## [27] 126 127 128 129 130
##
## [[2]]
## [1] "R"
##
## [[3]]
## [[3]][[1]]
## [1] TRUE
##
## [[3]][[2]]
## [1] FALSE

Os colchetes duplos indicam a posição do elemento da lista que foi impresso, enquanto que os colchetes simples indicam a posição do primeiro sub-elemento listado.

As mais comuns estruturas de dados em R: vetores, matrizes, arrays, listas e data frames (fonte: Hands-on Programming with R).

As mais comuns estruturas de dados em R: vetores, matrizes, arrays, listas e data frames (fonte: Hands-on Programming with R).

Data frames são uma versão bi-dimensional das listas - de certa forma, equivalem às planilhas do Excel. Para ver o tipo de uma variável, utilize o comando "print(typeof(variavel))" - para aplicara essa ação a todos os elementos, utilize "print(sapply(test_data_long, typeof))" ou também "print(sapply(dados.obs,class))". Matrizes podem ser construídas a partir de outros vetores e matrizes pelas funções cbind (ligação horizontal de matrizes, como novas colunas) e rbind (novas linhas) ou também pela função merge (mescla duas data frames por colunas comuns ou nome da linha, equivalentemente ao "inner join" do SQL).

Loop

Veja um exemplo do uso do "for" para ler um vetor e de um "while":

for (word in c("My", "second", "for", "loop")) {
    print(word)
}
while (cash > 0) {
    cash - cash - 1 + play()
    n - n + 1
}

Comparação

O "if" pode ser usado para testes lógicos e booleanos. Veja esse exemplo:

if (a > b) {
    print("A wins!")
    } else if (a  b) {
    print("B wins!")
    } else {
    print("Tie.")
}

Os operadores lógicos são combinações dos sinais de "maior que", "menor que", igual (==) e diferente (!=). Já a sintaxe "a %in% c(a, b, c)" significa "está o elemento 'a' no vetor 'c(a, b, c)'?"

Funções

No script, as função ficam antes da função/rotina principal, sendo escritas da seguinte forma:

nome = function() {
	# (código)
}

De modo geral, temos que a função "as.formatoB(coisa)" salva coisa como "formatoB", enquanto que "is.formatoB(coisa)" testa se coisa está no formatoB (se verdadeiro, retorna TRUE ou 1). Por exemplo, "x=as.numeric(args)" transforma string em número. No caso de dados faltantes, é comum utilizar a sigla NaN (Not a Number), que em R é NA. A função "is.na(x)" retorna um vetor lógico (com o mesmo tamanho de x) com valor TRUE se (e somente se) o correspondente elemento de x for um NA.

Seguem algumas funções das mais comuns utilizadas:

  • getwd() - obtém diretório de trabalho
  • head(x, n) / tail(x,n) - pega a(s) primeira(s)/última(s) n linhas (ou itens de um vetor)
  • strsplit(string,'separador') - quebra string em um vetor de strings conforme o separador
  • data(x) - carrega conjunto de dados especificado
  • match(x,y) - retorna um vetor de mesmo tamanho que x com os elementos de x que estão em y
  • scan() - ler dado da tela ou arquivo como uma tabela
  • tapply(X,INDEX,FUN=) - aplica a função "FUN" para cada célula do array "X" com os índices "INDEX"
  • list() - cria uma lista de argumentos (nomeados ou não)
  • rep(x,n) - repete "x" um número "n" de vezes
  • paste() - recebe um número variável de argumentos e monta um vetor de caracteres, separados por espaço ou definido como sep="separador" (pode inclusive ser nulo, com sep=""). Ex: O comando abaixo ficaria "php diretorio_onde_estou/dados/script.php 2001 01":
path = paste('php ', getwd(), '/dados/script.php 2001 01', sep = '')
# Executa o comando da string "path"
system(path)

Caso o argumento da função sejam três pontos ("...", tecnicamente chamada "ellipsis"), isso permite um número arbitrário de argumentos e também dar argumentos adicionais para a função que está sendo aplicada - veja mais no post "The three-dots construct in R".

Packages

Pacotes são coleções de funções em R, dados e código compilado guardados no diretório "library" (padrão) ou em algum diretório definido pelo usuário.

Para instalar um novo pacote, você pode utilizar o comando "install.packages('NOME_DO_PACOTE')" para pegar o arquivo de um dos espelhos (por exemplo, "9: Brazil (SP 1) [https]"). Caso não tenha privilégios de administrador, você poderá instalar o pacote na sua conta. Para isso, crie uma pasta ("~/Rpacks", por exemplo) e execute no R o seguinte comando (a opção "dependencies=TRUE" permite instalar todas as dependências do pacote automaticamente):

> install.packages("NOME_DO_PACOTE", dependencies=TRUE, lib="~/Rpacks")

Existe também a opção de baixar o arquivo (uma boa fonte é a lista do CRAN de pacotes), abrir o R na pasta onde está o arquivo baixado e utilize o mesmo comando para instalação no sistema (com senha de administrador). Isso é muito usado para o caso de instalar outra versão do pacote que não seja a última. Para isso, utilize essa variação do comando acima:

> install.packages("/home/user/Downloads/forecast_7.3.tar.gz", repo=NULL, type="source", lib="~/Rpacks")

Também é possível digitar a URL diretamente (por exemplo 'https://cran.r-project.org/src/contrib/forecast_7.3.tar.gz') desde a versão 3.1.1 e com https desde a 3.2.2.

Os pacotes podem ser atualizados através do seguinte comando (deve-se iniciar uma nova sessão após a atualização):

> update.packages(c("pacote1", "pacote2"))

Nas páginas dos pacotes, existem "change logs" com as alterações de cada versão - veja esse exemplo do change log do pacote forecast. Sua versão pode ser consultada através de (a variável lib contém o endereço do pacote, se não estiver no endereço padrão):

packageVersion("pacote",lib="~/Rpacks")

Para carregar o pacote, utilize "require(NOME_DO_PACOTE,lib="~/Rpacks")" - se o pacote não é encontrado, retorna um warning e continua função, o contrário de library(), que retorna um erro. Use a função "suppressPackageStartupMessages()" com o comando acima como argumento para suprimir aquelas mensagens iniciais de carregamento de pacote ("loading packages"). Veja mais sobre o pacote "forecast" no post sobre modelo ARIMA.

Clique no link para saber mais sobre Arquivos e gráficos em R.

Fontes

Compartilhe o link desse texto, mas se for copiar algum trecho, cite a fonte. Valorize nosso trabalho.
Mais informações na licença de uso do site.

2 Pingbacks/Trackbacks