Introdução ao uso do software R




UFBA | IM | DEST
Kim Samejima

Introdução ao uso do software R

R é uma linguagem com foco em análises estatísticas e gráficas. É um projeto GNU com características similares à linguagem S, desenvolvida pela Bell Laboratories(atualmente Lucent Technologies) por John Chambers e sua equipe.

O R é composto por uma variedade de implementações de técnicas estatísticas(Modelos lineares e não-lineares, testes estatísticos, análise de séries temporais, clustering, análise multivariada etc) e técnicas gráficas. O R é um pacote estatístico open-source e esta flexibilidade o torna bastante popular no meio acadêmico.

Além disso, possui facilidade, robustez e qualidade na produção das análises e gráficos, incluindo símbolos e fórmulas matemáticas, uma vez que o usuário detém total controle sobre o que está sendo desenhado.

Mais sobre:
[R-project] (http://r-project.org “www.r-project.org”)
RStudio (http://rstudio.org “www.rstudio.org”)
[RJournal] (http://journal.r-project.org “R Journal”)

Cronograma

Parte 1:

  1. Instalação e Apresentação do Software;
  2. Apresentação dos principais operadores e funções do R;
  3. Os objetos do R: vetores, fatores, matrizes, listas e dataframes;
  4. Importação e exportação de banco de dados;
  5. Medidas descritivas;
  6. Medidas descritivas estratificadas em grupos e subgrupos;

Parte 2:

  1. Tabelas de frequência e contingência;
  2. Gráficos de barras, linha, Pareto, setor e boxplot para uma e mais variáveis;
  3. Introdução ao desenvolvimento e uso de funções.

Instalando o R

R-project.org

[R-project] (http://r-project.org “www.r-project.org”)

R Journal

[RJournal] (http://journal.r-project.org “R Journal”)

R Journal

R manuals

R Manuals

CRAN Mirrors

Repositórios

Download R

Arquivos de Instalação

Instalador do R para Windows 32/64bits

Instalação do R

RTools

Download RTools >- RTools contém uma série de pacotes e funções importantes na utilização do R;
>- É essencial para a construção de novos pacotes e para a execução de muitos dos pacotes utilizados no R;
>- Por exemplo, os pacotes que geraram esta apresentação (knitr e slidify) requerem o RTools para sua perfeita execução.

Pacotes ou Bibliotecas

Lista de Pacotes disponíveis >- Pacotes são extensões do R, contendo funções e objetos específicos para a realização de determinadas rotinas e análises;
>- Os pacotes são criados pelos usuários da comunidade a partir do seu código-fonte e publicados com a finalidade de disseminação do conhecimento;
>- Para instalar o pacote no R, basta descompactar o arquivo ZIP na pasta ‘library’ do diretório em que o R está instalado. >- os Pacotes também podem ser instalados via menu, através da aba “packages”, ou ainda, utilizando alguma interface GUI; >- Para carregar o pacote no R utilizaremos o comando require() ou o comando library().

Pacotes disponíveis

Exemplo: Pacote tseries

Título Original: Time series analysis and computational finance

Objetivo: Análise de séries temporais e análises de dados de finanças

Pacote tseries 

library(tseries)
require(tseries)

Instalação do RStudio

RStudio (http://rstudio.org “www.rstudio.org”)

O RStudio é uma GUI (Graphical User Interface) para o R. Com ele, é possivel interagir de forma mais ’amigável’com o console do R, por exemplo:
>- editando códigos em múltiplas linhas;
>- carregando pacotes e suas dependencias;
>- visualizando histórico de comandos e de saídas;
>- gerando relatórios em HTML e HTML5 (markdown) ;
>- publicando seus resultados em nuvens específicas e repositórios de projetos(Dropbox, GitHub, Rpubs).

Além disso, é possível utilizar o RStudio para trabalhos em rede, centralizando processamentos em um servidor.

Outras GUI bastante utilizadas na comunidade científica:

RStudio

RStudio (http://rstudio.org “www.rstudio.org”)

Interface do RStudio (GUI)

Instalando pacotes pelo RStudio

R-portable

Instalador o R-portable

Para utilizar o RStudio em um dispositivo móvel no Windows, apenas copie os dados do diretório RStudio (normalmente localizado na pasta de Arquivos de Programas). Para utilizá-lo, execute o arquivo ‘rstudio.exe’ na pasta bin e direcioná-lo para o arquivo de execução do console do R.

Perl

Linguagem Perl

Perl é uma linguagem de programação utilizada na construção de alguns pacotes do R. Neste cursp, utilizaremos alguns pacotes que tem o Perl como dependência.
Uma distribuição bastante comum de compilador desta linguagem é o Strawberry Perl

Exercícios

Instalação

  • Entre no site do R e encontre o local em que estão disponíveis os arquivos de instalação do R-Base e do RTools;
  • Procure a biblioteca nlme, baixe seu arquivo de instalação, e entenda para que esta biblioteca é utilizada;
  • Instale a biblioteca gdata através do RStudio. Acesse seu arquivo de ajuda (help(gdata)) e descubra informações básicas como quando foi sua última atualização, qual o autor e para que ela é utilizada;
  • Vá até a página do RStudio e encontre seu arquivo instalador;
  • Encontre e instale um compilador de Perl;
  • Instale, no seu pendrive, a licença portable do R;
  • Digite os dados na lousa, contendo as informações (nome, sexo, idade, unidade ) dos alunos deste curso, em algum dos seguintes tipos de arquivos: TXT, DAT, CSV, XLS ou XLSX.

Alguns comentários sobre o R

  • Case Sensitive: Help é diferente de help e de HELP
  • Possui arquivos dos tipos:
  • RData: Armazena os dados da workspace;
  • RHistory: Armazena o histórico de comandos utilizados durante o uso da sessão;
  • R: Script para execução (é executado através do comando source);
  • Rmd: Script em Markdown para a construção de arquivos HTML5;
  • RProj: Formato específico do RStudio para armazenamento de projetos. Neste formato, é possível manter organizados os arquivos acima.

Estrutura do Projeto no RStudio

help

  • Peça ajuda sempre que precisar!!!
help(solve)
?solve
help.search("linear model") 
??"linear model"

RStudio e R-bloggers possuem grandes comunidades de usuários que podem ajudar com seu problema ou dúvida.

Coursera.org

O Coursera é um site muito divulgado na comunidade científica com foco na divulgação e ensino de cursos online gratuitos. Há uma vasta lista de cursos de introdução e utilização do R, ou que utilizam o R com foco em análises estatísticas.

Alguns comandos básicos

Utilize o comando ‘<-’ ou ‘->’ para atribuir valores para as suas variáveis. Apesar de ser funcional, o caracter ‘=’ é utilizado para comparações e para definir parametros de funções internas. Por este motivo, evita-se o seu uso para atribuir valores aos objetos.

# Isto e um comentario

x<-NA    # Atribui NA a variavel x
y=1     # Atribui 1 a variavel y. Alternativamente, podemos fazer 1->y
y
## [1] 1
z<-w<-2  # Atribui 2 as variaveis z e w. Alternativamente, podemos fazer 2->w->z
ls()     # Lista os objetos existentes na workspace
## [1] "w" "x" "y" "z"
rm(x)    # Remove um determinado objeto da workspace
rm(list=ls()) # Remove todos os arquivos da Workspace

Work Directory

Work Directory é o caminho onde são armazenados os arquivos salvos do projeto em que estamos trabalhando.

getwd()  # Verifica o caminho padrao para a workspace (working directory)
[1] "C:/Users/Kim/Documents/Academicos/UFBA/IntroductionR"
caminho<-getwd() # Armazena o caminho padrao atual na variavel 'caminho'
caminho  # imprime o conteudo da variavel 'caminho' no output do console
[1] "C:/Users/Kim/Documents/Academicos/UFBA/IntroductionR"
setwd("C:/Windows") # define o caminho 'C:\Windows' como caminho padrao
getwd()  
[1] "C:/Windows"
setwd(caminho) #Define de volta o caminho padrao para o diretorio armazenado na variavel 'caminho'
getwd()
[1] "C:/Users/Kim/Documents/Academicos/UFBA/IntroductionR"

Vetores

Podemos armazenar mais de um valor para uma variável. Neste caso, a variável armazenará um vetor e não um único numero:

x<-c(5.1,4.3,2,0.5,9,2,10)
x
## [1]  5.1  4.3  2.0  0.5  9.0  2.0 10.0

Outras maneiras de se atribuir um valor ao objeto ‘x’:

assign("x", c(5.1,4.3,2,0.5,9,2,10))
c(5.1,4.3,2,0.5,9,2,10) -> x

Operações com vetores

É possivel construir vetores a partir de outros vetores já existentes:

y<-c(x,x,x)
y
##  [1]  5.1  4.3  2.0  0.5  9.0  2.0 10.0  5.1  4.3  2.0  0.5  9.0  2.0 10.0
## [15]  5.1  4.3  2.0  0.5  9.0  2.0 10.0

Equivalentemente, a função rep replica um determinado objeto um número específico de vezes:

t<-rep(x,times=3)
t
##  [1]  5.1  4.3  2.0  0.5  9.0  2.0 10.0  5.1  4.3  2.0  0.5  9.0  2.0 10.0
## [15]  5.1  4.3  2.0  0.5  9.0  2.0 10.0
s<-c(x,0,rep(NA,times=2),x)
s
##  [1]  5.1  4.3  2.0  0.5  9.0  2.0 10.0  0.0   NA   NA  5.1  4.3  2.0  0.5
## [15]  9.0  2.0 10.0

seq

seq(...)

## Default S3 method:
seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
    length.out = NULL, along.with = NULL, ...)

A função seq cria uma sequencia (de)crescente:

seq(-1, 1, by=.1) 
##  [1] -1.0 -0.9 -0.8 -0.7 -0.6 -0.5 -0.4 -0.3 -0.2 -0.1  0.0  0.1  0.2  0.3
## [15]  0.4  0.5  0.6  0.7  0.8  0.9  1.0
seq(5, -2, by=-.5) 
##  [1]  5.0  4.5  4.0  3.5  3.0  2.5  2.0  1.5  1.0  0.5  0.0 -0.5 -1.0 -1.5
## [15] -2.0

Operadores e funções matemáticas

Os operadores usuais +, -, *, / e ^ podem ser utilizados para operações aritméticas. Quando utilizadas em vetores, são aplicadas a cada elemento do vetor:

k<-4
z<-5
2*z + k + 1
## [1] 15
x^2
## [1]  26.01  18.49   4.00   0.25  81.00   4.00 100.00
t/3
##  [1] 1.70000 1.43333 0.66667 0.16667 3.00000 0.66667 3.33333 1.70000
##  [9] 1.43333 0.66667 0.16667 3.00000 0.66667 3.33333 1.70000 1.43333
## [17] 0.66667 0.16667 3.00000 0.66667 3.33333

As funções log, exp, sin, cos, tan, sqrt também estão disponíveis e funcionam de modo análogo aos operadores aritméticos acima, respeitando-se as restrições de cada uma.

Operadores de arredondamento

Função resultado
round(x, digits = 0) arredonda x com o número de casas decimais definido em ‘digits’
ceiling(x) arredonda x para cima
floor(x) arredonda x para baixo
trunc(x) retorna a parte inteira de x 
round(pi, digits = 2)
## [1] 3.14
ceiling(pi) 
## [1] 4
floor(exp(1))
## [1] 2
trunc(pi)
## [1] 3

Operadores Lógicos

Os operadores:

Operador| Descrição –| ‘<’ | Menor ‘<=’| Menor ou igual ‘>’ | Maior ‘>=’| Maior ou igual ‘==’| Igual ‘!=’| Diferente

são utilizados para se realizar comparações entre objetos. O resultado de uma comparação é um valor lógico TRUE (ou T, de forma abreviada) se a condição é verdadeira ou FALSE (F, abreviado) se a condição é falsa.

> 2>3
[1] FALSE
> 5<=9
[1] TRUE
> z== 5*8-10
[1] FALSE

Condições compostas são construídas através dos conectores: ‘&’ significando conjunção (e) e ‘|’ representando uma disjunção (ou).

2>3 & 5<=9
## [1] FALSE
teste1<- z== 5*8-10 | k!=z
teste1
## [1] TRUE

Obs: Eventualmente, quando um resultado é armazenado em uma variável e esta é interagida com objetos numéricos, ela assume valores 1 para ‘TRUE’ e 0 para ‘FALSE’.

Variáveis de caracteres

Variáveis de caracter são utilizadas em análise estatística, em geral, para se imprimir o label da observação, isto é, sua identificação/descrição ou para se representar um fator não numérico.

ex<-"Dados selecionados da região 21"
length(ex)
[1] 1

O comando paste é utilizado para concatenar variáveis caracter:

paste("Today is", date())
## [1] "Today is Mon Aug 31 10:57:45 2015"
Trat<-c("A", "B", "C")
ID<-c(1:12)
TratID<-paste(Trat,ID, sep="_")
TratID
##  [1] "A_1"  "B_2"  "C_3"  "A_4"  "B_5"  "C_6"  "A_7"  "B_8"  "C_9"  "A_10"
## [11] "B_11" "C_12"

Uso em variáveis de Fatores

Suponha, por exemplo, que desejamos construir uma variável Tratamento, contendo 3 níveis para, sexos masculino e feminino, com 5 observações em cada casela:

Trat<-rep(c(rep("A",times=5),rep("B",times=5),rep("C",times=5)),times=2)
Trat
##  [1] "A" "A" "A" "A" "A" "B" "B" "B" "B" "B" "C" "C" "C" "C" "C" "A" "A"
## [18] "A" "A" "A" "B" "B" "B" "B" "B" "C" "C" "C" "C" "C"
Sexo<-c(rep("M",times=15),rep("F",times=15))
Sexo
##  [1] "M" "M" "M" "M" "M" "M" "M" "M" "M" "M" "M" "M" "M" "M" "M" "F" "F"
## [18] "F" "F" "F" "F" "F" "F" "F" "F" "F" "F" "F" "F" "F"
#paste(Sexo,Trat,sep=":")

Futuramente, veremos como construir variaveis de fatores, que, numericamente, representarão estas informações em modelos estatisticos.

Identificando pontos

Outro uso bastante comum para variáveis do tipo caracter, é a identificação de elementos dos dados:

plot(mpg~wt, data=mtcars, col="darkblue", pch=20, main="Milhas/Galão x Peso")
identify(mtcars$mpg~mtcars$wt,n=3, labels=rownames(mtcars))

Índices

Índices são utilizados para restringir o conjunto de dados a ser selecionado. Podem ser utilizados na maioria dos objetos do R.

s
##  [1]  5.1  4.3  2.0  0.5  9.0  2.0 10.0  0.0   NA   NA  5.1  4.3  2.0  0.5
## [15]  9.0  2.0 10.0
s[2]
## [1] 4.3
s[c(1,5,10)]
## [1] 5.1 9.0  NA

É possivel definir condições compostas e restringir elementos:

s
##  [1]  5.1  4.3  2.0  0.5  9.0  2.0 10.0  0.0   NA   NA  5.1  4.3  2.0  0.5
## [15]  9.0  2.0 10.0
s_<-s[!is.na(s)]
s_
##  [1]  5.1  4.3  2.0  0.5  9.0  2.0 10.0  0.0  5.1  4.3  2.0  0.5  9.0  2.0
## [15] 10.0
s[!is.na(s) & s>5]
## [1]  5.1  9.0 10.0  5.1  9.0 10.0
s[-(1:5)]
##  [1]  2.0 10.0  0.0   NA   NA  5.1  4.3  2.0  0.5  9.0  2.0 10.0

Também é possivel definir referências baseadas em nomes:

cal <- c(50, 250,2,0, 2000,30)
names(cal) <- c("banana", "hotdog", "tictac","coca-zero", "feijoada","helmanns")
almoco <- cal[c("coca-zero","feijoada","tictac")]
almoco
## coca-zero  feijoada    tictac 
##         0      2000         2
sum(almoco) # Calcula o somatório da variável almoco
## [1] 2002

Exercícios

Vetores, Caracteres, operadores e índices

  • Construa um vetor de observações de 1 a 10;
  • Construa um vetor de observações de -10 a 5, com saltos de 0.2
  • o que faz a função ‘spectrum’?
  • Qual o resultado da seguinte execução:
z<-c(1,3,10)
z[1]^100-z[2]+5*z[3]->w
  • crie uma pasta chamada “introR” em um diretório de preferência (no seu disco removível, se possível) e modifique o caminho padrão da sua workspace para ele;
  • O comando abaixo cria um vetor x de 100 posições. crie um novo vetor com base nele que não contenha valores missing.
x<-numeric()
for(i in 1:100){
if (runif(1)>0.3) x[i]<-rpois(1,3)
else x[i]<- 0/0
}
  • Com o vetor resultante da etapa anterior, digamos, y, realize a seguinte transformação:

\[ z=\frac{y-3}{\sqrt{3}} \]

  • Construa um novo vetor apenas com os elementos de z que são maiores que 1,96. Calcule o percentual de elementos que este novo vetor representa de z;
  • Reproduza o exemplo sobre calorias das comidas com suas comidas favoritas. Assim como no exemplo, crie uma variavel ‘almoco’ e armazene nela o cardápio do seu almoço de hoje. Calcule o total de calorias ingeridas naquela refeição.

Classes e Objetos

Todos os objetos no R fazem parte de classes. Cada classe possui características especificas. Vimos, até agora, objetos das classes numeric(), character. Com efeito, é possivel modificar a classe de um objeto desde que ele possa assumir as características da nova classe.

# exemplo retirado do livro 'Introduction to R, Venables et. al., 2013'
z <- 0:9
digits <- as.character(z) # transforma o objeto z, numérico, em caracter
d <- as.integer(digits) # transforma o objeto 'digits', vetor de caracteres, em numérico
e <- numeric() # cria um vetor numerico vazio, com alocação dinâmica
e[3] <- 17
alpha<-rep(NA,times=10)
alpha <- alpha[2 * 1:5] # selecionando apenas os pares de 2 a 10
length(alpha) <- 3 # truncando em 3

class(digits)
## [1] "character"
class(z)
## [1] "integer"

Tamanho de um objeto

A função length nos mostra o tamanho do objeto, i.e., a quantidade de elementos que ele possui. O resultado depende da classe em que a função é aplicada.

length(digits)
[1] 10
x<-matrix(c(2,2,2,2),ncol=2)
length(x)
[1] 4
x<-list(a=c(1,2,3,4,5), b=c(5,6,6,7,7) )
length(x)
[1] 2
caminho<-getwd()
length(caminho)
[1] 1

Outras classes importantes

Vetores

Vetores são objetos que podem armazenar uma quantidade determinada de elementos do mesmo tipo, desde que eles sejam de algumas classes específicas. São elas: numeric, character,complex, logical.
Algumas operações com vetores:

x<-c(1,2,2,3,4,5,6)
y<-c(1,-1,0,2,1,1,6)
2*x
## [1]  2  4  4  6  8 10 12
2*x+1
## [1]  3  5  5  7  9 11 13
log(x)
## [1] 0.00000 0.69315 0.69315 1.09861 1.38629 1.60944 1.79176
c(1,2,3)+c(1,2,3,4,5,6)
[1] 2 4 6 5 7 9

Matrizes

Matrizes são vetores bidimensionais. São casos particulares de array (assim como os vetores). Portanto, nas matrizes, também são armazenados elementos de um mesmo tipo ou classe, desde que sejam do tipo numeric, character,complex ou logical.

#matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE,
#       dimnames = NULL)
#as.matrix(x, ...)
#is.matrix(x)
#dim(x)

matrix(c(1,2,3,4,5,6,7,8,9),nrow=3)
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
matrix(c(1,2,3,4,5,6,7,8,9),nrow=3, byrow=T)
##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6
## [3,]    7    8    9
x<-matrix(c(10,5,4,3,2,-1),ncol=3,byrow=T)
dim(x) # Retorna um vetor de tamanho 2 com o número de linhas e colunas de x, respectivamente.
## [1] 2 3
> as.matrix(c(1,2,3,4))
     [,1]
[1,]    1
[2,]    2
[3,]    3
[4,]    4
> is.matrix(mtcars)
[1] FALSE
> !is.matrix(caminho)
[1] TRUE

Elementos da matriz

Cada elemento da matriz (assim como em um vetor) possui uma coordenada. a Primeira coordenada representa a linha, enquanto a segunda representa a coluna. Assim, para acessarmos a linha 2, coluna 1 da matriz x abaixo, fazemos:

     [,1] [,2] [,3]
[1,]   10    5    4
[2,]    3    2   -1
x[1,2]
## [1] 5

Podemos fazer referências a linhas ou colunas inteiras das matrizes apenas ocultando a coordenada a qual se deseja generalizar:

x[1,]
## [1] 10  5  4
x[,2]
## [1] 5 2

Operações matriciais

Considere a matriz X abaixo: \[ x= \left( \begin{array}{ccc} 10 & 5 & 4 \\ 3 & 2 & -1 \\ 0 & 0 & 1 \end{array} \right) \] ### Transposição:

x<-matrix(c(10,5,4,3,2,-1,0,0,1),ncol=3,byrow=T)
t(x)
     [,1] [,2] [,3]
[1,]   10    3    0
[2,]    5    2    0
[3,]    4   -1    1

Inversão:

solve(x)
     [,1] [,2] [,3]
[1,]  0.4   -1 -2.6
[2,] -0.6    2  4.4
[3,]  0.0    0  1.0

Considere as matrizes X e Y abaixo: \[ x= \left( \begin{array}{ccc} 10 & 5 & 4 \\ 3 & 2 & -1 \\ 0 & 0 & 1 \end{array} \right) , y= \left( \begin{array}{ccc} 0 & 2 & 0 \\ 7 & 2 & 3 \\ 1 & 1 & 1 \end{array} \right) \]

x<-matrix(c(10,5,4,3,2,-1,0,0,1),ncol=3,byrow=T)
y<-matrix(c(0,2,0,7,2,3,1,1,1),ncol=3,byrow=T)

#O produto matricial entre x e y é:
x%*%y
     [,1] [,2] [,3]
[1,]   39   34   19
[2,]   13    9    5
[3,]    1    1    1

Determinantes:

> det(x)
[1] 5
> det(y)
[1] -8

Arrays

São a classe generalizada das matrizes e vetores. Possuem até 3 dimensões e podem ser numeric, character,complex ou logical. Para acessar um elemento de um array, caso ele tenha 3 dimensões, a primeira coordenada representa a linha, a segunda coordenada representa a coluna e a terceira, a página.

array(data = NA, dim = length(data), dimnames = NULL)
as.array(x, ...)
is.array(x)
z<-rnorm(24,0,1) # um vetor pode ser transformado em array, desde que seu numero de elementos seja coerente com as dimensões do array desejado.
dim(z) <- c(4,3,2)
z
, , 1                                         , , 2                                      
         [,1]     [,2]     [,3]                        [,1]     [,2]     [,3]
[1,]  2.27348  2.91914 -0.32439               [1,]  0.31916 0.029518 -1.09777
[2,]  1.17350  0.67742 -0.27470               [2,] -1.07754 0.594274  0.71118
[3,]  0.28771 -0.68432 -0.93350               [3,] -3.23315 0.059135  0.71889
[4,] -0.65977  0.18649  0.11685               [4,] -0.25487 0.413399  0.25165
z[3,2,1]
[1] -0.68432

Marginais

Assim como no caso matricial, é possível acessar as marginais de cada dimensão ocultando os índices das demais:

> z[1,,]
         [,1]      [,2]
[1,]  2.27348  0.319160
[2,]  2.91914  0.029518
[3,] -0.32439 -1.097772
> z[,1,]
         [,1]     [,2]
[1,]  2.27348  0.31916
[2,]  1.17350 -1.07754
[3,]  0.28771 -3.23315
[4,] -0.65977 -0.25487
> z[,,1]
         [,1]     [,2]     [,3]
[1,]  2.27348  2.91914 -0.32439
[2,]  1.17350  0.67742 -0.27470
[3,]  0.28771 -0.68432 -0.93350
[4,] -0.65977  0.18649  0.11685

Regras Aritméticas em Arrays

  • As Expressões são executadas da esquerda para a direita, respeitando-se a hierarquia de parênteses;
  • Se houver um vetor menor durante uma operação, os valores dele serão repetidos no final, até que ele alcançe o tamanho do vetor maior;
  • Exceto pelo caso dos vetores, as dimensões dos arrays devem ser compatíveis durante a operação;
  • Caso haja um array e um vetor em uma operação, a estrutura do array prevalecerá sobre a do vetor.

Exercícios

Classes, matrizes, arrays

  • Qual a classe da função ‘spectrum’?
    Considere a matriz:
    \[ X=\left( \begin{array}{ccc} 10 & 2 & -3 \\ 4 & 15 & 6 \\ -7 & 8 & 0 \end{array} \right) \]
  • Calcule seu determinante, sua transposta e sua inversa.

  • Considere agora a matriz
    \[ Y= \left( \begin{array}{ccc} 0 & 2 \\ 7 & 2 \\ 1 & 1 \end{array} \right) \]

  • Calcule o produto Matricial X * Y;

  • Some a coluna 1 com a coluna 2 da matriz resultante do item anterior e armazene seu resultado em uma variável chamada Scol.

  • Subtraia a linha 1 da matriz resultante do produto de X * Y da linha 2 da matriz Y e armazene seu valor na variável Srow.

Funções rbind() e cbind()

Estas funções organizam objetos no formato de linhas (rbind) ou colunas (cbind)

Exemplo:

x <- 1:3
y <- 10:12
z<-cbind(x, y)
z
##      x  y
## [1,] 1 10
## [2,] 2 11
## [3,] 3 12
rbind(z[,1],z[,2])
##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]   10   11   12

Funções de loop

As funções de loop são aquelas que realizam uma determinada operação repetidamente para um grupo de observações, de acordo com um critério pré-determinado. As principais são:

  • apply: Aplica uma função às marginais de uma matrix ou array;
  • tapply: aplica uma função a subgrupos de um vetor;
  • lapply e sapply: aplica uma função a elementos de uma lista. lapply sempre devolverá uma lista, enquanto sapply simplificará o resultado.
# apply(X, MARGIN, FUN, ...)
# X é o objeto ao qual 'FUN'será aplicado. 
# MARGIN será igual a 1 para FUN aplicado às linhas e igual 
  # a 2 para FUN aplicado às colunas 
x <- cbind(x1 = 3, x2 = c(4:1, 2:5))
row.sums <- apply(x, 1, sum)
col.sums <- apply(x, 2, sum)

row.sums
[1] 7 6 5 4 5 6 7 8
col.sums
x1 x2 
24 24

Listas

Uma lista é um vetor que pode aceitar a maioria das classes de objetos em seu conteúdo. Por exemplo, podemos ter uma lista x, com um número na primeira posição, um caracter na segunda, e uma matriz na terceira:

a<-123456
b<-"João"
c<-matrix(c(6,7,8.5,6,4,5),byrow=T,nrow=3,
  dimnames=list(disciplina=c("Cálculo","Estat I","AlgLin"),Notas=c("P1","P2")))
x<-list(Matricula=a,Nome=b,Notas=c)
x
## $Matricula
## [1] 123456
## 
## $Nome
## [1] "João"
## 
## $Notas
##           Notas
## disciplina  P1 P2
##    Cálculo 6.0  7
##    Estat I 8.5  6
##    AlgLin  4.0  5

Elementos da Lista

É possível acessar cada elemento da lista através do seu nome ou de sua posição:

x$Matricula
## [1] 123456
x[[2]]
## [1] "João"
x$Notas
##           Notas
## disciplina  P1 P2
##    Cálculo 6.0  7
##    Estat I 8.5  6
##    AlgLin  4.0  5

lapply e sapply

#lapply(X, FUN, ...)
#sapply(X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE)
x <- list(a = 1:10, beta = exp(-3:3), logic = c(TRUE,FALSE,FALSE,TRUE))
x
## $a
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## $beta
## [1]  0.049787  0.135335  0.367879  1.000000  2.718282  7.389056 20.085537
## 
## $logic
## [1]  TRUE FALSE FALSE  TRUE
sapply(x,mean)
##      a   beta  logic 
## 5.5000 4.5351 0.5000
lapply(x,mean)
$a
[1] 5.5
$beta
[1] 4.5351
$logic
[1] 0.5

lapply(x, quantile, probs = 1:3/4) # Podemos especificar comandos para FUN após sua declaração
$a
 25%  50%  75% 
3.25 5.50 7.75 
$beta
    25%     50%     75% 
0.25161 1.00000 5.05367 
$logic
25% 50% 75% 
0.0 0.5 1.0 

sapply(x, quantile,c(0.25,0.75))
         a      beta logic
25%   3.25  0.251607   0.0
75%   7.75  5.053669   1.0

Fatores

Fatores são variáveis muito utilizadas em análises estatísticas. São, essencialmente, como listas, exceto que possuem elementos específicos.

factor(x = character(), levels, labels = levels, ordered = is.ordered(x))
ordered(x, ...)

is.factor(x)
is.ordered(x)

as.factor(x)
as.ordered(x)
factor(c(4,3,2,2,2,2,1,1,1,2,2,2,3,3,4,4,4,4,4,4))
##  [1] 4 3 2 2 2 2 1 1 1 2 2 2 3 3 4 4 4 4 4 4
## Levels: 1 2 3 4
ordered(c(4,3,2,2,2,2,1,1,1,2,2,2,3,3,4,4,4,4,4,4))
##  [1] 4 3 2 2 2 2 1 1 1 2 2 2 3 3 4 4 4 4 4 4
## Levels: 1 < 2 < 3 < 4

Podemos construir fatores a partir de variáveis caracter:

sex<-c(rep(1,times=15),rep(2,times=15))
tr<-rep(c(rep(1,times=5),rep(2,times=5),rep(3,times=5)),times=2)
f_sex<-factor(sex)
f_trat<-factor(tr)
f_sex
##  [1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
## Levels: 1 2
f_trat
##  [1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3
## Levels: 1 2 3

Note que, apesar de existir uma ordem sintática entre os elementos de alguns fatores (A,B,C), por exemplo, se não declararmos esta ordem com (ordered=TRUE), ela não será considerada, isto é, o fator será encarado como uma variável nominal ao invés de ordinal

Exemplo de utilização de fatores

y<-rnorm(mean=0,sd=1,n=30)
summary(aov(y~tr+sex))
##             Df Sum Sq Mean Sq F value Pr(>F)
## tr           1   0.28   0.279    0.32   0.57
## sex          1   0.05   0.050    0.06   0.81
## Residuals   27  23.32   0.864
summary(aov(y~f_sex+f_trat))
##             Df Sum Sq Mean Sq F value Pr(>F)
## f_sex        1   0.05   0.050    0.06   0.81
## f_trat       2   0.28   0.141    0.16   0.86
## Residuals   26  23.31   0.897
  • Não utilizar a variável categórica da forma correta poderá, em alguns casos, ocasionar numa má interpretação dos dados e na tomada de decisão baseada em um ajuste não válido;
  • É importante conhecer profundamente os dados que entrarão no modelo, para garantir que eles serão declarados da forma correta.

Nota sobre Classes

O R é uma linguagem orientada a objetos. Assim, é possível acessar as propriedades dos objetos de acordo com as características específicas de sua classe.

Exemplo:

fit1<-aov(y~f_sex+f_trat)
class(fit1)
[1] "aov" "lm" 
names(fit1)
 [1] "coefficients"  "residuals"     "effects"       "rank"          "fitted.values" "assign"       
 [7] "qr"            "df.residual"   "contrasts"     "xlevels"       "call"          "terms"    "model"               
attributes(fit1)
$names
 [1] "coefficients"  "residuals"     "effects"       "rank"          "fitted.values" "assign"       
 [7] "qr"            "df.residual"   "contrasts"     "xlevels"       "call"          "terms"    "model"               

$class
[1] "aov" "lm" 
fit1$coefficients
(Intercept)      f_sexB      f_sexC     f_tratM 
   -0.38265     0.24616     0.11951     0.79872

Exemplo

par(mfrow=c(2,2))
plot(fit1)

Exercícios

Listas, fatores, cbind rbind, applies

  • Considere os números aleatórios gerados pelo seguinte comando:
x<-numeric()
for (i in 1:7){
x[i]<-round(runif(1,min=1,max=30))
}
  • A partir desta amostra, construa 3 vetores com os dados dos participantes do curso que foram selecionados:
  1. Nome; b. Sexo; c. Idade;
  • Construa uma variável chamada f_Sexo contendo o fator da variável ‘sexo’ dos selecionados;
  • Utilizando a função cbind, construa uma matriz que consindera o o nome e o sexo dos participantes;
  • Nomeie as colunas da matriz como ‘L_Nome’ e ‘L_sexo’;
  • Construa uma lista contendo 3 argumentos: a matriz da questão anterior, a variável idade e o fator da variável ‘sexo’;
  • Considere agora o banco de dados Orange. Nele, temos os dados de idade e circunfrencia de 5 laranjeiras. Construa uma lista contendo os dados deste data frame e utilize a função lapply para calcular a idade máxima para cada árvore.
  • Utilizando os mesmos dados da lista Orange, criada no exercício anterior, calcule a média de circunferências para cada árvore utilizando, desta vez, a função sapply.

Data Frames

Data Frames são como matrizes, mas que possuem a faciclidade de aceitar colunas de diferentes classes. São a forma mais comum de utilização de dados importados, assim domo para análise e modelagem de dados.

data.frame(..., row.names = NULL, check.rows = FALSE,
           check.names = TRUE, stringsAsFactors = default.stringsAsFactors())
  • row.names: especificação da coluna que deve ser utilizada como nome das linhas
  • check.rows: valor lógico - verificar consistencia das linhas?
  • check.names: valor lógico - verificar consistencia dos nomes das variáveis em busca de duplicidade?
  • stringsAsFactors: valor lógico - considerar variáveis caracter como fatores automaticamente?

Exemplo

y<-rnorm(mean=0,sd=1,n=30)
sex<-c(rep(1,times=15),rep(2,times=15))
tr<-rep(c(rep(1,times=5),rep(2,times=5),rep(3,times=5)),times=2)
f_sex<-factor(sex)
f_trat<-factor(tr)
f_sex
##  [1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
## Levels: 1 2
f_trat
##  [1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3
## Levels: 1 2 3
dados<-data.frame(1:30,sex,tr,f_sex, f_trat,y,exp(y))

Modificando atributos

É possível modificar atributos específicos do data.frame

attributes(dados)
## $names
## [1] "X1.30"  "sex"    "tr"     "f_sex"  "f_trat" "y"      "exp.y."
## 
## $row.names
##  [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] 24 25 26 27 28 29 30
## 
## $class
## [1] "data.frame"

Funções head e tail

Retornam as ‘n’ primeiras(últimas) linhas do banco de dados.

head(dados)
##   X1.30 sex tr f_sex f_trat        y  exp.y.
## 1     1   1  1     1      1  1.10230 3.01108
## 2     2   1  1     1      1 -0.47559 0.62152
## 3     3   1  1     1      1 -0.70944 0.49192
## 4     4   1  1     1      1 -0.50126 0.60577
## 5     5   1  1     1      1 -1.62909 0.19611
## 6     6   1  2     1      2 -1.16762 0.31111
tail(dados, n=3)
##    X1.30 sex tr f_sex f_trat        y  exp.y.
## 28    28   2  3     2      3 -0.77335 0.46146
## 29    29   2  3     2      3  1.60591 4.98239
## 30    30   2  3     2      3 -1.15781 0.31417

Aplicações de data.frame

attach(dados)
fit1<-aov(resp~f_sex+f_trat, data=dados)
summary(fit1)

Sem declarar o banco de dados com a opção ‘data’, seria necessário ajustar o modelo da seguinte forma:

fit1<-aov(dados$resp~dados$f_sex + dados$f_trat)

É possivel, ainda, anexar as variáveis do data.frame ao projeto, evitando, assim, a necessidade de se declarar o nome do banco de dados na sintaxe ‘dados$variavel’

attach(dados) # Utilize este comando para anexar o banco de dados 'dados'
## The following objects are masked _by_ .GlobalEnv:
## 
##     f_sex, f_trat, sex, tr, y
detach(dados) # DESanexa 'dados'

Nota: Variáveis que já estavam na workspace e que possuem o mesmo nome de variáveis do banco de dados anexado, sejam reais ou anexadas de outros data frames serão ocultadas.

Junção de bancos de dados: merge

a função merge é muito útil quando precisamos adicionar variáveis ao banco de dados em que estamos trabalhando, garantindo que elas serão adicionadas ao ‘sujeito’ correto.
O objetivo desta função é unir 2 bancos de dados a partir de uma coluna em comum, ou a partir dos nomes das linhas (row.names)

## Default S3 method:
merge(x, y, ...)

merge(x, y, by = intersect(names(x), names(y)), by.x = by, by.y = by, all = FALSE, all.x = all, all.y = all, 
sort = TRUE, suffixes = c(".x",".y"), incomparables = NULL, ...)

Para termos o banco de dados unificado, considerando APENAS os casos que aparecem em ambos os bancos de dados(inner join), basta declararmos:

BancoFinal<-merge(banco1,banco2)

Já se desejamos a união de todos os casos, i.e, dos que aparecem em um ou outro banco de dados, devemos declarar:

BancoFinal<-merge(banco1,banco2, all=TRUE)

O merge identificará, automaticamente, as colunas que são comuns (i.e., possuem o mesmo nome) em ambos os bancos de dados e as utilizará como chaves para unificá-los.

Exercícios

Data frames

rnorm(n=N, mean=mu, sd=sigma)

Exercícios

Importação de dados

Arquivos de texto e similares

O R possui um grande poder de análise de dados. Para isso, no entanto, é necessário inserir os dados em sua workspace. Isto é possível através da importação dos dados em formato de arquivos de texto (TXT), tabulares ou delimitados(DAT,TAB,CSV), ou mesmo planilhas (XLS,XLSX). Vejamos inicialmente os dois primeiros casos. Para isso, duas funções são muito utilizadas: read.table e read.csv.

read.table {utils}

read.table(file, header = FALSE, sep = "", quote = "\"'",
           dec = ".", row.names, col.names,
           as.is = !stringsAsFactors,
           na.strings = "NA", colClasses = NA, nrows = -1,
           skip = 0, check.names = TRUE, fill = !blank.lines.skip,
           strip.white = FALSE, blank.lines.skip = TRUE,
           comment.char = "#",
           allowEscapes = FALSE, flush = FALSE,
           stringsAsFactors = default.stringsAsFactors(),
           fileEncoding = "", encoding = "unknown", text)
read.csv(file, header = TRUE, sep = ",", quote="\"", dec=".",
         fill = TRUE, comment.char="", ...)
read.delim(file, header = TRUE, sep = "\t", quote="\"", dec=".",
           fill = TRUE, comment.char="", ...)

Importação de dados

  • file: Caminho e nome do arquivo que está sendo lido;
  • header: Valor Lógico. Se ‘TRUE’ então o R entenderá que existe cabeçalho nos dados lidos
  • sep: Caracter utilizado para separação de colunas (o valor padrão é ‘,’);
  • dec: Caracter utilizado na separação de inteiro e decimal (o valor padrão é ‘.’);
  • quote: Caracter utilizado para descriminar uma variável Caracter. o Padrão é ‘"’;
  • Dados faltantes (missing) são gravados como ‘NA’.

Importação de dados em Planilhas

Vejamos agora como importar dados a partir de um arquivo do excel. Para isso, é necessário ter um compilador Perl instalado.
A biblioteca gdata possui funções específicas para a leitura de planilhas em interfaces gráficas, como é o caso das planilhas do Microsoft Excel. Para executá-la, é preciso ter um compilador Perl instalado no computador.

read.xls {gdata}
read.xls(xls, sheet=1, verbose=FALSE, pattern, na.strings=c("NA","#DIV/0!"),
         ..., method=c("csv","tsv","tab"), perl="perl")
  1. Istale a biblioteca gdata e suas dependências;
  2. Instale o Strawberry Perl;
  3. Carregue a biblioteca gdata;
  4. Para realizar a leitura dos dados, execute a função read.xls. Eventualmente, será necessário descriminar o caminho em que se encontra o arquivo executável do compilador Perl.

Biblioteca gdata

library(gdata)
gdata: read.xls support for 'XLS' (Excel 97-2004) files ENABLED.

gdata: read.xls support for 'XLSX' (Excel 2007+) files ENABLED.

Attaching package: ‘gdata’

The following object(s) are masked from ‘package:stats’:

    nobs

The following object(s) are masked from ‘package:utils’:

    object.size

Warning message:
package ‘gdata’ was built under R version 2.15.3

Exercícios

Importação de dados

  • Considere os dados digitados no exercício 1, contendo as informações dos aluno deste curso.
  • Vamos importar estes dados para o R.
dados<-read.table("dados_cursoR.txt", sep="," head=T)
dados<-read.csv("dados_cursoR.csv", sep=";" head=T, skip=2)
dados<-read.xls("Exemplo_import.xlsx", sheet=1, skip=2)

Medidas descritivas

Considere uma amostra aleatória de uma população com N observações. com n observações de uma variável X: \(\{X_1, X_2,...,X_n\}\).
A média amostral, \(\bar{X}\) é estimador não viesado para \(\mu\), média populacional e é definida por: \[ \bar{X}=\sum_{i=1}^{n} X_i \] O desvio padrão amostral, \(S\) é um estimador não viesado para o desvio padrão populacional, \(\sigma=\sqrt{\sum_{i=1}^N \frac{(x_i-\mu)^2}{N}}\) e é definido por:

\[ S= \sqrt{\left( \sum_{i=1}^n \frac{(X_i-\bar{X})^2}{n-1}\right)} \]

A O Quartil 1 (\(Q_1\)), Mediana(\(Md\)) e o Quartil 3 (\(Q_3\)) são os valores que têm, menores que eles, respectivamente, 25%, 50% e 75% dos dados da variável considerada.

A moda é definida (informalmente) como o valor mais comum dentre os observados para a variável considerada.

Algumas funções comuns para o cálculo de medidas descritivas são:

x<-rnorm(30)
mean(x) # Calcula a média de x
[1] -0.23442
var(x) # Calcula a variância de x
[1] 1.3346
quantile(x, probs=c(0.25,0.5,0.75)) # Calcula os quantis de x, para as probabilidades dadas em 'probs'
     25%      50%      75% 
-1.00022 -0.41723  0.31696 
var(x, y = NULL, na.rm = FALSE, use)
cov(x, y = NULL, use = "everything", method = c("pearson", "kendall", "spearman")) 
cor(x, y = NULL, use = "everything", method = c("pearson", "kendall", "spearman"))
quantile(x, probs = seq(0, 1, 0.25), na.rm = FALSE, names = TRUE, type = 7, ...)

Summary

Uma outra função muito comum no cálculo de medidas descritivas é a função summary() Ela nos dá uma série de medidas descritivas de uma só vez para o conjunto de dados Seu resultado é, porém, dependente da classe do objeto:

summary(x)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
 -2.080  -1.000  -0.417  -0.234   0.317   2.580 
summary(Sexo)
   Length     Class      Mode 
       30 character character 
summary(factor(Trat))
 A  B  C 
10 10 10 
 ```

summary(aov(y~tr+sex)) Df Sum Sq Mean Sq F value Pr(>F) tr 1 0.9 0.950 0.73 0.40 sex 1 0.1 0.112 0.09 0.77 Residuals 27 35.3 1.306



## Medidas descritivas por grupo

A função *tapply* aplica uma função específica para grupos dentro de um vetor.

Trat<-rep(c(rep(“A”,times=5),rep(“B”,times=5),rep(“C”,times=5)),times=2) Trat [1] “A” “A” “A” “A” “A” “B” “B” “B” “B” “B” “C” “C” “C” “C” “C” “A” “A” “A” “A” “A” “B” “B” “B” “B” “B” [26] “C” “C” “C” “C” “C” Sexo<-c(rep(“M”,times=15),rep(“F”,times=15)) Sexo [1] “M” “M” “M” “M” “M” “M” “M” “M” “M” “M” “M” “M” “M” “M” “M” “F” “F” “F” “F” “F” “F” “F” “F” “F” “F” [26] “F” “F” “F” “F” “F”

x<-rnorm(30) tapply(x,Trat,mean) A B C 0.10071 0.25269 0.27933 tapply(x,Sexo,mean) F M -0.060551 0.482365 ```

Exercícios

Tópico Adicional

Estruturas de controle

  • Permitem que você controle a execução de um program dependendo da estrutura e condição dos dados. Funções comuns são:
  • if, else: Testa uma condição
  • for: executa uma rotina um número específico de vezes
  • while: executa uma rotina até que uma condição seja satisfeita
  • repeat: repete uma tarefa
  • break: interrompe a execução de um loop
  • next: pula uma execução para a próxima iteração
  • return: termina uma função

Estas estruturas de controle são bastante utilizadas durante a construção de scripts e funções.

Bibliografia

Introdução ao uso do software R

Obrigado!

samejimal@ufba.br

UFBA | Campus Ondina
Instituto de Matemática | Departamento de Estatistica
Sala 260