Introdução ao R

Introdução ao R
Programa de Pós-Graduação em Modelagem Computacional da UFJF
Leonardo Goliatt
Departamento de Mecânica Aplicada e Computacional
UFJF
leonardo.goliatt@ufjf.edu.br
v. 13.07
Leonardo Goliatt (MAC/UFJF) Introdução ao R v. 13.07 1 / 132

Programa
1 Interface R
2 Sintaxe R
3 Pacotes do R
4 Gráﬁcos
5 Interface com outras linguagens
6 Análise de casos

Conteúdo
1 Interface R
2 Sintaxe R
Informações Preliminares
Sintaxe do R
Símbolos
Vetores
Instruções de Controle
Funções
Operadores
Estruturas de dados
Objetos e Classes
3 Pacotes do R
Pacotes de dados e funções
4 Gráﬁcos
Gráﬁcos no R
R e outras Linguagens de Programação
Combinando R com C e Fortran
6 Análise de casos
Ajuste de Curvas
Vazão da Represa de Furnas
Análise de Adubação da Soja
Usando o ANOVA
Análise Granulométrica do Solo
Computação Simbólica no R

Interface R
Conteúdo
1 Interface R

Interface R
O R e sua filosofia de trabalho
R pode ser definido como um ambiente de programação com
ferramentas para
manipulação de dados
cálculos
e apresentação gráfica
Como ambiente, entende-se um sistema coerente e totalmente planejado
O R não é um software do tipo aplicativo
a preocupação não é com amigabilidade, mas com
flexibilidade
capacidade de manipulação de dados
realização de análises

Interface R
Sobre o R
R é free
R é open-source
Qualquer pessoa tem liberdade para usar e modﬁcar
Quem usa R?
Google
Pﬁzer
Merck
Bank of America
R possui mas de 1600 pacotes, entre eles:
BiodiversityR (ecologia e meio ambiente)
Emu (análise da fala)
GenABEL (genoma humano)
...
Deu no New York Times: http://nyti.ms/Wl12E4

Interface R
O que é o R?
R é um programa para análise estatística e representação gráfica.
Funções e resultados de análises são armazenados como objetos,
permitindo:
fácil modificação de funções
construção de modelos
R é flexível e personalizável
Ideal para análise exploratória de dados
Por outro lado,
R é pouco eficiente para manipular grandes conjuntos de dados
Pouco eficiente na execução de grandes laços (loops) quando
comparado com outras linguagens com C, Fortran e C++
Alternativas:
Pacotes de acesso a banco de dados (RMySQL)
Uso de bibliotecas (escritas em C e Fortran) compiladas (R CMD SHLIB)

Interface R
Objetivos
Apresentar o ambiente de programação R contexto de simulação e
análise de dados
Fornecer exemplos claros e simples da funcionalidade e ﬂexibilidade do
R
Estimular o aproveitamento do Software Livre, evitando as restrições de
softwares comerciais e o uso não autorizado destes.

Interface R
Página Oﬁcial do R
Referência básica para usuários de R: http://www.r-project.org/
inclui programas para download
listas de discussão
documentação e ajuda
Livros:
R in a Nutshell
The Art of R Programming
Onde baixar (Linux, Windows, Mac):
http://cran.fiocruz.br/
Ubuntu (Linux): sudo apt-get install r-base
Onde ober ajuda:
R mailing list
Stack Overﬂow www.stackoverflow.com

Interface R
Como usar o R?
Diretamente do terminal ou console (tela preta)
Linux: konsole, xterm, gnome-terminal
Usando interfaces gráﬁcas
Rstudio: http://rstudio.org/
Rkward: http://rkward.sourceforge.net/
Rcmdr: http://www.rcommander.com/
StatET: http://www.walware.de/goto/statet/
Outras interfaces: http://www.sciviews.org/_rgui/

Interface R
Invocando o R na linha de comando
Se estiver corretamente instalado, abra um terminal e digite R.
O símbolo “>” indica que o R está esperando um comando

Interface R
1> R version 2.13.1 (2011-07-08)
2> Copyright (C) 2011 The R Foundation for Statistical Computing
3> ISBN 3-900051-07-0
4> Platform: x86_64-pc-linux-gnu (64-bit)
5>
6> R é um software livre e vem sem GARANTIA ALGUMA.
7> Você pode redistribuí-lo sob certas circunstâncias.
8> Digite 'license()' ou 'licence()' para detalhes de distribuição.
9>
10> R é um projeto colaborativo com muitos contribuidores.
11> Digite 'contributors()' para obter mais informações e
12> 'citation()' para saber como citar o R em publicações.
13>
14> Digite 'demo()' para demonstrações, 'help()' para o sistema
15> de ajuda, ou 'help.start()' a ajuda em HTML no seu navegador.
16> Digite 'q()' para sair do R.

Interface R
Ajuda sobre algo sobre o que se deseja
1> apropos('help') # busca por comandos similares
2> [1] "help" "help.request" "help.search" "help.start"
3> apropos('mean')
4> [1] "colMeans" "kmeans" "mean"
5> [5] "mean.Date" "mean.default" "mean.difftime"
6> [9] "mean.POSIXlt" "rowMeans" "weighted.mean"
Quando só se sabe o que procurar
1> help('mean') # help em modo texto
2> ?mean # o mesmo que help('mean')
3> help('mean',help_type='html') # help em modo html

Interface R
Para sair do programa, digite
1> quit()
2> Save workspace image? [y/n/c]: n

Sintaxe R
Conteúdo
2 Sintaxe R

Sintaxe R Informações Preliminares
Tipos de dados:
character (“Leonardo”)
numeric (1.)
integer (3)
logical (TRUE or FALSE)
vector (tipos homogêneos)
list (parecidos vectors, mas heterogêneos)
matrix
dataframe (a maior parte dos dados estarão em dataframes)
factors → Variáveis qualitativas que podem ser incluídas em modelos
as.factor
missing values (NA)
···

Funcionamento básico:
entre com uma expressão no console e digite <enter>
a expressão é avaliada e o resultado impresso na tela
Note que [1] sempre acompanha qualquer resultado
1 # Isto éum comentário
2 1 + 2 + 3
3 [1] 6
4 1 + 2 * 3 # outro comentário
5 [1] 7
6 (1 + 2) * 3 # ...
7 [1] 9

R é case-sensitive: então A e a são símbolos diferentes e se referem a
diferentes variáveis
Comandos diferentes são separados por ponto e vírgula “;”
O conjunto de símbolos dependem do idioma e do sistema operacional
onde se roda o R (tecnicamente, o locale em uso)
Todos os símbolos alfanuméricos são permitidos, incluindo “.” e “_”
Comentários começam com “#”
1 #
2 A=2; a=banana
3 print(A)
4 [1] 2
5 print(a)
6 [1] banana
7 #
8 .num=45; print(.num+1)
9 [1] 46

Como a maioria das linguagens de programação, R permite atribuir
valores a variáveis
A operação de atribuição tem a sintaxe objeto recebe valor
Há dois operadores que atribuem valores a um objeto dessa maneira
sinal de menor seguido de hífen: -
sinal de igual: =
1 # Os dois operadores de atribuição - e = são equivalentes
2 a - 2
3 f - b = 5*a
4 print(a)
5 [1] 2
6 print(b)
7 [1] 10
8 print(f)
9 [1] 10

Uma forma de atribuição menos usada é valor atribuído a objeto
1 # Outra forma, menos usual é
2 salsa -d -e
3 print(d)
4 [1] salsa
5 print(e)
6 [1] salsa
7
8 # Para saber mais
9 ?=
10 ?-

Em R, todo resultado é interpretado como um vetor
O “[1]” indica o índice do vetor
No caso abaixo, os números entre colchetes indicam o índice do primeiro
elemento de cada linha
1 # sequência de inteiros no intervalo [1,50]
2 1:50
3 [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
4 [23] 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
5 [42] 42 43 44 45 46 47 48 49 50

1 # Usando o R como calculadora
2 4+6
3 [1] 10
4 3/2+1
5 [1] 2.6
6 4*3**3 # potências são indicadas por ** ou ^
7 [1] 108
8 # Outras funções
9 sqrt(2)
10 [1] 1.414214
11 sin(pi) # os ângulos são interpretados em radianos
12 [1] 1.224606e-16 # zero!
13 sqrt(sin(45*pi/180))
14 [1] 0.8408964
15 log(1) # logaritmo neperiano (base e)
16 [1] 0
17 log(64,4) # base 4
18 [1] 3

Uso de scripts
Exemplo um script: exemplo.R
1 # exemplo.R
2 a-3
3 b-6
4 print(a+b)
Executando o script de dentro do R
1 source('exemplo.R')
Chamando o script via terminal
1 R -f exemplo.R

Sintaxe R Sintaxe do R
Sintaxe do R
Vamos começar com uma visão geral do R
È possível escrever quase qualquer expressão em R como uma função
Porém, isso pode se tornar confuso e o R permite algumas sintaxes
especiais
A sintaxe básica envolve:
Constantes
números
caracteres
símbolos.
Símbolos
Operadores
Operadores básicos e deﬁnidos pelo usuário
Atribuição

Sintaxe do R
Vetores numéricos
1 # Números são interpretados literalmente
2 1.1
3 [1] 1.1
4 2^1023
5 [1] 8.988466e+307
6
7 # Valores em notação hexadecimal comecam com 0x
8 0x1
9 [1] 1
10 0xFFFF
11 [1] 65535

Sintaxe do R
Vetores numéricos
1 # Qualquer número éinterpretado como ponto flutuante de dupla ←
precisão
2 typeof(1)
3 [1] double
4 ?typeof # mais sobre a função typeof()
5 typeof(as(1,integer)) # se deseja um inteiro, use a função ←
as
6 [1] integer

Sintaxe do R
Vetores numéricos
1 # Limites de precisão
2 (2^1023 + 1) == 2^1023 # 2^1023 éo máximo de precisão
3 [1] TRUE
4 # Limites de tamanho
5 2^1024
6 [1] Inf # o universo so existe até 2^1023
7
8 # R suporta complexos, escritos como (real) + (imaginário)i
9 0+1i ^ 2
10 [1] -1+0i
11 sqrt(-1+0i)
12 [1] 0+1i
13 exp(0+1i * pi)
14 [1] -1+0i

Sintaxe do R
Vetores numéricos
1 # A função sqrt() retorna um valor do mesmo tipo de entrada
2 sqrt(-1)
3 [1] NaN
4 Warning message:
5 In sqrt(-1) : NaNs produced
6 # O operador a:b retorna uma sequência de inteiros no ←
intervalo [a,b]
7 1:5
8 [1] 1 2 3 4 5
9 typeof(1:5)
10 [1] integer
11 # Para combinar um conjunto de números em um vetor, use a ←
função c()
12 v - c(173,12,1.12312,-93)
13 print(v)
14 [1] 173.00000 12.00000 1.12312 -93.0000000

Sintaxe do R
Vetores numéricos
1 # Em R, c se refere a função primitiva c(), porém você pode ←
redefinitr c
2 c - 3
3 c
4 [1] 3
5 # mesmo após redefinir c, você pode combinar números
6 v - c(3,2,1)
7 v
8 [1] 3 2 1

Sintaxe do R
Caracteres
1 # Um caracter contém texto entre duas aspas
2 y - abc
3 y
4 [1] abc
5 length(y) # tamanho de y
6 [1] 1
7 mode(y) # equivalente a typeof()
8 [1] character
9
10 # Um vetor de caracteres
11 z - c(abc,29 88)
12 length(z)
13 [1] 2
14 mode(z)
15 [1] character

Sintaxe do R
Caracteres
1 # Concatenação de caracteres ...
2 u - paste(abc,de,f) # concatena as strings
3 u
4 [1] abc de f
5 # ... e separação (split)
6 v - strsplit(u,.) # divide em função dos espaços
7 v
8 [[1]]
9 [1] abc de f
10 # Outra forma de concaternar ...
11 u - paste(abc,de,f,sep=.) # usa . como separador
12 u
13 [1] abc.de.f
14 # ... e separar
15 strsplit(u,)
16 [[1]]
17 [1] a b c . d e . f

Sintaxe R Símbolos
Símbolos
Um símbolo é um objeto que se refere a outro objeto
1 # Símbolo éo nome da variável em R
2 x1 - 1
3 X1 - 2
4 x1
5 [1] 1
6 X1
7 [1] 2
8 x1.1 - 1
9 x1.1_1 - 1
10 # Se necessário (!?), defina um símbolo assim:
11 1+2=3 - hello
12 1+2=3
13 [1] hello
14 # Nem todas as palavras são símbolos (palavras reservadas)
15 # -- if, else, repeat, while, function, for, in, next, break
16 # -- TRUE, FALSE, NULL, Inf, NaN, NA
17 # -- ...

Sintaxe R Símbolos
Símbolos
Funções
Uma função é uma outra forma de atribuir valor a um símbolo
1 # Atribui a função vetorial c(x+1, y+1) ao símbolo f
2 f - function(x,y) {c(x+1, y+1)}
3 f(1,2)
4 [1] 2 3
5 # Para visualizar o conteúdo de f
6 f
7 function(x,y) {c(x+1, y+1)}

Sintaxe R Símbolos
Símbolos
Funções
1 # Visualizando o conteúdo da função desvio padrão
2 sd
3 function (x, na.rm = FALSE)
4 {
5 if (is.matrix(x))
6 apply(x, 2, sd, na.rm = na.rm)
7 else if (is.vector(x))
8 sqrt(var(x, na.rm = na.rm))
9 else if (is.data.frame(x))
10 sapply(x, sd, na.rm = na.rm)
11 else sqrt(var(as.vector(x), na.rm = na.rm))
12 }

Sintaxe R Vetores
Vetores
Operações básicas
O comando c(), de “combinar”, é a forma principal de criar vetores
1 # Criando objetos
2 x- c(1,2,3); print(x)
3 [1] 1 2 3
4 y- 5:9; print(y) # aqui temos uma sequência
5 [1] 5 6 7 8 9
6 z-c(x,y); print(z) # x e y são aglutinados em z
7 [1] 1 2 3 5 6 7 8 9
8 # Listando os elementos no espaço de trabalho
9 ls()
10 [1] x y z
11 # Apagando alguns deles
12 rm(x,y)
13 # Listando novamente
14 ls()
15 [1] z
16 rm(list=ls()) # apaga tudo

Sintaxe R Vetores
Vetores
1 # soma de vetores
2 c(1,2,3) + c(1,1,1)
3 [1] 2 3 4
4 # se não têm o mesmo tamanho, a menor sequência érepetida
5 c(1, 2, 3, 4) + 1
6 [1] 2 3 4 5
7 # o mesmo vale para divisão
8 1 / c(1, 2, 3, 4, 5)
9 [1] 1.0000000 0.5000000 0.3333333 0.2500000 0.2000000
10
11 # no caso abaixo, a menor sequência tem tamanho 2
12 c(1, 2, 3, 4) + c(10, 100)
13 [1] 11 102 13 104

Sintaxe R Vetores
Vetores
1 # A primeira sequência não émúltipla da segunda: 5 não é←
mútiplo de 2
2 c(1, 2, 3, 4, 5) + c(10, 100)
3 [1] 11 102 13 104 15
4 Mensagens de aviso perdidas:
5 In c(1, 2, 3, 4, 5) + c(10, 100) :
6 comprimento do objeto maior não émúltiplo do comprimento do ←
objeto menor
7 # Em R podemos entrar com expressões de caracteres
8 Hello world.
9 [1] Hello world.
10 # Um vetor de caracteres de comprimento 2
11 c(Hello world, Hello R interpreter)
12 [1] Hello world
13 [2] Hello R interpreter

Sintaxe R Vetores
Vetores
1 # Formas de acessar os membros de um vetor
2 b = c(1:10)
3 b
4 [1] 1 2 3 4 5 6 7 8 9 10
5 b[5] # acessa o 5o. elemento de b
6 [1] 5
7 b[2:7] # acessa uma fatia de b
8 [1] 2 3 4 5 6 7
9 b%%3 # resto da divisão por 3
10 [1] 1 2 0 1 2 0 1 2 0 1

Sintaxe R Vetores
Vetores
1 # A operação abaixo retorna um vetor lógico
2 b%%3==0
3 [1] FALSE FALSE TRUE FALSE FALSE TRUE FALSE FALSE TRUE FALSE
4
5 # Elementos de b congruentes de 0 (mod 3)
6 b[b%%3==0]
7 [1] 3 6 9
8 #
9 b[c(2,6,9)]
10 [1] 2 6 9

Sintaxe R Instruções de Controle
As instruções de controle em R são muito similares àquelas de C, C++,
Perl e Python
Aqui vamos focar nos laços (loops) e condicionais (if-else)
1 # Python-like for: uma iteração para cada elemento
2 x - c(5,12,13)
3 for (n in x){
4 + y = x/10
5 + print(n^2+y)
6 + }
7 [1] 25.5
8 [1] 144.12
9 [1] 169.13

As instruções de controle em R são muito similares àquelas de C, C++,
Perl e Python
Aqui vamos focar nos laços (loops) e condicionais (if-else)
1 # O mesmo vale para listas
2 l=list(p=21,k=c(1,2,3),z=NaN, f=function(a){return(a^2)})
3 for(x in l) print(x)
4 [1] 21
5 [1] 1 2 3
6 [1] NaN
7 function(a){return(a^2)}

1 # C-style while
2 i - 1
3 while (i = 10) i - i+4
4 i
5 [1] 13
6
7 # Funcionamento básico do if
8 if (r == 4) {
9 + x - 1
10 +} else {
11 + x - 3
12 + y - 4
13 +}

1 # Duas formas de representar a mesma operação
2 x - 1
3 y - if(x == 2) x else x+1
4 y
5 [1] 2
6 if(x == 2) y - x else y - x+1
7 y
8 [1] 2

Sintaxe R Funções
Funções
Em R, as operações que fazem todo o trabalho são chamadas funções
1 # Funções com 1 argumento
2 exp(1)
3 [1] 2.718282
4 cos(3.141593)
5 [1] -1
6 # Alguns argumentos podem ser especificados pelo nome
7 log(x=64, base=4)
8 [1] 3
9 # O comando seq() possui vários argumento opcionais
10 seq(from=0,to=10,by=0.8) # intervalo
11 [1] 0.0 0.8 1.6 2.4 3.2 4.0 4.8 5.6 6.4 7.2 8.0 8.8 9.6
12 seq(from=0,to=10,length=20) # comprimento
13 [1] 0.0000000 0.5263158 1.0526316 1.5789474 2.1052632 2.6315789
14 [7] 3.1578947 3.6842105 4.2105263 4.7368421 5.2631579 5.7894737
15 [13] 6.3157895 6.8421053 7.3684211 7.8947368 8.4210526 8.9473684
16 [19] 9.4736842 10.000000

Sintaxe R Funções
Funções
Nem todas as funções têm a forma f (x1,x2,....)
Algumas aparecem na forma de operadores
1 17 + 2
2 [1] 19
3 2 ^ 10
4 [1] 1024
5 3 == 4
6 [1] FALSE

Sintaxe R Funções
Funções
Assim como em qualquer linguagem de programação, o cerne do R
consiste em escrever funções
Uma função é um grupo de instruções que recebe as entradas, opera
sobre elas e retorma uma saída
1 # Conta o número de números ímpares em um vetor de inteiros
2 oddcount - function(x)
3 + k - 0 # o + indica continuação de linha
4 + for (n in x) {
5 + if (n %% 2 == 1) k
6 + }
7 + return(k) # o função retorna alguma coisa
8 + }
9
10 oddcount(c(1,3,5))
11 [1] 3
12 oddcount(c(1,2,3,7,9))
13 [1] 4

Sintaxe R Funções
Funções
Variáveis criadas fora da função são globais e visíveis pela função
1 f - function(x) return(x+y)
2 y - 3
3 f(5)
4 [1] 8
Entradas podem ter um valor default
1 f - function(x,y=10) return(x+y)
2 f(x=3)
3 [1] 13
4 f(x=3,y=3)
5 [1] 6
6 f(k=3)
7 Error in f(k = 3) : unused argument(s) (k = 3)

Sintaxe R Operadores
Operadores
Operadores básicos
Um operador é uma função que toma um ou mais argumentos e pode
ser escrita sem parênteses
1 x - -1:5
2 x
3 [1] -1 0 1 2 3 4 5
4 # adição e multiplicação
5 2 * x + 3
6 [1] 1 3 5 7 9 11 13
7 # exponenciação
8 x^3
9 [1] -1 0 1 8 27 64 125
10 # resto da divisão (módulo)
11 x %% 2 #-- éperiódico
12 [1] 1 0 1 0 1 0 1
13 # divisão inteira
14 x %/% 5 # x %/% 5 == floor(x/5)
15 [1] -1 0 0 0 0 0 1

Operadores
Operadores deﬁnidos pelo usuário
1 # Você pode definir seus próprios operadores
2 # Vamos definir o operador %myop% através de uma função
3 %myop% - function(a, b) {2*a + b}
4 1 %myop% 1
5 [1] 3
6 1 %myop% 2
7 [1] 4
8 c(1,2,3,4,5) %myop% 2
9 [1] 4 6 8 10 12
10 # Atribuição éum operador
11 x - c(1,2,3,4,5)
12 # O negativo também éum operador
13 -7
14 [1] -7
15 # O ponto de interrogação ? (help) também éum operador
16 ??

Operadores
Atribuição
1 # As operações de atribuição atribuem um objeto a um símbolo
2 # Vetor atribuído a um símbolo
3 v - c(1,2,3,4,5,6,7,8)
4 # Objeto lista atribuída a um símbolo
5 y - list(sapato=mocassim, chapeu=gorro, camisa=polo)
6 y
7 $sapato
8 [1] mocassim
9 $chapeu
10 [1] gorro
11 $camisa
12 [1] polo
13 # Objeto função atribuído a um símbolo
14 z - function(a,b,c) {a ^ b / c}
15 z
16 function(a,b,c) {a ^ b / c}

Sintaxe R Estruturas de dados
Introdução as estruturas de dados
Em R, podemos construir estruturas de dados mais complicadas do que
vetores
Alguns casos
arrays
listas
dataframes
...

Estruturas de dados
Arrays
1 # Um array éum vetor multidimensional
2 a - array(c(1,2,3,4,5,6,7,8,9,10,11,12),dim=c(3,4))
3 a
4 [,1] [,2] [,3] [,4]
5 [1,] 1 4 7 10
6 [2,] 2 5 8 11
7 [3,] 3 6 9 12
8 # Para acessar o elemento [2,2]
9 a[2,2]
10 [1] 5
11 # Veja como fica um vetor com o mesmo conteúdo
12 v - c(1,2,3,4,5,6,7,8,9,10,11,12); v
13 [1] 1 2 3 4 5 6 7 8 9 10 11 12

Estruturas de dados
Arrays
1 # Relembrando do array a, podemos acessá-lo de diferentes formas
2 a
3 [,1] [,2] [,3] [,4]
4 [1,] 1 4 7 10
5 [2,] 2 5 8 11
6 [3,] 3 6 9 12
7
8 # Somente a primeira linha
9 a[1,]
10 [1] 1 4 7 10
11 # Somente a primeira coluna
12 a[,1]
13 [1] 1 2 3

Estruturas de dados
Arrays
1 # Acessando uma fatia das linhas
2 a[1:2,]
3 [,1] [,2] [,3] [,4]
4 [1,] 1 4 7 10
5 [2,] 2 5 8 11
6 # Relembrando do array a mais uma vez
7 a
8 [,1] [,2] [,3] [,4]
9 [1,] 1 4 7 10
10 [2,] 2 5 8 11
11 [3,] 3 6 9 12

Estruturas de dados
Arrays
1 # Acessando um conjunto não contíguo colunas
2 a[,c(1,3)] # mostra somente as colunas 1 e 3
3 [,1] [,2]
4 [1,] 1 7
5 [2,] 2 8
6 [3,] 3 9
7
8 # O sinal negativo exclui linhas ou colunas
9 a[-c(1,3),] # exclui linhas 1 e 3
10 [1] 2 5 8 11
11 a[-2,-c(1,4)] # exclui linha 2 e colunas 1 e 4
12 [,1] [,2]
13 [1,] 4 7
14 [2,] 6 9

Estruturas de dados
Arrays
1 # Uma matriz éum array bidimensional
2 m - matrix(data=c(1,2,3,4,5,6,7,8,9,10,11,12),nrow=3,ncol=4)
3 m
4 [,1] [,2] [,3] [,4]
5 [1,] 1 4 7 10
6 [2,] 2 5 8 11
7 [3,] 3 6 9 12
8
9 # O comando matrix(() preenche as colunas com os dados ←
fornecidos
10 matrix(1:6,nrow=2)
11 [,1] [,2] [,3]
12 [1,] 1 3 5
13 [2,] 2 4 6

Estruturas de dados
Arrays
1 # O preencimento por linhas também épossível
2 matrix(1:6,nrow=2, byrow=TRUE)
3 [,1] [,2] [,3]
4 [1,] 1 2 3
5 [2,] 4 5 6
6
7 # Uma outra forma de criar uma matriz éusando as funções
8 # -- rbind()
9 m - rbind(c(1,4),c(2,-3))
10 m
11 [,1] [,2]
12 [1,] 1 4
13 [2,] 2 -3

Estruturas de dados
Arrays
1 # -- cbind()
2 n - cbind(c(1,4),c(2,-3))
3 n
4 [,1] [,2]
5 [1,] 1 2
6 [2,] 4 -3
7
8 # --diag()
9 diag(2)
10 [,1] [,2]
11 [1,] 1 0
12 [2,] 0 1

Estruturas de dados
Arrays
1 # Além da soma e subtração, temos as operações
2 # -- multiplicação termo a termo
3 m * diag(2)*3
4 [,1] [,2]
5 [1,] 3 0
6 [2,] 0 -9
7
8 # -- divisão termo a termo
9 m/diag(2)
10 [,1] [,2]
11 [1,] 1 Inf
12 [2,] Inf -3

Estruturas de dados
Arrays
1 # -- produto matricial
2 m % * % n
3 [,1] [,2]
4 [1,] 17 -10
5 [2,] -10 13

Estruturas de dados
Arrays
Atenção!
1 # O R pode operar com arrays de diferentes tamanhos, por ←
causa do reuso dos vetores!
2 x=matrix(1:6,ncol=2)
3 x
4 [,1] [,2]
5 [1,] 1 4
6 [2,] 2 5
7 [3,] 3 6
8 # Aparentemente, a operação não faria sentido
9 x+c(1,2)
10 [,1] [,2]
11 [1,] 2 6
12 [2,] 4 6
13 [3,] 4 8
14 # Vamos vamos fazer algumas considerações...

Estruturas de dados
Arrays
Atenção!
1 # Neste caso, ocorre a repetição dos valores, e a soma ←
anterior éequivalente a
2 x + c(1,2,1,2,1,2)
3 [,1] [,2]
4 [1,] 2 6
5 [2,] 4 6
6 [3,] 4 8

Estruturas de dados
Arrays
Atenção!
1 # Observe a construção da matrix y, com c(1,2) repetido nas ←
colunas
2 y=matrix(c(1,2,1,2,1,2),ncol=2)
3 y
4 [,1] [,2]
5 [1,] 1 2
6 [2,] 2 1
7 [3,] 1 2
8 x + y
9 [,1] [,2]
10 [1,] 2 6
11 [2,] 4 6
12 [3,] 4 8

Estruturas de dados
Arrays
1 # Arrays podem ter mais de uma dimensão
2 w - array(c(1:18),dim=c(3,3,2))
3 print(w)
4 , , 1
5
6 [,1] [,2] [,3]
7 [1,] 1 4 7
8 [2,] 2 5 8
9 [3,] 3 6 9
10
11 , , 2
12
13 [,1] [,2] [,3]
14 [1,] 10 13 16
15 [2,] 11 14 17
16 [3,] 12 15 18

Estruturas de dados
Arrays
1 # Acessando um dos elementos
2 w[1,1,1]
3 [1] 1

Estruturas de dados
Listas
Uma lista aceita a mistura de objetos de diferentes tipos
1 # Uma lista contendo um número e uma string
2 e - list(elemento=esfera, raio=8.25)
3 e
4 $elemento
5 [1] esfera
6 $raio
7 [1] 8.25
8 # Os objetos podem ser acessados de várias formas
9 e$elemento
10 [1] esfera
11 e[2]
12 $raio
13 [1] 8.25
14 e[[2]]
15 [1] 8.25

Estruturas de dados
Listas
1 # Uma lista pode referenciar outra lista
2 g - list(Essa lista referencia outra lista, e)
3 g
4 [[1]]
5 [1] Essa lista referencia outra lista
6
7 [[2]]
8 [[2]]$objeto
9 [1] esfera
10
11 [[2]]$raio
12 [1] 8.25

Estruturas de dados
Dataframes
Um dataframe é um objeto que contém múltiplos vetores que são do
mesmo tamanho
é semelhante a uma planilha ou base de dados
bons para representar dados experimentais
1 # As 6 cidades mais populosas do Brasil
2 cidade - c('São Paulo','Rio de ←
Janeiro','Salvador','Brasília','Fortaleza', 'Belo ←
Horizonte','Manaus')
3 estado - c('SP','RJ','BA','DF','CE','MG','AM')
4 pop - ←
c(11376685,6390290,2710698,2648532,2500194,2395785,1861838)

Estruturas de dados
Dataframes
Um dataframe é um objeto que contém múltiplos vetores que são do
mesmo tamanho
é semelhante a uma planilha ou base de dados
bons para representar dados experimentais
1 # As informações estão armazenadas em vetores
2 cidade
3 [1] São Paulo Rio de Janeiro Salvador Brasília
4 [5] Fortaleza Belo Horizonte Manaus
5 estado
6 [1] SP RJ BA DF CE MG AM
7 pop
8 [1] 11376685 6390290 2710698 2648532 2500194 2395785 1861838

Estruturas de dados
Dataframes
1 # Armazenando em um dataframe
2 top6pop -data.frame(cidade,estado,pop)
3 top6pop
4 cidade estado pop
5 1 São Paulo SP 11376685
6 2 Rio de Janeiro RJ 6390290
7 3 Salvador BA 2710698
8 4 Brasília DF 2648532
9 5 Fortaleza CE 2500194
10 6 Belo Horizonte MG 2395785
11 7 Manaus AM 1861838

Estruturas de dados
Dataframes
1 # Acessando as informações contidas em top6pop
2 top6pop$estado
3 [1] SP RJ BA DF CE MG AM
4 Levels: AM BA CE DF MG RJ SP
5 #
6 top6pop[2] # outra forma de acessar os estados
7 estado
8 1 SP
9 2 RJ
10 3 BA
11 4 DF
12 5 CE
13 6 MG
14 7 AM

Estruturas de dados
Dataframes
1 top6pop$pop 2.7e6 # cidades com mais de 2.7 mi hab
2 [1] TRUE TRUE TRUE FALSE FALSE FALSE FALSE
3 #
4 top6pop$pop[top6pop$pop2.7e6] # populações maiores que 2.7 ←
mi hab
5 [1] 11376685 6390290 2710698

Sintaxe R Objetos e Classes
Objetos e Classes
R é uma linguagem orientada a objetos
Cada objeto em R tem um tipo
E cada objeto em R é membro de uma classe
Já encontramos diferentes classes: vetores de caracteres, vetores
numéricos, dataframes, listas, ...
1 class(1:10)
2 [1] integer
3 class(w)
4 [1] array
5 class(v)
6 [1] numeric
7 class(top6pop)
8 [1] data.frame
9 class(e)
10 [1] list
11 class(class)
12 [1] function

Objetos e Classes
Modelos e fórmulas
Um modelo é uma forma concisa de descrever um conjunto de dados,
usualmente por meio de uma fórmula matemática
Algumas vezes o objetivo é construir um modelo preditivo baseado em
dados disponíveis para avaliar novos dados
Outras vezes o objetivo é constrir um modelo descritivo que auxilie no
melhor entendimento dos dados
O R possui uma notação especíﬁca para decrever relações entre
variáveis
Suponha uma variável y onde assumimos uma dependência linear de
outras variáveis x1,x2,··· ,xn, resultando no modelo
y = c1x1 +c2x2 +··· +cnxn +ε
Em R, podemos escrever essa relação como um objeto fórmula
1 y ~ x1 + x2 + ... + xn

Objetos e Classes
Modelos e fórmulas
Vamos analisar o seguinte exemplo
1 # Conjunto de 20 pontos com ruído e distribuição normal
2 set.seed(2)
3 x = seq(from=0,to=5,length=20)
4 y = 2*x - 3 + rnorm(20) # rnorm(): distrib. normal
5 xy= data.frame(x,y)
6 xy
7 x y
8 1 0.0000000 -3.8969145
9 2 0.2631579 -2.2888350
10 ...
11 20 5.0000000 7.4322652
12 # lm() constroi um modelo y~x e atribui a variável xy.lm
13 # -- y : variável dependente
14 # -- x : variável independente
15 xy.lm = lm(formula=y~x, data=xy)

Objetos e Classes
Modelos e fórmulas
1 # Vamos analisar o objeto xy.lm (modelo linear)
2 xy.lm
3
4 Call:
5 lm(formula = y ~ x, data = xy)
6
7 Coefficients:
8 (Intercept) x
9 -2.926 2.049
10
11 # Observe os coeficiente e compare com o modelo y = 2*x - 3 + ←
rnorm(20)

Objetos e Classes
Modelos e fórmulas
1 # Para maiores detalhes, use a função summary()
2 summary(xy.lm)
3 Call:
4 lm(formula = y ~ x, data = xy)
5
6 Residuals:
7 Min 1Q Median 3Q Max
8 -2.57694 -0.45741 0.04638 0.62709 1.80821
9 Coefficients:
10 Estimate Std. Error t value Pr(|t|)
11 (Intercept) -2.9261 0.4675 -6.259 6.65e-06 ***
12 x 2.0486 0.1598 12.816 1.74e-10 ***
13 ---
14 Signif. codes: 0 *** 0.001 ** 0.01 * 0.05 . 0.1 1
15 Residual standard error: 1.085 on 18 degrees of freedom
16 Multiple R-squared: 0.9012, Adjusted R-squared: 0.8957
17 F-statistic: 164.3 on 1 and 18 DF, p-value: 1.738e-10

Objetos e Classes
Modelos e fórmulas
1 # predict.lm() avalia os dados do dataframe xy no modelo xy.lm
2 xy.pr=predict.lm(xy.lm)
3
4 # Usamos algumas ferramentas gráficas para visualizar
5 plot(x,y,col='blue'); lines(x,xy.pr,col='red')

Pacotes do R
Conteúdo
3 Pacotes do R

Pacotes do R Pacotes de dados e funções
Introdução
Um pacote é um conjunto de funções, arquivos de ajuda e arquivos de
dados empacotados juntos
Pacotes em R são similares aos modulos em Perl e Fortran, bibliotecas
em C e classes em Java
Tipicamente, todas as funções em um pacote estão relacionadas entre si
1 # Os pacotes de dados disponíveis são listados através
2 data()
3
4 # Os pacotes de funçõesd isponíveis são listados usando
5 library()

Dados
O R possui pacotes de dados internos, usados principamente para
demos e desenvolvimento de pacotes
1 # Os pacotes de dados disponíveis são listados através do ←
comando
2 data()
3 Data sets in package 'datasets':
4
5 AirPassengers Monthly Airline Passenger Numbers 1949-1960
6 BJsales Sales Data with Leading Indicator
7 ...
8 volcano Topographic Information on Maunga Whau Volcano
9 warpbreaks The Number of Breaks in Yarn during Weaving
10 women Average Heights and Weights for American Women
11
12 Use data(package = .packages(all.available = TRUE))
13 to list the data sets in all *available* packages.

Dados
1 # Para acessar um determinado conteúdo
2 data(trees)
3 trees
4 Girth Height Volume
5 1 8.3 70 10.3
6 2 8.6 65 10.3
7 ...
8 31 20.6 87 77.0

Dados
1 # Operando com os dados
2 class(trees)
3 [1] data.frame
4 mean(trees)
5 Girth Height Volume
6 13.24839 76.00000 30.17097
7 str(trees) # mostra informações sobre a estrututa do ←
objeto
8 'data.frame': 31 obs. of 3 variables:
9 $ Girth : num 8.3 8.6 8.8 10.5 10.7 10.8 11 11 11.1 11.2 ...
10 $ Height: num 70 65 63 72 81 83 66 75 80 75 ...
11 $ Volume: num 10.3 10.3 10.2 16.4 18.8 19.7 15.6 18.2 22.6 ←
19.9 ...

Dados
1 # Medidas do fluxo anual do Nilo na cidade de Ashwan 1871-1970
2 data(Nile)
3 Nile
4 Time Series:
5 Start = 1871
6 End = 1970
7 Frequency = 1
8 [1] 1120 1160 963 1210 1160 1160 813 1230 1370 1140 995 935
9 [13] 1110 994 1020 960 1180 799 958 1140 1100 1210 1150 1250
10 ...
11 [85] 918 986 797 923 975 815 1020 906 901 1170 912 746
12 [97] 919 718 714 740
13 str(Nile)
14 Time-Series [1:100] from 1871 to 1970: 1120 1160 963 1210 ←
1160 1160 813 1230 1370 1140 ...
15 class(Nile) # objeto time series (série temporal)
16 [1] ts

Pacotes
O pacote stats agrupa funções de análise estatística
1 # Carrega os pacote -- comandos equivalentes
2 library(stats)
3 require(stats)
4
5 # Para maiores informações
6 library(help=stats)
7 ?stats

Pacotes
R oferece um grande número de pacotes
Análise gráﬁca
Aplicações industriais
Ciências sociais
....
Alguns pacotes veem com o R, outros são instalados através de
repositórios

Pacotes
1 # Pacotes carregados automaticamente
2 getOption(defaultPackages)
3 [1] datasets utils grDevices graphics methods stats
4 # Pacotes disponíveis para serem carregados
5 (.packages(all.available=TRUE))
6 [1] ade4 calibrate clusterSim corrgram
7 [6] Defaults ellipse gclus Hmisc
8 [11] nutshell quantmod R2HTML RColorBrewer
9 [16] seriation TSP TTR xts
10 [21] ape biclust bitops cba
11 [26] colorspace dataframes2xls e1071 emoa
12 # Instalação de pacotes -- repositórios online
13 install.packages('psy')
14 # Remoção de pacotes
15 remove.packages(c(tree, maptree),.Library)

Pacotes
1 # Exemplo de uso do pacote tsa (time series analysis)
2 Error in library(TSA) : there is no package called tsa
3 # Pacote não instalado
4
5 # Instalação
6 install.packages('TSA')
7
8 # Instalação completa
9 install.packages('TSA', dependencies=T)

Gráﬁcos
Conteúdo
4 Gráﬁcos

Gráficos Gráficos no R
Gráficos no R
R inclui vários pacotes para a visualização de dados
Se você é familiarizado com planilhas eletrônicas, vocÊ perceberá que o
R pode gerar
gráficos de barras
gráficos de linhas
histogramas
gráficos de dispersão
...
Vamos verificar alguns casos por meio de exemplos

Gráﬁcos no R
1 # Gráfico da função seno
2 x = seq(0,1,0.1)
3 y = sin(2*pi*x)
4 plot(x,y,type='b',col='darkgreen',main='Função ←
seno',xlab='eixo-x', ylab='eixo-y',lwd=2)

Gráﬁcos no R
1 # Gráficos de funções paramétricas de uma variável
2 par(mfrow=c(1,2)) # uma linha e duas colunas
3 curve( 3*x^2+2*x+1, -1, 2,col=red,lwd=2)
4 curve(-3*x^2+2*x+1, -1, 2,col=blue,lwd=2)

Gráﬁcos no R
1 # Histograma de uma série dados com distribuição normal
2 x = rnorm(1000)
3 hist(x,col=yellow,breaks=40)

Gráﬁcos no R
1 # Um gráfico de barras
2 barplot(c(2,4,7,5,3,1),col='lightblue')

Gráﬁcos no R
1 # Gráfico de pizza
2 pie(1:6, col = rainbow(6), labels= LETTERS[1:6], radius = 0.9)

Gráﬁcos no R
1 # Gráfico de densidade
2 x = rnorm(200)
3 plot(density(x),col='red',lwd=2)

Gráﬁcos no R
1 # Boxplots
2 x - rnorm(200) # distribuição normal
3 y - rlnorm(200) # distribuição log-normal
4 plot(x, y, xlim=c(-5,5), ylim=c(-2,8))
5 boxplot(x, col=gold , horizontal=TRUE, at=-1, add=TRUE)
6 boxplot(y, col=blue, horizontal=FALSE, at=-4, add=TRUE)

Interface com outras linguagens
Conteúdo

Interface com outras linguagens R e outras Linguagens de Programação
R e outras Linguagens de Programação
Em R, podemos reutilizar códigos desenvolvidos em outras linguagens
R e C (ou C++)
R e Fortran
R e Python (pacotes rpy, rpy2 e RSPython)
R e Java (pacotes RJava e JRI)
R e Perl (pacote RSPerl)
R e MySQL (pacote RMySQL)

Interface com outras linguagens Combinando R com C e Fortran
O R é relativamente lento em algoritmos iterativos que exigem laços
(loops) repetidas vezes
Uma maneira de obter todas as vantagens de velocidade de C ou
Fortran com a maioria da conveniência de R é escrever o loop interno em
C e chamá-lo de dentro do R
Vamos considerar um problema bem simples, elevar ao quadradoos
elementos de um vetor x = (x1,x2,...,xn−1,xn)
q(x) = (x2
1 ,x2
2 ,...,x2
n−1,x2
n )

Aqui temos o código em linguagem C com uma solução para o problema
O R exige duas proriedades da função:
A função não retorna nenhum valor. Todo o trabalho é feito mudando os
valores dos argumento.
Todos os argumentos são ponteiros. Em R, mesmo escalares são vetores
(de comprimento um).
1 /* pot2c.c */
2 void pot2c(int *nin, double *x)
3 {
4 int n = nin[0];
5 int i;
6
7 for (i=0; in; i++)
8 x[i] = x[i] * x[i];
9 }

Aqui temos o a mesma função em uma subrotina em Fortran
Ela tem as mesmas duas propriedades da função em C:
Ela não retorna valor, pois é uma subrotina. Funções (em Fortran) não são
reconhecidas pelo R.
A segunda proriedade é automática em Fortran. Fortran só aceita
passagens de argumentos por referência, que corresponde aos ponteiros
em C.
1 ! pot2f.f
2 subroutine pot2f(n, x)
3 integer n
4 double precision x(n)
5 integer i
6
7 do i = 1, n
8 x(i) = x(i) ** 2
9 enddo
10 end

A compilação para a geração de bibliotecas dinâmicas, é feita em um
terminal Linux, e portanto fora do R (e usando o proprio R)
1 # Compila o código em C
2 R CMD SHLIB pot2c.c
3 # Resultado do comando
4 # gcc -I/usr/share/R/include -fpic -std=gnu99 -O3 -pipe -g ←
-c pot2c.c -o pot2c.o
5 # gcc -shared -o pot2c.so pot2c.o -L/usr/lib/R/lib -lR
6
7
8 # Compila o código em Fortran
9 R CMD SHLIB pot2f.f
10 # Resultado do comando
11 # gfortran -fpic -O3 -pipe -g -c pot2f.f -o pot2f.o
12 # gcc -shared -o pot2f.so pot2f.o -lgfortran -lm -lquadmath ←
-L/usr/lib/R/lib -lR

Voltando ao R, podemos carregar as bibliotecas
1 # Carregas as biblotecas geradas
2 dyn.load(pot2c.so)
3 dyn.load(pot2f.so)
4
5 # Verifica as bibliotecas carregadas com o comando ←
getLoadedDLLs()
6 getLoadedDLLs()
7 Filename ←
Dynamic.Lookup
8 base base FALSE
9 methods /usr/lib/R/library/methods/libs/methods.so FALSE
10 grDevices /usr/lib/R/library/grDevices/libs/grDevices.so FALSE
11 stats /usr/lib/R/library/stats/libs/stats.so FALSE
12 pot2c /tmp/pot2c.so TRUE
13 pot2f /tmp/pot2f.so TRUE

Executando o função em C
1 # Para testar, vamos criar um vetor x
2 x=c(1,2,3,4,5)
3 x
4 [1] 1 2 3 4 5
5
6 typeof(x) # x deve ser double, assim como o argumento ←
na função em C
7 [1] double
8
9 # A chamada da função em R éfeita pelo comando .C()
10 .C(pot2c, n=length(x), x=x)
11 $n
12 [1] 5
13
14 $x
15 [1] 1 4 9 16 25

Executando o subrotina em Fortran
1 # A chamada da subrotina em R éfeita pelo comando .Fortran()
2 .Fortran(pot2f, n=length(x), x=x)
3 $n
4 [1] 5
5
6 $x
7 [1] 1 4 9 16 25

Uma solução mais agradável é criar uma função envelope
Permite checar alguns erros em R, o que é mais fácil que em C
Permite que alguns argumento calculados não sejam mostrados
Permite retornar somente o que o necessário
1 # Função envelope
2 pot2c - function(x) {
3 if (!is.numeric(x))
4 stop(O argumento x deve ser numérico)
5 out - .C(pot2c,
6 n=as.integer(length(x)),
7 x=as.double(x))
8 return(out$x)
9 }
10
11 # Executando a função
12 pot2c(x)
13 [1] 1 4 9 16 25

Análise de casos
Conteúdo
6 Análise de casos

Análise de casos Ajuste de Curvas
Ajuste de Curvas
Vamos usar dados que relacionam a temperatura em graus Celsius com
o valor da pressão de mercúrio.
1 # Carrega os dados
2 data(pressure)
3 head(pressure)
4 temperature pressure
5 1 0 0.0002
6 2 20 0.0012
7 3 40 0.0060
8 4 60 0.0300
9 5 80 0.0900
10 6 100 0.2700
11
12 pres = pressure$pressure # cria variáveis auxiliares
13 temp = pressure$temperature
14 plot(pres~temp, ylim=c(-50,400)) # gráfico dos dados

Ajuste de Curvas
1 # Constrói os modelos
2 lm1=lm(pres~temp) # linear
3 lm2=lm(pres~temp + I(temp^2)) # quadrático
4 lm3=lm(pres~temp + I(temp^2)+ I(temp^3)) # cúbico
5
6 summary(lm1)
7 summary(lm2)
8 summary(lm3)
9
10 # Gráficos dos modelos
11 plot(pres~temp, ←
ylim=c(-50,400),xlab='Temperatura',ylab='Pressão')
12 lines(predict(lm1)~temp,col='green')
13 lines(predict(lm2)~temp,col='red')
14 lines(predict(lm3)~temp,col='blue')
15 # Legenda
16 legend(x='topleft',legend=c('linear','quadrático','cúbico'), ←
col=c(3,2,4), lwd=1)

Ajuste de Curvas

Análise de casos Vazão da Represa de Furnas
Análise gráﬁca da série histórica (1931-2010) da vazão natural mensal
da represa de Furnas
Fonte: http://www.ons.org.br/operacao/vazoes_naturais.aspx
Planilha eletrônica contendo as séries de vazões naturais médias
mensais

1 # Análise da série histórica das vazões mensais da barragens ←
de Furnas
2 # Fonte: http://www.ons.org.br/operacao/vazoes_naturais.aspx
3 rm(list=ls()) # apaga todo o workspace
4 print(getwd()) # onde estamos?
5
6 # Dados das vazões na planilha
7 # Vazoes_Mensais_1931_2010.xls
8 library(gdata) # suporte para leitura de planilhas
9 v - read.xls(xls='./data/Vazoes_Mensais_1931_2010.xls',sheet=1)
10 View(v)
11
12 ano - v[ANO] # primeira coluna
13 vaz - v[,-1] # todos os dados exceto a 1a coluna
14
15 # Aplica a função média nas colunas de v
16 vaz.m - apply(vaz,2,mean) # médias das vazões mensais
17 View(vaz.m)

1 # Análise gráfica das médias das vazões mensais
2 bp - barplot(vaz.m, ylim=c(0,1.2*max(vaz.m)), ←
col=seagreen, ylab=Vazão, las=3)
3 text(bp, vaz.m, label=round(vaz.m, 0), pos=3,srt=90, cex=0.8, ←
offset=1.5)
4 title(Médias mensais das vazões de Furnas); box()

1 # Boxplots das vazões mensais
2 boxplot(vaz, las=3, col=steelblue, notch=1, ylab=Vazão, ←
main=Vazões mensais de Furnas)
3 points(vaz.m, col='red', lwd=1, pch=19)
4 lines(vaz.m, col='red', lwd=1)

1 # Histograma das vazões mensais
2 vaz.t - unlist(vaz)
3 hist(vaz.t,breaks=20,freq=F,ylim=c(0,12e-4), ←
ylab='Densidade', xlab='Vazão',
4 main='Histograma das Vazões', col='lightblue')
5 lines(density(vaz.t), col='red'); rug(vaz.t, col='red')

Análise de casos Análise de Adubação da Soja
Experimento em casa de vegetação com a cultura da soja, 2 plantas por
parcela com:
3 níveis do fator conteúdo de do solo água (agua),
5 níveis do fator adubação potássica (potassio),
parcelas arranjadas em 5 blocos (bloco).
Foram observadas as seguintes variáveis:
1 rengrao : redimento de grãos
2 pesograo : peso de grãos
3 kgrao : conteúdo de potássio no grão
4 pgrao : conteúdo de fósforo no grão
5 ts : total de sementes por planta
6 nvi : número de vagens inviáveis
7 nv : número de vagens total
Fonte: http://www.leg.ufpr.br/~walmes/

1 # Leitura dos dados no arquivo soja.txt que encontra-se no ←
diretório data
2 #
3 # Primeiro, devemos saber em que diretório estamos
4 getwd()
5 # Depois, devemos mudar para o diretório onde estão os dados
6 setwd('diretorio_onde_estao_os_dados')
7 #
8 # O comando read.table() lê o arquivo em formato de tabela e ←
cria um
9 # dataframe a partir dele, com as entradas correspondendo às ←
linhas
10 # e as variáveis correspondendo às colunas
11 #
12 soja - read.table('./data/soja.txt',header=TRUE)

1 View(soja) # visualização dos dados
2
3 # Algumas informações sobre os dados
4 class(soja) # classe do objeto
5 names(soja) # nomes das colunas
6 dim(soja) # dimensões
7 str(soja) # estrutura
8 head(soja) # cabeçalho
9 soja # imprime todos os registros

1 # Visualização rápida dos dados
2 head(soja) # cabeçalho
3 potassio agua bloco rengrao pesograo kgrao pgrao ts nvi nv
4 1 0 37.5 I 14.55 10.70 15.13 1.18 136 22 56
5 2 30 37.5 I 21.51 13.53 17.12 0.99 159 2 62
6 3 60 37.5 I 24.62 15.78 19.11 0.82 156 0 66
7 4 120 37.5 I 21.88 12.80 18.12 0.85 171 2 68
8 5 180 37.5 I 28.11 14.79 19.11 0.88 190 0 82
9 6 0 50.0 I 17.16 12.26 12.14 1.05 140 20 63
10
11 names(soja)
12 [1] potassio agua bloco rengrao pesograo kgrao ←
pgrao ts
13 [9] nvi nv

1 # Acessando informações das variáveis ($)
2
3 soja$bloco # a variável bloco foi lida como um fator ←
(variável categórica)
4 [1] I I I I I I I I I I I I I I I II ←
II II
5 [24] II II II II II II II III III III III III III III III ←
III III III
6 [47] IV IV IV IV IV IV IV IV IV IV IV IV IV IV V V ←
V V
7 [70] V V V V V V
8 Levels: I II III IV V
9
10 soja$rengrao
11 [1] 14.55 21.51 24.62 21.88 28.11 17.16 24.44 28.50 32.94 ←
28.76 14.13 19.71
12 [16] 15.72 19.72 24.29 25.39 28.45 15.44 28.12 31.49 29.95 ←
30.06 15.42 23.68
13 [31] 12.77 20.45 24.35 27.15 24.08 16.01 24.57 28.85 26.23 ←

1 # O comando attach() anexa a base de dados ao workspace do R
2 #
3 # Os objetos no banco de dados podem ser acessados simplesmente
4 # digitando seus nomes
5
6 attach(soja)
7 rengrao
8 [1] 14.55 21.51 24.62 21.88 28.11 17.16 24.44 28.50 32.94 28.76
9 ...
10 [73] 29.90 20.86 35.50
11
12 # Para desanexar a base de dados
13 detach(soja)
14 rengrao
15 Error: object 'rengrao' not found

1 # Exploração númerica, médias por nível de potássio, água e ←
potássio:água
2 attach(soja) # anexa a base de dados
3 levels(factor(potassio)) # factor() transforma a variável em ←
categórica e levels() extrai as categorias
4 [1] 0 30 60 120 180
5
6 tapply(rengrao,potassio,mean) # tapply() aplica um função a ←
um grupo de valores de um array
7 0 30 60 120 180
8 15.10733 21.29733 27.48200 29.51067 30.43200
9
10 tapply(rengrao,list(agua),mean)
11 37.5 50 62.5
12 21.6956 25.1040 27.4980
13
14 tapply(rengrao,list(potassio,agua),mean) # médias de ←
rendimento para potassio:agua
15 37.5 50 62.5

1 # O comando with avalia uma expressão em uma base de dados
2 # Assim, não precisamos anexar soja
3
4 # A mesma exploração numérica anterior
5 with(soja, tapply(rengrao, list(potassio), mean))
6 0 30 60 120 180
7 15.10733 21.29733 27.48200 29.51067 30.43200
8
9 with(soja, tapply(rengrao, list(agua), mean))
10 37.5 50 62.5
11 21.6956 25.1040 27.4980
12
13 with(soja, tapply(rengrao, list(potassio, agua), mean))
14 37.5 50 62.5
15 0 13.520 15.712 16.090
16 30 20.334 22.570 20.988
17 60 23.926 28.692 29.828
18 120 25.308 29.786 33.438
19 180 25.390 28.760 37.146

1 # Selecionando subconjuntos dos dados de acordo com os níveis ←
das categorias
2 subset(soja, potassio==0)
3 subset(soja, bloco==I)
4 subset(soja, potassio==0 bloco==I)
5
6
7 # Selecionando subconjunto dos dados por valores das respostas
8 subset(soja, rengrao15)
9 subset(soja, rengrao15 pesograo11)

1 # Gráficos simples de dispersão (rótulos, cores, simbolos, ←
tamanhos)
2 plot(rengrao~potassio, data=subset(soja, agua==50))
3 plot(rengrao~potassio, data=subset(soja, agua==50),
4 xlab=Dose de potássio, ylab=Rendimento de grãos,
5 col=2, pch=19, cex=1.2)

1 # Boxplot (subconjuntos e cores)
2 boxplot(rengrao~potassio, data=subset(soja, agua==50))
3 boxplot(rengrao~potassio, data=soja, col=yellow)

1 # Todos níveis de água ao mesmo tempo (título)
2 par(mfrow=c(1,3)) # divide a janela gráfica em uma linha em ←
três colunas
3 boxplot(rengrao~potassio, data=subset(soja, agua==37.5), ←
ylim=c(10,45), main=37.5%)
4 boxplot(rengrao~potassio, data=subset(soja, agua==50 ), ←
ylim=c(10,45), main=50.0%)
5 boxplot(rengrao~potassio, data=subset(soja, agua==62.5), ←
ylim=c(10,45), main=62.5%)

1 # Gráficos de barras (adição de texto)
2 par(mfrow=c(1,1)) # restaura a janela gráfica
3 pot.m - with(soja, tapply(rengrao, potassio, mean))
4 bp - barplot(pot.m) # alterar para ylim=c(0,32)
5 text(bp, pot.m, label=round(pot.m, 3), pos=3) # pos=3
6 title(Médias dos tratamentos)
7 box()

1 # Melhorando o aspecto
2 bp - barplot(pot.m, ylim=c(0,33), col=seagreen,
3 xlab=Dose de potássio, ylab=Rendimento médio ←
de grãos)
4 text(bp, pot.m, label=round(pot.m, 3), pos=3, font=3)
5 title(Médias dos tratamentos)
6 box()

1 # Mais análise gráfica: rendimento em função de potassio para ←
cada grupo de água
2 require(lattice) # biblioteca para gráficos mais elaborados
3 xyplot(rengrao~potassio, groups=agua, data=soja)
4 xyplot(rengrao~potassio, groups=agua, data=soja, ←
type=c(p,a))
5 xyplot(rengrao~potassio|agua, data=soja, type=c(p,a))
6 xyplot(rengrao~potassio|agua, data=soja, type=c(p,smooth))

Análise de casos Usando o ANOVA
Usando o ANOVA
http://www.personality-project.org/r/r.anova.html

Análise de casos Análise Granulométrica do Solo
Dados de análise de imagens de agregados (análise morfométrica) de
amostras de solo identiﬁcadas por dois níveis de profundidade de coleta.
As variáveis observadas foram:
área: area (da projeção no plano) do agregado;
perimetro: perimetro do poligono (obtido da projeção no plano) do agregado;
aspecto e roundness: medidas relativas à forma de um círculo;
maioreixo e menoreixo: retas de maior e menor comprimentos com
extremos na borda;

Análise de casos Análise Granulométrica do Solo
1 # Os dados encontram-se na planilha 'agregados.xls' na pasta ←
data
2 # Para a leitura dos dados, vamos precisar do pacote gdata
3 library(gdata)
4 agr - read.xls(xls='./data/agregados.xls')
5
6 str(agr)
7 'data.frame': 600 obs. of 7 variables:
8 $ profundidade: int 5 5 5 5 5 5 5 5 5 5 ...
9 $ area : num 0.0038 0.005 0.008 0.0052 0.0055 0.0046 ←
0.0055 0.0039 ...
10 $ perimetro : num 0.2 0.3 0.4 0.3 0.3 0.2 0.3 0.2 0.3 0.4 ...
11 $ aspecto : num 0.947 0.913 0.806 0.955 0.792 ...
12 $ roundness : num 0.968 0.871 0.795 0.83 0.897 ...
13 $ maioreixo : int 18 22 30 21 23 20 22 23 23 28 ...
14 $ menoreixo : num 17 20 24 20 18 20 19 15 17 27 ...
15
16 head(agr)
17 profundidade area perimetro aspecto roundness maioreixo ←

Análise de casos Computação Simbólica no R
Em R podemos calcular as derivadas (simbólicas) de expressões simples
1 # Operações simbólicas com expressões simples
2 rm(list=ls()) # limpa o espaço de trabalho
3 # Cria uma expressão simbólica
4 f = expression(cos(x) + x * sin(x))
5 class(f)
6 [1] expression
7 # Avalia a expressão, mas x ainda não exite...
8 eval(c)
9 Error in eval(expr, envir, enclos) : object 'x' not found
10 # Repetindo, mas agora com a criação de x
11 x=seq(0,pi,length=20)
12 eval(f)
13 [1] 1.00000000 1.01357652 1.05319340 1.11556315 1.19537338
14 ...
15 [19] -0.49648737 -1.00000000

1 # O grafico de f -- o rótulo de y éuma expressão
2 plot(ef~x,type='b', ylab=f, col='violetred4')

1 # Derivando f simbolicamente usando o comando D()
2 D(f) # faltou o x
3 Error in .Internal(D(expr, name)) : 'name' is missing
4 D(f,x)
5 sin(x) + x * cos(x) - sin(x)
6 # Para derivadas de ordem superior, definimos a função
7 DD - function(expr,name, order = 1) {
8 if(order 1) stop('order' must be = 1)
9 if(order == 1) D(expr,name)
10 else DD(D(expr, name), name, order - 1)
11 }
12
13 DD(f,x,1)
14 sin(x) + x * cos(x) - sin(x)
15 DD(f,x,2)
16 cos(x) + (cos(x) - x * sin(x)) - cos(x)
17 DD(f,x,4)
18 -(cos(x) + (cos(x) + (cos(x) - x * sin(x))) + cos(x) - cos(x))

1 # Continuando com as derivadas de ordem superior
2 f4=DD(f,x,4)
3 f4
4 -(cos(x) + (cos(x) + (cos(x) - x * sin(x))) + cos(x) - cos(x))
5
6 plot(eval(f4)~x, main=f4, type='b') # observe o título do ←
gráfico

Introdução ao R

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Introdução ao R

Mais de Leonardo Goliatt

Último

Introdução ao R