Mini R

R
Introdução
– Semana da Computação da UFJF –
Leonardo Goliatt
Depto Mecânica Aplicada e Computacional
UFJF
leonardo.goliatt@ufjf.edu.br
2012 Outubro/16
http://bit.ly/WiheUu
1 / 110

Programa
Informações Preliminares
Linguagem R
Análise de Casos
Interface com Outras Linguagens
2 / 110

Conteúdo
Sobre o R
Interface R
Linguagem R
Sintaxe do R
Símbolos
Vetores
Instruções de Controle
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
Pacotes e Dados do R
Análise de Casos
Ajuste de Curvas
Vazão da Represa de Furnas
Análise de Adubação da Soja
Computação Simbólica no R
R e outras Linguagens de Programação
Combinando R com C e Fortran
3 / 110

Conteúdo
Sobre o R
Interface R
4 / 110

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
4 / 110

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
5 / 110

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++
6 / 110

Objetivos do minicurso
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.
7 / 110

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
8 / 110

Conteúdo
Sobre o R
Interface R
9 / 110

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/
9 / 110

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
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.
10 / 110

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
11 / 110

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

Conteúdo
Linguagem R
Sintaxe do R
Símbolos
Vetores
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
13 / 110

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
13 / 110

R é case-sensitive: então A e a são símbolos diferentes e se referem
a diferentes variáveis
Comandos 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
14 / 110

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
15 / 110

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 ?-
16 / 110

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
17 / 110

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

Conteúdo
Linguagem R
Sintaxe do R
Símbolos
Vetores
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
19 / 110

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
19 / 110

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
12
13 # Qualquer número éinterpretado como ponto flutuante de dupla precisão
14 typeof(1)
15 [1] double
16 ?typeof # mais sobre a função typeof()
17 typeof(as(1,integer)) # se deseja um inteiro, use a função as
18 [1] integer
20 / 110

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
15
16 # A função sqrt() retorna um valor do mesmo tipo de entrada
17 sqrt(-1)
18 [1] NaN
19 Warning message:
20 In sqrt(-1) : NaNs produced
21 / 110

Sintaxe do R
Vetores numéricos
1 # O operador a:b retorna uma sequência de inteiros no intervalo [a,b]
2 1:5
3 [1] 1 2 3 4 5
4 typeof(1:5)
5 [1] integer
6
7 # Para combinar um conjunto de números em um vetor, use a função c()
8 v - c(173,12,1.12312,-93)
9 print(v)
10 [1] 173.00000 12.00000 1.12312 -93.0000000
11
12 # Em R, c se refere a função primitiva c(), porém você pode redefinitr c
13 c - 3
14 c
15 [1] 3
16 # mesmo após redefinir c, você pode combinar números
17 v - c(3,2,1)
18 v
19 [1] 3 2 1
22 / 110

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
23 / 110

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
11 # Outra forma de concaternar ...
12 u - paste(abc,de,f,sep=.) # usa . como separador
13 u
14 [1] abc.de.f
15 # ... e separar
16 strsplit(u,)
17 [[1]]
18 [1] a b c . d e . f
24 / 110

Conteúdo
Linguagem R
Sintaxe do R
Símbolos
Vetores
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
25 / 110

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
11 # Se necessário (!?), defina um símbolo assim:
12 1+2=3 - hello
13 1+2=3
14 [1] hello
15
16 # Nem todas as palavras são símbolos (palavras reservadas)
17 # -- if, else, repeat, while, function, for, in, next, break
18 # -- TRUE, FALSE, NULL, Inf, NaN, NA
19 # -- ...
25 / 110

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)}
8
9 # Visualizando o conteúdo da função desvio padrão
10 sd
11 function (x, na.rm = FALSE)
12 {
13 if (is.matrix(x))
14 apply(x, 2, sd, na.rm = na.rm)
15 else if (is.vector(x))
16 sqrt(var(x, na.rm = na.rm))
17 else if (is.data.frame(x))
18 sapply(x, sd, na.rm = na.rm)
19 else sqrt(var(as.vector(x), na.rm = na.rm))
20 }
26 / 110

Conteúdo
Linguagem R
Sintaxe do R
Símbolos
Vetores
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
27 / 110

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
9 # Listando os elementos no espaço de trabalho
10 ls()
11 [1] x y z
12
13 # Apagando alguns deles
14 rm(x,y)
15
16 # Listando novamente
17 ls()
18 [1] z
19
20 rm(list=ls()) # apaga tudo
27 / 110

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
8 # o mesmo vale para divisão
9 1 / c(1, 2, 3, 4, 5)
10 [1] 1.0000000 0.5000000 0.3333333 0.2500000 0.2000000
11
12 # no caso abaixo, a menor sequência tem tamanho 2
13 c(1, 2, 3, 4) + c(10, 100)
14 [1] 11 102 13 104
15
16 # a primeira sequência não émúltipla da segunda: 5 não émútiplo de 2
17 c(1, 2, 3, 4, 5) + c(10, 100)
18 [1] 11 102 13 104 15
19 Mensagens de aviso perdidas:
20 In c(1, 2, 3, 4, 5) + c(10, 100) :
21 comprimento do objeto maior não émúltiplo do comprimento do objeto menor
28 / 110

Vetores
1 # Em R podemos entrar com expressões de caracteres
2 Hello world.
3 [1] Hello world.
4
5 # Um vetor de caracteres de comprimento 3
6 c(Hello world, Hello R interpreter)
7 [1] Hello world
8 Hello R interpreter
29 / 110

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
11
12 # A operação abaixo retorna um vetor lógico
13 b%%3==0
14 [1] FALSE FALSE TRUE FALSE FALSE TRUE FALSE FALSE TRUE FALSE
15
16 # Elementos de b congruentes de 0 (mod 3)
17 b[b%%3==0]
18 [1] 3 6 9
19 #
20 b[c(2,6,9)]
21 [1] 2 6 9
30 / 110

Conteúdo
Linguagem R
Sintaxe do R
Símbolos
Vetores
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
31 / 110

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
10
11 # O mesmo vale para listas
12 l=list(p=21,k=c(1,2,3),z=NaN, f=function(a){return(a^2)})
13 for(x in l) print(x)
14 [1] 21
15 [1] 1 2 3
16 [1] NaN
17 function(a){return(a^2)}
31 / 110

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 +}
14
15 # Duas formas de representar a mesma operação
16 x - 1
17 y - if(x == 2) x else x+1
18 y
19 [1] 2
20 if(x == 2) y - x else y - x+1
21 y
22 [1] 2
32 / 110

Conteúdo
Linguagem R
Sintaxe do R
Símbolos
Vetores
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
33 / 110

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
7 # Alguns argumentos podem ser especificados pelo nome
8 log(x=64, base=4)
9 [1] 3
10
11 # O comando seq() possui vários argumento opcionais
12 seq(from=0,to=10,by=0.8) # intervalo
13 [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
14 seq(from=0,to=10,length=20) # comprimento
15 [1] 0.0000000 0.5263158 1.0526316 1.5789474 2.1052632 2.6315789
16 [7] 3.1578947 3.6842105 4.2105263 4.7368421 5.2631579 5.7894737
17 [13] 6.3157895 6.8421053 7.3684211 7.8947368 8.4210526 8.9473684
18 [19] 9.4736842 10.000000
33 / 110

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
34 / 110

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
35 / 110

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)
36 / 110

Conteúdo
Linguagem R
Sintaxe do R
Símbolos
Vetores
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
37 / 110

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
5 # adição e multiplicação
6 2 * x + 3
7 [1] 1 3 5 7 9 11 13
8 # exponenciação
9 x^3
10 [1] -1 0 1 8 27 64 125
11
12 # resto da divisão (módulo)
13 x %% 2 #-- éperiódico
14 [1] 1 0 1 0 1 0 1
15
16 # divisão inteira
17 x %/% 5 # x %/% 5 == floor(x/5)
18 [1] -1 0 0 0 0 0 1
37 / 110

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
4 %myop% - function(a, b) {2*a + b}
5 1 %myop% 1
6 [1] 3
7 1 %myop% 2
8 [1] 4
9
10 c(1,2,3,4,5) %myop% 2
11 [1] 4 6 8 10 12
12
13 # Atribuição éum operador
14 x - c(1,2,3,4,5)
15
16 # O negativo também éum operador
17 -7
18 [1] -7
19
20 # O ponto de interrogação ? (help) também éum operador
21 ??
38 / 110

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

Conteúdo
Linguagem R
Sintaxe do R
Símbolos
Vetores
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
40 / 110

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

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
41 / 110

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
14
15 # Acessando uma fatia das linhas
16 a[1:2,]
17 [,1] [,2] [,3] [,4]
18 [1,] 1 4 7 10
19 [2,] 2 5 8 11
42 / 110

Estruturas de dados
Arrays
1 # Relembrando do array a mais uma vez
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 # Acessando um conjunto não contíguo colunas
9 a[,c(1,3)] # mostra somente as colunas 1 e 3
10 [,1] [,2]
11 [1,] 1 7
12 [2,] 2 8
13 [3,] 3 9
14
15 # O sinal negativo exclui linhas ou colunas
16 a[-c(1,3),] # exclui linhas 1 e 3
17 [1] 2 5 8 11
18 a[-2,-c(1,4)] # exclui linha 2 e colunas 1 e 4
19 [,1] [,2]
20 [1,] 4 7
21 [2,] 6 9
43 / 110

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
14
15 # O preencimento por linhas também épossível
16 matrix(1:6,nrow=2, byrow=TRUE)
17 [,1] [,2] [,3]
18 [1,] 1 2 3
19 [2,] 4 5 6
44 / 110

Estruturas de dados
Arrays
1 # Uma outra forma de criar uma matriz éusando as funções
2 # -- rbind()
3 m - rbind(c(1,4),c(2,-3))
4 m
5 [,1] [,2]
6 [1,] 1 4
7 [2,] 2 -3
8
9 # -- cbind()
10 n - cbind(c(1,4),c(2,-3))
11 n
12 [,1] [,2]
13 [1,] 1 2
14 [2,] 4 -3
15
16 # --diag()
17 diag(2)
18 [,1] [,2]
19 [1,] 1 0
20 [2,] 0 1
45 / 110

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
13
14 # -- produto matricial
15 m % * % n
16 [,1] [,2]
17 [1,] 17 -10
18 [2,] -10 13
46 / 110

Estruturas de dados
Arrays
Atenção!
1 # O R pode operar com arrays de diferentes tamanhos, por conta 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
9 # Aparentemente, a operação não faria sentido
10 x+c(1,2)
11 [,1] [,2]
12 [1,] 2 6
13 [2,] 4 6
14 [3,] 4 8
15
16 # Vamos vamos fazer algumas considerações...
47 / 110

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
7
8 # Observe a construção da matrix y, com c(1,2) repetido nas colunas
9 y=matrix(c(1,2,1,2,1,2),ncol=2)
10 y
11 [,1] [,2]
12 [1,] 1 2
13 [2,] 2 1
14 [3,] 1 2
15 x + y
16 [,1] [,2]
17 [1,] 2 6
18 [2,] 4 6
19 [3,] 4 8
48 / 110

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
17
18 # Acessando um dos elementos
19 w[1,1,1]
20 [1] 1
49 / 110

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
7 $raio
8 [1] 8.25
9
10 # Os objetos podem ser acessados de várias formas
11 e$elemento
12 [1] esfera
13 e[2]
14 $raio
15 [1] 8.25
16
17 e[[2]]
18 [1] 8.25
50 / 110

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
51 / 110

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)
5
6 # As informações estão armazenadas em vetores
7 cidade
8 [1] São Paulo Rio de Janeiro Salvador Brasília
9 [5] Fortaleza Belo Horizonte Manaus
10 estado
11 [1] SP RJ BA DF CE MG AM
12 pop
13 [1] 11376685 6390290 2710698 2648532 2500194 2395785 1861838
52 / 110

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
53 / 110

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
15 #
16 top6pop$pop 2.7e6 # cidades com mais de 2.7 mi hab
17 [1] TRUE TRUE TRUE FALSE FALSE FALSE FALSE
18 #
19 top6pop$pop[top6pop$pop2.7e6] # populações maiores que 2.7 mi hab
20 [1] 11376685 6390290 2710698
54 / 110

Conteúdo
Linguagem R
Sintaxe do R
Símbolos
Vetores
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
55 / 110

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
55 / 110

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
56 / 110

Objetos e Classes
Modelos e fórmulas
Vamos analisar o seguinte exemplo
1 # Conjunto de 20 pontos com ruído que segue uma distribuição normal
2 set.seed(2)
3 x = seq(from=0,to=5,length=20)
4 y = 2*x - 3 + rnorm(20) # rnorm(): dist. 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
13 # lm() constroi um modelo y~x e atribui a variável xy.lm
14 # -- y : variável dependente
15 # -- x : variável independente
16 xy.lm = lm(formula=y~x, data=xy)
57 / 110

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)
58 / 110

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

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')
60 / 110

Conteúdo
Linguagem R
Sintaxe do R
Símbolos
Vetores
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
61 / 110

Gráficos
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
61 / 110

Gráﬁcos
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)
62 / 110

Gráﬁcos
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)
63 / 110

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

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

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

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

Gráﬁcos
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)
68 / 110

Conteúdo
Linguagem R
Sintaxe do R
Símbolos
Vetores
Funções
Operadores
Estruturas de dados
Objetos e Classes
Gráﬁcos
69 / 110

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
13 Use data(package = .packages(all.available = TRUE))
14 to list the data sets in all *available* packages.
69 / 110

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
9
10 # Operando com os dados
11 class(trees)
12 [1] data.frame
13 mean(trees)
14 Girth Height Volume
15 13.24839 76.00000 30.17097
16 str(trees) # mostra informações sobre a estrututa do objeto
17 'data.frame': 31 obs. of 3 variables:
18 $ Girth : num 8.3 8.6 8.8 10.5 10.7 10.8 11 11 11.1 11.2 ...
19 $ Height: num 70 65 63 72 81 83 66 75 80 75 ...
20 $ Volume: num 10.3 10.3 10.2 16.4 18.8 19.7 15.6 18.2 22.6 19.9 ...
70 / 110

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 [25] 1260 1220 1030 1100 774 840 874 694 940 833 701 916
11 [37] 692 1020 1050 969 831 726 456 824 702 1120 1100 832
12 [49] 764 821 768 845 864 862 698 845 744 796 1040 759
13 [61] 781 865 845 944 984 897 822 1010 771 676 649 846
14 [73] 812 742 801 1040 860 874 848 890 744 749 838 1050
15 [85] 918 986 797 923 975 815 1020 906 901 1170 912 746
16 [97] 919 718 714 740
17 str(Nile)
18 Time-Series [1:100] from 1871 to 1970: 1120 1160 963 1210 1160 1160 813 1230 1370 ←
1140 ...
19 class(Nile) # objeto time series (série temporal)
20 [1] ts
71 / 110

Pacotes
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, bibliotecas em C e
classes em Java
Tipicamente, todas as funções em um pacote estão relacionadas
entre si
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
72 / 110

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
73 / 110

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

Conteúdo
Análise de Casos
Ajuste de Curvas
75 / 110

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
75 / 110

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)
76 / 110

Conteúdo
Análise de Casos
Ajuste de Curvas
78 / 110

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
78 / 110

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

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,
3 ylab=Vazão, las=3)
4 text(bp, vaz.m, label=round(vaz.m, 0), pos=3,srt=90, cex=0.8, offset=1.5)
5 title(Médias mensais das vazões de Furnas)
6 box()
80 / 110

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

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')
6 rug(vaz.t, col='red')
82 / 110

Conteúdo
Análise de Casos
Ajuste de Curvas
83 / 110

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/
83 / 110

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)
13
14 View(soja) # visualização dos dados
15
16 # Algumas informações sobre os dados
17 class(soja) # classe do objeto
18 names(soja) # nomes das colunas
19 dim(soja) # dimensões
20 str(soja) # estrutura
21 head(soja) # cabeçalho
22 soja # imprime todos os registros
84 / 110

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
85 / 110

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 26.36 16.08 20.99
14 [46] 14.26 23.71 22.76 22.46 22.97 15.54 18.48 25.54 30.29 30.64 17.26 20.51
15 [61] 10.30 16.28 23.61 29.66 23.34 14.41 17.24 29.08 29.52 27.98 17.56 20.05
16
17 soja$potassio # a variável potassio também écategórica, mas foi lida como numérica
18 [1] 0 30 60 120 180 0 30 60 120 180 0 30 60 120 180 0 30 60
19 [24] 120 180 0 30 60 120 180 0 30 60 120 180 0 30 60 120 180 0
20 [47] 30 60 120 180 0 30 60 120 180 0 30 60 120 180 0 30 60 120
21 [70] 180 0 30 60 120 180
86 / 110

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
87 / 110

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
16 0 13.520 15.712 16.090
17 30 20.334 22.570 20.988
18 60 23.926 28.692 29.828
19 120 25.308 29.786 33.438
20 180 25.390 28.760 37.146
88 / 110

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
89 / 110

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)
90 / 110

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)
91 / 110

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

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%)
93 / 110

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()
94 / 110

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()
95 / 110

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
4 xyplot(rengrao~potassio, groups=agua, data=soja)
5 xyplot(rengrao~potassio, groups=agua, data=soja, type=c(p,a))
6 xyplot(rengrao~potassio|agua, data=soja, type=c(p,a))
7 xyplot(rengrao~potassio|agua, data=soja, type=c(p,smooth))
96 / 110

Conteúdo
Análise de Casos
Ajuste de Curvas
97 / 110

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
4 # Cria uma expressão simbólica
5 f = expression(cos(x) + x * sin(x))
6 class(f)
7 [1] expression
8
9 # Avalia a expressão, mas x ainda não exite...
10 eval(c)
11 Error in eval(expr, envir, enclos) : object 'x' not found
12
13 # Repetindo, mas agora com a criação de x
14 x=seq(0,pi,length=20)
15 eval(f)
16 [1] 1.00000000 1.01357652 1.05319340 1.11556315 1.19537338 1.28553021
17 [7] 1.37748586 1.46163791 1.52778475 1.56561949 1.56524303 1.51767600
18 [13] 1.41534884 1.25255020 1.02581462 0.73423276 0.37966969 -0.03311993
19 [19] -0.49648737 -1.00000000
97 / 110

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

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
7 # Para derivadas de ordem superior, definimos a função
8 DD - function(expr,name, order = 1) {
9 if(order 1) stop('order' must be = 1)
10 if(order == 1) D(expr,name)
11 else DD(D(expr, name), name, order - 1)
12 }
13
14 DD(f,x,1)
15 sin(x) + x * cos(x) - sin(x)
16
17 DD(f,x,2)
18 cos(x) + (cos(x) - x * sin(x)) - cos(x)
19
20 DD(f,x,4)
21 -(cos(x) + (cos(x) + (cos(x) - x * sin(x))) + cos(x) - cos(x))
99 / 110

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
100 / 110

Conteúdo
101 / 110

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)
101 / 110

Conteúdo
102 / 110

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 )
102 / 110

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 }
103 / 110

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
4 integer n
5 double precision x(n)
6 integer i
7
8 do i = 1, n
9 x(i) = x(i) ** 2
10 enddo
11
12 end
104 / 110

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
Se a compilação funcionar corretamente, serão gerados os arquivos
pot2c.so e pot2f.so
105 / 110

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
106 / 110

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
107 / 110

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
108 / 110

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
109 / 110

Mini R

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Mini R

Mini R