Introdução ao ambiente R

Download e instalação do R

• Download do R: http://cran.r-project.org/ .
• Download do RStudio: http://www.rstudio.com/products/RStudio/ .
• Download do Emacs+ESS (versão para Windows): http://vgoulet.act.ulaval.ca/en/emacs/, usuários Linux instalam por sudo apt-get install emacs ess.
• Download do Tinn-R (para Windows apenas): http://sourceforge.net/projects/tinn-r/ .
• Outros editores:
  • Wikipedia - R programming language editors
  • Sciviews - Editors

Primeiros passos

Abra o R instalado em seu sistema para iniciar uma sessão.

## Texto após o sinal de hash não é interpretado, serve de comentário.

2+6+5+9+3+2 ## Comentário pode ser após alguma instrução.

## Uma intrução pode ser dividida em duas linhas.
2+6+5+
    9+3+2

## E em uma linha podem existir mais de uma instrução.
2+6; 14+12; 40-23

Objetos

Em um curso introdutório aborda-se os 4 tipos básicos de objetos para armazenamento de dados no R: vetores, arranjos, tabelas (data.frames) e listas. Em resumo, distinguem-se tais objetos pela forma na qual armazenam dados.

• vetor: tem apenas uma dimensão que é o comprimento (número de elementos) e armazena valores de apenas um tipo (ex. só números inteiros).
• arranjo (array): é uma extensão de vetor que permite mais de uma dimensão. Só permite um tipo de valor. No caso de ter duas dimensões (linha e coluna) chamamos os arranjos de matrizes.
• tabela: no idioma R são mais conhecidos por data frames. Têm duas dimensões (linha e coluna). Cada coluna é como se fosse um vetor e por isso pode ter tipo de conteúdo diferente das demais colunas. Todas as colunas têm o mesmo comprimento (que é o que permite acomodar no formato de tabela).
• lista: é um tipo de objeto cuja unidade básica é o item da lista. O “tamanho” da lista é o número de elementos/itens que possui. Cada elemento, no entanto, pode ser um objeto de qualquer classe mecionada acima. O data frame é uma lista especial na qual cada item é um vetor (ou matriz) de mesmo número de elementos (linhas).

Nos objetos é importante conhecer formas de selecionar os valores dentro do objeto. Além disso, conhecer os atributos e saber modificá-los é interessante principalmente porque gráficos e procedimentos sobre tais objetos dependem dos seus atributos propriedades. As formas de selecionar elementos de um objeto são com os operadores:

• [], [ , ], [ , , ]: para vetores e arranjos. As virgulas servem para especificar à dimensão que recebe seleção. Serve para selecionar listas e data frames também.
• $: para listas e data frames (pois DF é um caso de lista).
• [[]]: serve para listas.
• @: serve para listas de objetos classe S4.

A seleção de elementos/linhas/colunas/itens nos objetos pode ser de 4 formas:

• Pelo índice: número inteiro correspondente à sua posição.
• Por um vetor lógico: valores TRUE vão selecionar os elementos correspondentes.
• Pelo nome: quando o elemento possui nome.

Abaixo são ilustrados os 4 tipos básicos, atributos e seleção.

##-----------------------------------------------------------------------------
## Vetor.

x <- 100:105

## Atributos.
class(x)
mode(x)
typeof(x)
length(x)
str(x)
attributes(x)
dput(x)
is.vector(x)
is.numeric(x)
is.integer(x)

x[3:5]
x[-2]
x[c(2,3)]

##-----------------------------------------------------------------------------
## Vetor nomeado.

x <- c(Paulo=7.8, Ulisses=9.0, Ricardo=8.5, Lincon=4.5, Thobias=7.1)

## Atributos.
class(x)
mode(x)
typeof(x)
length(x)
str(x)
attributes(x)
dput(x)
is.vector(x)
is.numeric(x)
is.integer(x)

x[3:5]
x[-2]
x[c(2,3)]

x["Ulisses"]
x[c("Ricardo","Thobias")]

##-----------------------------------------------------------------------------
## Um arranjo de duas dimensões.

X <- matrix(1:9, nrow=3, ncol=3)

class(X)
mode(X)
typeof(X)
dim(X) ## ncol(X) e nrow(X).
str(X)
attributes(X)
dput(X)
is.matrix(X)
is.array(X)
is.numeric(X)
is.integer(X)

X[1,]
X[1:2,]
X[-2,]
X[,-2]
X[,c(3,2,1)]
X[3:1,c(3,2,1)]

##-----------------------------------------------------------------------------
## Um arranjo de 3 dimensões (cúbico).

X <- array(1:24, dim=c(3,4,2))

class(X)
mode(X)
typeof(X)
dim(X) ## ncol(X) e nrow(X).
str(X)
attributes(X)
dput(X)
is.matrix(X)
is.array(X)
is.numeric(X)
is.integer(X)

X
X[1,,]
X[,1,]
X[,,1]

##-----------------------------------------------------------------------------
## Um data frame.

da <- data.frame(id=1:5,
                 aluno=c("Júlio", "Ana", "Pietra", "Bianca", "Nelson"),
                 nota=c(9,8.5,7.1,9.8,8), falta=c(12,4,4,0,2))

class(da)
mode(da)
typeof(da)
dim(da) ## ncol(da) e nrow(da).
str(da)
attributes(da)
dput(da)
is.data.frame(da)
is.list(da)

da[1,]
da[,2]
da[,"aluno"]
da[,c("nota", "falta")]
da[1:3,c("nota", "falta")]

##-----------------------------------------------------------------------------
## Uma lista.

L <- list(item1=x,
          item2=X,
          item3=da)

class(L)
mode(L)
typeof(L)
length(L)
str(L)
attributes(L)
dput(L)
is.data.frame(L)
is.list(L)

Regras lógicas

É muito frequênte a necessidade de selecionar elementos de um objeto de acordo com alguma regra lógica. No objeto da, por exemplo, quais os alunos com mais de 10 faltas? Quantos alunos nota superior à 9?

Para responder à essas perguntam tem-se que utilizar regras lógicas. As regras lógicas podem ser simples ou compostas. Os operadores para regras lógicas são < > <= >= == !=. Os operadores para fazer regras compostas são o E & e o OU |. E o operador %in% é usado para representar o operador pertence para conjuntos. O resultado de uma regra lógica é um vetor lógico que no caso será usando para seleção. São operadores também úteis o “todos” all() e “algum” any().

## Selecionando as notas maiores que 8.
sel <- da$nota>8; sel
da[sel,]

## Selecionando as notas maiores que 8 com faltas não superior à 10.
sel <- da$nota>8 & da$falta<=10; sel
da[sel,]

## O operador ! inverte um vetor lógico.
!sel
da[!sel,]

sel <- da$aluno%in%c("Ana","Bianca")
## sel <- is.element(da$aluno, c("Ana","Bianca"))
da[sel,]

all(da$nota>7)
any(da$falta<10)
sum(da$nota>8)

Conversão

As conversões podem ser de formato ou de tipo de conteúdo. Pode-se precisar converter um data frame em uma matriz para, por exemplo, fazer uma análise de componentes principais bem como converter um vetor de characteres para fator para mudar a ordem ou rótulo de seus níveis. As funções para conversão iniciam com o padrão as.*.

## As funções para conversão.
apropos("^as\\.")

## De numérico para inteiro.
x <- seq(from=1, to=12, by=2)
x

is.integer(x)
object.size(x)

x <- as.integer(x)
object.size(x)

## De data.frame para lista.
as.list(da)

## De vetor para matriz.
as.matrix(x)

Dentre os tipos de conversão deve-se destacar a importância daquela que envolve characteres e fatores. Muitos dos métodos de análise de dados, das tabelas de frequência até análise de variância são desenvolvidos para dados do tipo fator.

## Um vetor com 3 níveis.
x <- sample(c("bom","regular","ruim"), size=10, replace=TRUE)

## Atributos.
class(x)
mode(x)
typeof(x)
length(x)
str(x)
attributes(x)
dput(x)
is.vector(x)
is.character(x)
is.factor(x)

## Conversão.
x <- as.factor(x)

## Atributos.
class(x)
mode(x)
typeof(x)
length(x)
str(x)
attributes(x)
dput(x)
is.vector(x)
is.character(x)
is.factor(x)

levels(x)
nlevels(x)

Informações da sessão

Consultar e fornecer as informações da sessão é algo útil para ter conhecimento da versão do R e seus pacotes bem como detalhes do sistema operacional. Dessa forma pode-se verificar se a atual instalação está defasada, por exemplo. Usuários Linux que fazer instalação do R pelo repositório debian estão sempre com a versão mais recente do R.

## Lista os objetos existentes.
ls()

## Remove objetos existentes.
rm(list=c("da", "L"))

## Mostra informações da sessão, versões e pacotes.
sessionInfo()

## Mais informações.
cbind(Sys.info())

## Salva a imagem (objetos criados) para serem carregados no futuro ou
## compartilhados.
save.image("minhaprimeirasessao.RData")
rm(list=ls())
ls()

## Carrega sessão.
load("minhaprimeirasessao.RData")
ls()

## Mostra o diretório de trabalho.
getwd()

## Mostra os arquivos dentro no diretório.
list.files()

Instalar pacotes oficiais

Os pacotes oficiais para o R são disponibilizados pelo cran.r-project.org.

## Instala um pacote.
install.packages("plyr", dependencies=TRUE,
                 repos="http://cran-r.c3sl.ufpr.br/")

## Instala vários.
install.packages(c("plyr", "doBy", "multcomp", "latticeExtra", "devtools"),
                 dependencies=TRUE,
                 repos="http://cran-r.c3sl.ufpr.br/")

## Faz requisição do pacote.
require(plyr)
require(multcomp)

Instalar pacotes do GitHub

Muitos desenvolvedores de pacotes R têm utilizado o GitHub para manter seus projetos e fazer colaboração em código. O pacote knitr e o plyr são exemplos de pacotes R mantidos no GitHub.

## Pacote wzRfun por Walmes Zeviani.
browseURL("https://github.com/walmes/wzRfun")

require(devtools)
install_github("wzRfun", "walmes")

print(sessionInfo(), locale=FALSE)

## R version 3.1.1 (2014-07-10)
## Platform: i686-pc-linux-gnu (32-bit)
## 
## attached base packages:
## [1] stats     graphics  grDevices utils     datasets  base     
## 
## other attached packages:
## [1] rmarkdown_0.3.3 knitr_1.6      
## 
## loaded via a namespace (and not attached):
## [1] digest_0.6.4    evaluate_0.5.5  formatR_0.10    htmltools_0.2.6 stringr_0.6.2  
## [6] tools_3.1.1

Sys.time()

## [1] "2014-10-07 00:48:06 BRT"