Landeiro Et Al 2013 - Introdução Ao Uso de R

Landeiro, Zucco, Menezes e Oliveira-Santos, 2010
Introdução ao uso do programa R

The R Project for Statistical Computing
 O R é um software livre para computação estatística e construção de gráficos.

 Plataformas UNIX, Windows e MacOS.
 Para baixar o R vá ao Web site do R www.r-project.org
 Clique em CRAN
 Escolha o espelho de sua preferência (CRAN mirrors), existem 5 no Brasil
 Clique em Windows 95 or later
 Clique em base e salve o arquivo do R para Windows. Depois é só executar o arquivo .
Última atualização
24 de junho de 2013
O criador deste material é Victor Lemes Landeiro (INPA/ Coordenação de Pesquisas Ecológicas) -
vllandeiro@gmail.com
1
Esta versão foi modificada por

L. Gustavo R. Oliveira-Santos (Doutor em Ecologia pela UFRJ) – gu_tapirus@hotmail.com
Carlos André Zucco (Doutorando do PPG Ecologia da UFRJ) – cazucco@hotmail.com
Jorge F. S. Menezes (Graduando da Biologia da UFRJ) – jorgefernandosaraiva@gmail.com
Dissemine e reproduza à vontade – referencie aos autores
2
CONTEÚDO
Para quê aprender a usar o R ......................................................................................................... 5
Nota sobre o uso desta apostila: ..................................................................................................... 6
DIA 1 – PRIMEIRO CONTATO ....................................................................................................... 7
A cara do R e algumas informações básicas: ................................................................................. 7
A sintaxe básica dos comandos de R ......................................................................................... 8
O workspace e o working directory do R (área de trabalho). ...................................................... 8
Pacotes do R ............................................................................................................................... 9
Como usar um pacote do R .................................................................................................... 9
Como citar o R, ou um pacote do R em publicações .............................................................. 9
Usando o R .................................................................................................................................... 10
Demonstrações ......................................................................................................................... 10
O R como calculadora (operadores matemáticos simples) ...................................................... 10
Funções matemáticas do R ....................................................................................................... 11
Acessar o menu de ajuda do R (HELP!!!!) ................................................................................ 12
O help.search (para quando se está bem perdido) ............................................................... 12
Objetos do R (O que são?):....................................................................................................... 13
Como criar objetos .................................................................................................................... 13
Criar vetores com valores numéricos .................................................................................... 13
Criar vetores com caracteres (letras, variáveis categóricas). ............................................... 14
Criar matrizes ........................................................................................................................ 14
Operações com objetos............................................................................................................. 14
Acessar valores de elementos de um objeto [colchetes] .......................................................... 15
Transformar dados .................................................................................................................... 15
Listar e remover objetos salvos ................................................................................................. 16
Gerar Dados .................................................................................................................................. 16
Gerar sequências ...................................................................................................................... 16
: (dois pontos) ........................................................................................................................ 16
seq(from,to,by) ...................................................................................................................... 16
Repetições ................................................................................................................................. 17
rep(x,vezes) ........................................................................................................................... 17
Dados aleatórios ........................................................................................................................ 17
runif(n,min,max) – para distribuições uniformes ................................................................... 17
rnorm(n,mean,sd) – para distribuições normais .................................................................... 17
Tirar amostras aleatórias ........................................................................................................... 18
sample(objeto,size,replace) .................................................................................................. 18
Ordenar e a atribuir postos (ranks) aos dados .......................................................................... 18
sort ......................................................................................................................................... 18
order ...................................................................................................................................... 19
rank ........................................................................................................................................ 19
Exercícios com operações básicas ............................................................................................... 19
Dia 2 – Usando o script e aprendendo a fazer gráficos ................................................................ 21
Usar o script do R para digitar os comandos ............................................................................ 21
Exercícios com o script do R ..................................................................................................... 22
Gráficos do R................................................................................................................................. 22
3
Gráficos de barras – barplot(objeto) .......................................................................................... 22

Histogramas – hist(objeto,breaks) ............................................................................................. 22
Gráficos de pizza – pie(objeto) .................................................................................................. 23
Gráfico de pontos – plot(x,y) ..................................................................................................... 23
Gráficos com variáveis numéricas ........................................................................................ 23
Gráficos com variáveis explanatórias categóricas. ............................................................... 23
Alterando a aparência (parâmetros do gráfico) ......................................................................... 24
Adicionando linhas a um gráfico de pontos .......................................................................... 25
Adicionar mais pontos ao gráfico .......................................................................................... 26
Inserir texto em gráficos ........................................................................................................ 26
Dividir a janela dos gráficos....................................................................................................... 27
Salvar os gráficos ...................................................................................................................... 27
Exercícios com gráficos ................................................................................................................ 28
DIA 3 - Importar conjunto de dados para o R ............................................................................... 29
Importar arquivos de outros programas .................................................................................... 30
Procurar os dados dentro do computador ................................................................................. 30
Transformar vetores em matrizes e data frames ...................................................................... 30
Acessar partes da tabela de dados (matrizes ou dataframes).................................................. 31
Operações usando dataframes ................................................................................................. 32
Ordenar a tabela.................................................................................................................... 32
Calcular a média de uma linha ou de uma coluna ................................................................ 32
Soma de todas as linhas ou colunas..................................................................................... 33
Medias de todas as linhas ou colunas ................................................................................. 33
Operações em sub-conjuntos – família de comandos apply .................................................... 33
Exemplo com dados reais ............................................................................................................. 35
As funções aggregate e by ........................................................................................................ 36
Transpor uma tabela de dados ................................................................................................. 37
Comandos de lógica ...................................................................................................................... 37
Opções para manipular conjunto de dados. .............................................................................. 37
which(teste lógico) ................................................................................................................. 38
Ifelse(teste lógico ,valor se TRUE, valor se FALSE) ............................................................. 38
Exercícios com dataframes e comandos de lógica: ...................................................................... 39
DIA 4 – Aprender a criar Funções (programação) ........................................................................ 40
Sintaxe para escrever funções .................................................................................................. 40
Comando function ................................................................................................................. 40
Comando for() ................................................................................................................... 41
Exercícios .............................................................................................................................. 43
Brincando com funções ............................................................................................................. 43
Índice de Diversidade de Shannon ....................................................................................... 43
Índice de Similaridade de Jaccard. ....................................................................................... 44
Índice de similaridade de Bray-Curtis.................................................................................... 45
Exercícios de criar funções: .......................................................................................................... 46
DIA 5 – Diferença entre criar uma função e escrever um código ................................................. 47
Criar uma função para fazer um gráfico composto (genérico) ...................................................... 48
Script da funcão ..................................................................................................................... 48
Exemplo de como usar a função genérico ............................................................................ 50
Referências ................................................................................................................................... 51
4
PARA QUÊ APRENDER A USAR O R

O R é, segundo a definição de seus criadores, “uma linguagem para programação estatística, que
aliada a um ambiente próprio permite a manipulação de dados, realização de cálculos, simulações e
procedimentos estatística e produção de gráficos”. Foi desenvolvido na década de 90, na forma de
software livre, a partir da linguagem S (S-plus nas versões mais modernas) que por ter desenvolvimento
comercial não era de acesso livre e gratuito.
Muitas pessoas enxergam o R como um programa estatístico, análogo a tantas outras plataformas
já conhecidas como o SPPS, Stata, Statística ou Systat. Na verdade, o R é um ambiente que abriga uma
verdadeira linguagem computacional. Isso significa que sua potencialidade é inteiramente flexível,
podendo o usuário desenvolver novas funções extrapolando de longe a gama de ferramentas já
disponível nos inúmeros pacotes prontos.
O caráter flexível da linguagem tornou o R uma das mais potentes ferramentas para análises de
dados em ciência. A compatibilidade do ambiente com outras linguagens de aplicação distintas expande
as possibilidades do R exponencialmente. Dessa maneira, o R permite criar rotinas de procedimentos
muito além da análise estatística.
Um exemplo bastante ilustrativo do potencial da linguagem pode ser visualizado no site
www.congressoaberto.com.br, desenvolvido pelos cientistas políticos brasileiros Eduardo Leoni e Cesar
Zucco Jr. Esse portal utiliza dados oficiais providos de sites do governo para gerar um panorama da
atuação de parlamentares e partidos brasileiros na legislatura. Todos os procedimentos incluindo a
consulta regular das fontes de dados, a anexação das novas informações ao banco de dados e a
execução e postagem online da análise estatística atualizada no site são programadas de dentro do R.
Como o R dispõe de um pacote que cria interface com a tradicional linguagem de programação web
PERL, os autores puderam programar inclusive o design do site de dentro do ambiente R. Desde
meados de 2009, quando criaram este projeto, o site atualiza o próprio banco de dados com resultados
das votações do Congresso Brasileiro e roda as análises novamente todos os dias sem necessidade dos
autores intervir no processo.
Embora não se espera que todo mundo vire um programador avançado, o simples fato do R não
impor limites ao usuário é, por si só, um forte argumento em favor do seu uso. Você não precisará
recorrer a inúmeros softwares diferentes para executar procedimentos novos, pois as ferramentas
distribuídas no portal do R-project (R Development Core Team 2010) cobrem praticamente tudo que
você pode imaginar, E se algo ainda não estiver desenvolvido, você mesmo pode criar.
O R se desenvolve através do trabalho difuso de inúmeros programadores. Após serem testados
pelo R Development Core Team para garantir que as funções fazem mesmo o que se propõem a fazer é
que as mesmas são disponibilizadas ao público no portal do R na forma de pacotes. Muito do que é
desenvolvido nasce justamente da parceria de pesquisadores e programadores com diferentes
habilidades (e conhecimento). Em geral, o que se observa é que dentre a comunidade de usuários do R,
há uma disposição coletiva em cooperar para elaboração de novas formas de análise. Para se ter uma
noção da profusão de material existente, atualmente (2011) existe mais de 2800 pacotes disponíveis no
portal do R.
Por ser software livre e gratuito o uso do R se espalhou rapidamente entre os grupos de pesquisa
em todo mundo (fato facilmente verificável através do número de artigos científicos cujas análises são
feitas no programa). Com a crescente comunidade de usuário, o avanço das técnicas desenvolvidas para
essa base ocorre numa velocidade maior do que a de qualquer outra ferramenta comercialmente
desenvolvida. Alain Zuur e companheiros, autores de quatro livros populares em análise de dados
ecológicos optaram pelo uso do R em seus livros por causa da gratuidade e da funcionalidade do
programa (http://www.highstat.com/). Há um comentário de Jonathan Baron em Burns (2006) bastante
interessante:
5
“Outro ponto que eu repetidamente apresento aos meus estudantes é que o R é gratuito e vai
continuar a existir. Nada pode fazê-lo sumir. Uma vez aprendido, você não será mais sujeito a mudanças
de preços (por exemplo de zero quanto estudante, pois você usa a cópia de seu orientador, à várias
centenas de dólares ou mais quando você sai do laboratório). Você pode levá-lo com você aonde você
vá. O investimento no aprendizado, nesse sentido tem um retorno garantido no longo prazo.”
Habilidades em delineamento amostral e estatística são chave para todo ecólogo. Para Nicholas J.
Gotelli, famoso por seus livros em ecologia de comunidades e estatística, aprender R ou Delphis (outra
linguagem de programação estatística) é um dos principais conselhos dados aos interessados em
trabalhar em seu laboratório (http://www.uvm.edu/~ngotelli/GradAdvice.html).
Tantas possibilidades e ao mesmo tempo nenhuma delas prontamente acessível através de
interface amigável que caracteriza a computação moderna, torna o primeiro contato com o R às vezes
traumatizante e o aprendizado inicial quase sempre penoso. Esperamos ao final deste curso, convencer
a maioria dos estudantes que a necessidade de aprender programação não é um preciosismo de quem
tem um gosto pelo assunto e quebrar a resistência inicial dos novos usuários ao R, fazendo-os se sentir
à vontade para continuar aprendendo por conta própria.
NOTA SOBRE O USO DESTA APOSTILA:

O objetivo desta apostila é fazer uma breve introdução ao uso do programa R (R Development Core
Team 2010). Seu intuito não é ensinar estatística, embora apresente alguns exemplos de programação
de procedimentos estatísticos. Ela tem a sua organização planejada para um módulo de 5 dias em
linguagem e um módulo adicional de 3 dias para procedimentos estatísticos mais usuais.
O ideal para aprender a usar o R é "usá-lo!". Então, a melhor forma de se familiarizar com os
comandos do R é ler um texto introdutório (como esta apostila) e ao mesmo tempo ir digitando os
comandos no R e observando os resultados, gráficos, etc. Apenas ler esta apostila talvez não o ajude a
fazer progressos no seu aprendizado do R, acompanhe-a fazendo os cálculos no R.
Ler os manuais disponíveis na página do R como o "An introduction to R" (Venable et al 2010,
disponível para download) que vem com o R e o "Simple R" (Verzani 2002, disponível para download),
pode ser de grande ajuda no começo. Outro manual bem curto (49 páginas) e fácil de entender é o “The
R Guide” .(Owen, 2007, disponível para download). Na página do R também existem 4 manuais em
português, caso não goste de ler em inglês.
Nesta apostila as notas e explicações estão em fonte arial, os comandos do R estão em fonte
Courier New. Os resultados dos comandos não aparecem na apostila, vocês devem conferir o
resultado no R. Portanto, use os comandos em Courier New para ir acompanhando a apostila no R.
6
DIA 1 – PRIMEIRO CONTATO
A CARA DO R E ALGUMAS INFORMAÇÕES BÁSICAS:

Por ser software livre e não um produto comercial, o R não foi desenvolvido com uma interface
amigável cheia de comandos prontos em menus e botões para clicar. Para usar o R é necessário
conhecer e digitar comandos. Alguns usuários acostumados com outros programas carregados de
opções de clique-clique poderão sentir grande dificuldade, mas na medida em que utilizam o programa,
(boa parte deles) tendem a preferir o mecanismo de comandos, pois é mais flexível e com mais recursos.
Usuários acostumados com programação em outras plataformas (Systat, SAS, SPSS ou Minitab por
exemplo) tendem a se adaptar mais facilmente.
Há, de fato, alguns módulos de interface com clique-clique para o R, entre os quais a interface
gráfica para estatística Básica R-commander (Fox, 2005) e o Tinn-R, projeto coordenado pelo brasileiro
José Cláudio Faria. O Tinn é originalmente um editor de texto destinado a substituir o Notepad do
Windows. A versão Tinn-R é uma extensão destinada a controlar o R e servir como um editor de scripts
de comandos que torna a leitura de scripts mais agradável. Nós acreditamos que a melhor maneira de
aprender o R é evitando as alternativas de clique-clique como o R-commander que substituem passos de
programação por botões. Esse não é o caso do Tinn-R que consideramos um companheiro útil para
programadores.
Nós iremos começar a apostila apenas digitando comandos (i.e. "escrevendo códigos") e conforme
aumenta a familiaridade com a linguagem veremos como criar e escrever nossas próprias funções.
O R possui uma janela com algumas poucas opções para você se divertir clicando (Figura 1). As
análises feitas no R são digitadas diretamente na linha de comandos (i.e. você tem controle total sobre o
que será feito). Na "linha de comandos", você irá digitar os comandos e funções que deseja usar. O sinal
> (sinal de maior) indica o prompt e quer dizer que o R está pronto para receber comandos. Em alguns
casos um sinal de + aparecerá no lugar do prompt, isso indica que ainda estão faltando comandos para
terminar (ou que você errou alguma coisa na linha anterior). Se tiver errado pressione Esc para retornar
ao prompt normal >. Note que na apostila, o começo de cada linha com os comandos do R possui um
sinal do prompt, >, e em alguns casos um sinal de +. NÃO DIGITE ESSES SINAIS!!
Os comandos que você digita aparecem em vermelho e o output do R aparece em azul (veja a
Figura 1). Após digitar os comandos tecle Enter para que eles sejam executados!
Figura 1 – Layout da interface do R

ATENÇÃO!!!
 O R é case-sensitive (i.e. diferencia letras
maiúsculas de minúsculas), portanto A é diferente
de a.
 Não é recomendado o uso de acentos em
palavras. Na verdade deve-se evitar uso de
acentos em programação. As vezes eles geram
incompabilidade entre softwares quando se
pretende fazer exportações.
 No R o sinal # (jogo-da-velha) é usado para
inserir comentários; é o mesmo que dizer ao
programa: "não leia nada que estiver a direita do #
na mesma linha”. No decorrer da apostila este
recurso foi usado extensivamente
7
A sintaxe básica dos comandos de R

A sintaxe se refere à estrutura da escrita dos comandos. Ela é regular para todos os comandos:
> objetoA <- função(argumento1,argumento2,argumento3)
Esse comando genérico acima diz que o objeto A é igual ao resultado da função cujos argumentos
são 1, 2, 3. Ao longo do curso iremos aprender inúmeras funções e compreender melhor os tipos de
objetos que existem, mas algumas regras de pontuação e sintaxe não podem ser esquecidas. Por isso
leia o quadro abaixo e recorra a ele sempre que tiver dúvida ou travar no andamento de algum
comando:
 ( ) parênteses SEMPRE aparecem depois de funções contendo os argumentos

dela, ou em expressões matemáticas para definir a prioridade da ordem das
operações, como aprendemos desde cedo na escola.
 “,” virgulas são usadas para separar argumentos de uma função. O separador
de casas decimais é o ponto “.”
 Palavras sem aspas ao longo de um comando são SEMPRE entendidas como
um objeto ou função. Se você deseja inserir uma palavra ou letra como valor para
uma variável ou qualquer parte de um objeto use sempre aspas.
 [ ] colchetes SEMPRE aparecem depois de um objeto. Servem para extrair uma
parte do objeto
 { } chaves SEMPRE aparecem englobando o corpo de uma função, após o
comando function ( ){ } ou o comando for( ){ }
 <- assign equivale ao sinal de igual. Ele serve para indicar que a parte inicial
(esquerda) do comando deverá ser igual à parte final (direita). É recomendável que
o “=” seja usado apenas para informar que os argumentos da função são iguais à
um valor.
O workspace e o working directory do R (área de trabalho).

A cada vez que você abre o R ele inicia uma "área de trabalho" (workspace). Este workspace é o
ambiente onde você fará suas análises, gráficos, etc. Ao final de uma sessão de uso do R, você pode
salvar uma imagem do workspace atual que poderá ser carregado novamente numa sessão futura. A
imagem do workspace assume a forma de um arquivo .Rdata.
Outro conceito importante é o working directory. Nada mais é do que a pasta ou diretório onde seu
workspace está salvo. Assim como em qualquer outro programa de computador, é sempre importante ter
em mente a pasta onde vc salvou o arquivo desejado, No entanto para R, é recomendável salvar os
workspace’s em pastas separadas para cada projeto. Assim, não salve mais de um workspace na
mesma pasta física (working directory)!!.
Sempre que for usar o R em um trabalho, antes de tudo, crie uma pasta para este trabalho (via
Windows Explorer) e salve um workspace do R nela. Isso irá facilitar sua vida. Para este curso salve um
workspace na pasta do curso, abrindo o R, clicando em "File”>”Save workspace" e salve-o na pasta
desejada (diretório). Não é preciso nomear o arquivo ao salvar, isso é dispensável visto que sempre
haverá apenas um por pasta.
Agora vamos verificar onde está o nosso workspace. Primeiro cheque através do Windows Explorer
que um arquivo .Rdata está no seu diretório de trabalho. Segundo vamos usar um comando de dentro do
R para checar qual o diretório do arquivo que está aberto. Os comandos getwd() e setwd() servem para
8
checar e definir o working directory da sessão atual. Assim, confira digitando e veja o output que o R
retorna:
> getwd() #função sem argumentos, por isso os parênteses vazios
[1] "C:/Documents and Settings/Victor Landeiro/My Documents"
Feche o R e abra-o novamente clicando no arquivo da pasta escolhida, faça os exercícios e no final
apenas feche o R, irá aparecer uma caixa perguntando se deseja salvar o workspace, diga que sim. A
partir daqui, sempre abra o R a partir do workspace (arquivo) salvo na pasta do seu trabalho.
Pacotes do R
O R é um programa leve (ocupa pouco espaço e memória) e geralmente roda rápido, até em
computadores não muito bons. Isso porque ao instalarmos o R apenas as configurações mínimas para
seu funcionamento básico são instaladas (o pacote base). Para realizar tarefas mais complicadas pode
ser necessário instalar pacotes adicionais (packages). Um pacote bastante utilizado em ecologia é o
vegan, vegetation analysis, criado e mantido por Jari Oksanen (Oksanen et al., 2007). Para instalar um
pacote vá ao site do R (www.r-project.org), clique em CRAN, escolha o espelho e clique em packages,
uma lista com uma grande quantidade de pacotes está disponível. Clique no pacote que deseja e depois
clique em windows binary e salve o arquivo. Abra o R e clique em Packages, depois em Install
Package(s) from local zip files e selecione o arquivo do pacote que você baixou. Baixe e instale os
pacotes vegan e o pacote lattice.
O R também pode conectar-se diretamente à internet. Desta forma é possível, instalar e atualizar
pacotes sem que seja necessário acessar a página do R.
Para instalar um pacote direto do R digite, por exemplo:
> install.packages("vegan") ## É necessário estar conectado!
Durante o curso, se o seu computador não estiver ligado à internet, verifique se há uma pasta
chamada “Pacotes” no material do curso. Nós já baixamos os dois pacotes e colocamos no material
fornecido prevendo que isso poderia acontecer. Faça apenas o procedimento de instalação dos dois
pacotes recomendados.
Como usar um pacote do R

Não basta apenas instalar um pacote. Para usar o pacote instalado é necessário "rodar" o pacote
sempre que você abrir o R e quiser usar o pacote. Use a função library para rodar um pacote. Por
exemplo: Digite library(vegan) na linha de comandos do R.
> library(vegan) ## carrega a biblioteca
Após isso as funcionalidades do vegan estarão prontas para serem usadas. Sempre que abrir o R
será necessário rodar o pacote novamente.
Como citar o R, ou um pacote do R em publicações

No R existe um comando que mostra como citar o R ou um de seus pacotes. Veja como fazer
> citation()
To cite R in publications use:
R Development Core Team (2009). R: A language and environment for
statistical computing. R Foundation for Statistical Computing, Vienna,
Austria. ISBN 3-900051-07-0, URL http://www.R-project.org.
9
Veja que na parte com o nome dos autores aparece "R Development Core Team", isso está correto,
cite o R desta forma. Algumas pessoas não sabem disso e citam o R com autor Anônimo, isto tira o
crédito do time.
Para citar um pacote, por exemplo o vegan, basta colocar o nome do pacote entre aspas.
> citation("vegan") Lembre das aspas
To cite package ‘vegan’ in publications use:
Jari Oksanen, F. Guillaume Blanchet, Roeland Kindt, Pierre Legendre, R.
B. O'Hara, Gavin L. Simpson, Peter Solymos, M. Henry H. Stevens and Helene
Wagner (2010). vegan: Community Ecology Package. R package version 1.17-2.
http://CRAN.R-project.org/package=vegan
USANDO O R
Demonstrações
Algumas funções do R possuem demonstrações de uso. Estas demonstrações podem ser vistas
usando a função demo(). Vamos ver algumas demonstrações de gráficos que podem ser feitos no R.
Digite o seguinte na linha de comandos:
> demo(graphics)
Aparecerá uma mensagem pedindo que tecle Enter para prosseguir, depois vá clicando na janela
dos gráficos para ver as opções.
> demo(persp)
> demo(image)
O R como calculadora (operadores matemáticos simples)

O uso mais básico do R é usá-lo como calculadora. Os operadores são: + para soma, -
subtração, * multiplicação, / divisão, ^ exponenciação. Tente o seguinte na linha de comandos do R:
> 2+2
> 2*2 Observação!
Em cálculo matricial, cercar
> 2/2 operadores matemáticos por %:
> 2-2 > matrizA %+% matrizB
> 2^2
Use parênteses para separar partes dos cálculos, por exemplo, para fazer a conta 4+16 dividido por
4 elevado ao quadrado:
> ((4+16)/4)^2
> (4^2)+(3^2)/25
10
Funções matemáticas do R
O R tem diversas funções que podemos usar para fazer os cálculos desejados. O uso básico de
uma função, como já dito antes é função(argumentos) onde função especifica o nome da função
que iremos usar e argumentos especifica a lista de argumentos que serão avaliados, sempre
separados por vígulas quando houver mais de um argumento.
Por exemplo: sqrt é a função para calcular raiz quadrada
> sqrt(9) # Tira a raiz quadrada dos argumentos entre parênteses, no caso 9
> sqrt(3*3^2) # raiz quadrada de 27
> sqrt((3*3)^2) # raiz quadrada de 81
prod(x1,x2,x3,...,xn) é a função para multiplicação da lista de argumentos
> prod(2,2) # O mesmo que 2*2
> prod(2,2,3,4) # O mesmo que 2*2*3*4
log(x,base) é a função para calcular o logaritmo do valor x na base. Por default, a base é o
algarismo neperiano “e”, portanto:
> log(3) # log natural de 3
> log(3,10) # log de 3 na base 10
Logarítmos em base 2 e 10 possuem atalhos log2(x) e log10(x). Veja:

> log10(100)
> log2(512)
Para obter valores em módulo, podemos usar a função abs(x)
> abs(3-9) # modulo de 3-9 ou |3-9|
Para fazer o fatorial de algum número use factorial()
> factorial(4) #4 fatorial ou (4!)
11
Acessar o menu de ajuda do R (HELP!!!!)

O aprendizado mais importante do R é talvez saber usar o help. Para ver os arquivos de ajuda do R
use help(função) ou ?funcão. Por exemplo: a função para fazer anova é aov:
> help(aov)
Para usar help ou ? é preciso saber o
ou simplesmente
nome da função que se quer ajuda!!!!
>?aov
ENTENDA O HELP!!!
1 - Description - faz um resumo geral da função
2 - Usage - mostra como a função deve ser utilizada e quais argumentos podem ser especificados
3 - Arguments - explica o que é cada um dos argumentos
4 - Details - explica alguns detalhes que é preciso estar atento ao usar a função
5 - Value - mostra o que sai no output após usar a função (os resultados)
6- Note - notas sobre a função
7 - Authors - lista os autores da função (quem escreveu os códigos em R)
8 - References - referências para os métodos usados
9 - See also - mostra outras funções relacionadas que podem ser consultadas
10 - Examples - exemplos do uso da função. Copie e cole os exemplos no R para ver como
funciona
Quando for usar uma função que nunca utilizou é no help que você aprenderá a usá-la. Os tópicos
Usage e Arguments são os mais importantes, pois mostram como os argumentos devem ser inseridos
na função (Usage) e caso não saiba o que é algum desses argumentos existe uma explicação para cada
um deles (Arguments). Muitas pessoas têm dificuldade em entender o help do R e dizem que o help é
ruim. Pelo contrário, ele possui tudo que você precisa saber. Nada a mais nem nada a menos do que o
necessário. Ao longo do curso, gaste um tempo inspecionando o help das funções mais interessantes
que você for aprendendo.
O help.search (para quando se está bem perdido)

Em diversos casos nós não sabemos o nome da função que faz a análise que desejamos. Nestes
casos é possível pesquisar usando palavras chave com a função help.search() ou ??
> help.search("anova")
Para usar help ou ? é preciso saber o
Ou simplesmentes nome da função que se quer ajuda!!!!
> ??anova
Também é possível buscar ajuda na internet, no site do R, com a função RSiteSearch()
> RSiteSearch("analysis of variance") # abre uma página na internet, mas

# só funcionará se seu computador estiver conectado à internet.
12
Objetos do R (O que são?):

O R é uma linguagem baseada em objetos. Mas o que são os Objetos? Ora, são simplesmente tudo
que existe no ambiente? São conjuntos de dados (suas planilhas, variáveis, resultados de suas
estatísticas, etc) e são também suas funções seus pacotes, seus resultados de estatísticas.
Existem muitos tipos de objetos no R que só passamos a conhecê-los bem com o tempo. Por
enquanto vamos aprender os tipos básicos de objetos. Para uma leitura mais aprofundada sobre os tipos
de objetos e definições da linguagem R leia o manual "R language definition" disponível no menu
"HELP", "Manuais em PDF", "R language definition".
A. VECTOR: uma seqüência de valores do mesmo tipo, numéricos, caracteres ou lógicos. Equivale
muitas vezes a uma variável dos nossos dados. Todos os vetores tem como propriedade o
comprimento (número de valores) e o modo (tipo dos valores).
B. MATRIX: é uma generalização dos vetores, ou uma coleção de vetores em linhas e colunas,
sendo que todos os vetores dever ser do mesmo tipo. Matrizes possuem as propriedades de
dimensão e modo.
C. LIST: é um conjunto ordenado de outros objeto ( vetores, matrizes ou outros) chamados de
componentes. Os componentes não precisam ter o mesmo tipo, comprimento ou dimensão e
podem ter um nome associado a eles. Essa é a forma que a maioria das funções estatísicas
retorna os resultados.
D. DATAFRAME: é equivalente à uma matriz em que os vetores (colunas) possuem nomes e
podem ser de tipo diferentes (alguns numéricos, alguns lógicos, alguns de caracteres) . Por isso
é o tipo de objeto mais conveniente para guardar seus dados. Contudo, em termos
computacionais é relevante dizer que a dataframe é um tipo especial de lista. Isso explica porque
algumas funções rodam em matriz mas não em dataframe e vice-versa.
E. FUNCTION: as funções criadas para fazer diversos cálculos também são objetos do R, tanto
aquelas que já existem prontas nos pacotes, como aquelas que o usuário mesmo desenvolve.
Em outras palavras são objetos que executam ações e podem manipular outros objetos.
No decorrer do curso veremos exemplos de cada um destes objetos. Para uma leitura mais
detalhada sobre os tipos de objetos, recomendamos Lam (2007), Torgo (2006) e o manual "An
introduction to R" (Venables 2010). Este manual, e outros, já vem com o R, clique em help no menu do R
e em Manuais (em PDF) para abrir o arquivo.
Como criar objetos

Criar vetores com valores numéricos
A função concatenar, expressa por c(x1,x2,x3,...,xn ), é uma das mais básicas e importantes. É usada
para combinar os valores num vetor ou lista. Vamos criar um conjunto de dados que contém o número de
espécies de aves (riqueza) coletadas em 10 locais. As riquezas são 22, 28, 37, 34, 13, 24, 39, 5, 33, 32.
> aves<-c(22,28,37,34,13,24,39,5,33,32)
Relembrando: o comando <- significa assinalar (assign). Indica que tudo que vem após este
comando será salvo com o nome que vem antes. Traduzindo então, temos: "agrupe os dados entre
parênteses dentro do objeto aves que será criado".
Para ver os valores (o conteúdo de um objeto), basta digitar o nome do objeto na linha de
comandos.
> aves #chama conteúdo de aves
A função length fornece o número de observações (n) dentro do objeto.

> length(aves)
13
Criar vetores com caracteres (letras, variáveis categóricas).

Também podemos criar objetos que contêm letras ou palavras ao invés de números. Porem, as
letras ou palavras devem vir entre aspas " ".
> letras<-c("a","b","c","da","edw")
> letras #chama conteúdo de letras
> capitais<-c("Rio de Janeiro","Florianópolis","Campo Grande","Brasília")
> capitais
Crie um objeto "misto", com letras e com números. Depois chame o conteúdo do objeto. Funcionou?
Esses números realmente são números?
Já dissemos que vetores são conjuntos com elementos do mesmo tipo. Se vc criar vetores mistos o
R força a serem do mesmo tipo. É possível entender um número como caracter, mas não o contrário.
Note a presença de aspas, isso indica que os números foram convertidos em caracteres. Evite criar
vetores "mistos", a menos que tenha certeza do que está fazendo.
Criar matrizes
Para criar matrizes podemos juntar inúmeros vetores que já existem, ou usar o comando
matrix(sequência,linhas,colunas) que distribui a sequência na matriz de dimensões que você
indicou. Digamos que as riquezas de aves do exemplo anterior tivessem sido coletadas em 5 locais com
duas estações diferentes.
> aves2<-matrix(c(22,28,37,34,13,24,39,5,33,32),5,2)
> aves2
Você entendeu a sintaxe acima? Se perdeu nos parênteses e virgulas? Observe que há uma função
dentro da outra. Para entender melhor, decomponha as funções nos seus argumentos. Perceba que o
c() é apenas um argumento de matrix(). Alternativamente, poderíamos fazer a mesma coisa assim:
> aves2<-matrix(aves,5,2)
Em analogia ao comando length(x) de vetores, há o comando dim(x) para matrizes que retorna
no número de linhas e colunas do objeto. Veja:
> dim(aves2)
Operações com objetos

Podemos fazer operações aritméticas com todos os elementos dos objetos aves e aves2, criados
acima.
> max(aves) # valor máximo contido no objeto aves
> min(aves) # valor mínimo
> sum(aves) # soma dos valores de aves
> aves+2 # adiciona 2 a cada elemento
> aves2/10 # divide os elementos de aves2 por 10
> aves^2 # eleva elementos de aves ao quadrado
14
Agora vamos usar o que já sabemos para calcular a média dos dados das aves.
> n.aves<-length(aves) # número de observações (n)
> media.aves<-sum(aves)/n.aves # cálculo da média

Para ver os resultados basta digitar o nome dos objetos que você salvou
> n.aves # para ver o número de observações (n)
> media.aves # para ver a média

Você não ficará surpreso em saber que o R já tem uma função pronta para calcular a média.
> mean(aves)
Acessar valores de elementos de um objeto [colchetes]

Caso queira acessar apenas um valor do conjunto de dados, use colchetes []. Isto é possível porque
o R salva os objetos como vetores, ou seja, a seqüência na qual você incluiu os dados é preservada. Por
exemplo, vamos acessar o quinto valor do objeto aves.
> aves[5] # Qual o quinto valor de aves?
> capitais[3] # Qual o terceiro elemento de capitais?
Para acessar mais de um valor use c() dentro dos colchetes [c(1,3,...)]: para concantenar vários
elementos ao mesmo tempo:
> aves[c(5,8,10)] # acessa o quinto, oitavo e décimo valores
Para excluir um valor, use o sinal de subtração antes do elemento:

> aves[-1] # note que o valor 22, o primeiro do objeto aves, foi excluído
Caso tenha digitado um valor errado e queira corrigir o valor, especifique a posição do valor e o
novo valor. Por exemplo, o primeiro valor de aves é 22. Caso tivesse sido digitado errado (ex: deveria ser
100), basta alterarmos o valor da seguinte maneira.
> aves[1]<-100 # O primeiro valor de aves deve ser 100
> aves
> aves[1]<-22 # Vamos voltar ao valor antigo
Matrizes possuem duas dimensões e por isso precisamos especificar ambas dentro dos colchetes.
Assim a sintaxe geral é objeto[linhas,colunas]:
> aves2[3,2] # Valor na linha 3 e coluna 2
> aves2[3,] # Retorna toda linha 3
Você consegue deduzir o que é aves2[,1]???
Transformar dados
Transformações de dados são procedimentos bastante comuns antes de análises estatísticas. As
mais comumente usadas são aplicações de funções matemáticas simples sobre seus dados, como log,
raiz quadradas e arco seno.
> sqrt(aves) #Raiz quadrada dos valores de aves
> log10(aves) #log(aves) na base 10, apenas
15
> log(aves) # logaritmo natural de aves
> asin(sqrt(aves/sum(aves))) # arco seno da raiz quadrada da freq. relativa de aves
LEMBRE que para salvar os dados é preciso atribuir a função à um novo objeto (ou salvá-la como
um novo objeto). Por exemplo:
> aves.log<-log10(aves) # salva um objeto com os valores de aves em log
> aves.log # retorna o novo objeto com valores transformados
Listar e remover objetos salvos

Chegamos num ponto em que já temos uma boa quantidade de objetos salvos no nosso workspace
e não queremos nos confundir. Para listar os objetos que existem no workspace que está aberto use a
função listar com a sintaxe ls(),sem nenhum argumento mesmo.
> ls()
Para remover objetos use rm() para remover o que está entre parênteses.
> rm(aves.log)
> aves.log # você verá a mensagem:

Error: object "aves.log" not found
GERAR DADOS
Gerar sequências
: (dois pontos)
Dois pontos " : " é usado para gerar sequências simples, de um em um, por exemplo a seqüência de
1 a 10:
> 1:10 # Seq de mínimo a máximo, isto é., de 1 a 10
> 5:16
Também é possível fazer sequências simples em ordem decrescente:
> 8:1
seq(from,to,by)
A função seq(from,to,by)é usada para gerar seqüências do valor from, até o valor to de
acordo com o intervalo by especificado. Por exemplo, vamos criar uma seqüência de 1 a 10 pegando
valores de 2 em 2:
> seq(1,10,2) # tradução: “from 1 to 10, by 2”, ou “de 1 a 10, de 2 em 2”.
> seq(1,100,5) # de 1 a 100 em intervalos de 5
> seq(0.01,1,0.02) # vc conseque deduzir como será essa sequência?
16
Repetições
rep(x,vezes)
A função rep(x,vezes=n) gera repetição de x,n vezes. Digamos que vc precisa criar uma
variável de 100 elementos com todos os valores iguais a 5 e não tem paciência para digitar isso no
comando c():
> rep(5,100) # repete 5 cem vezes
Você pode gerar repetição de um valor, caracteres ou conjunto de valores e caracteres:
> rep(2,5)
> rep("a",5) # repete a letra "a" 5 vezes
> rep(1:4,3) # repete a seqüência de 1 a 4 três vezes
Note a diferença ao usar o argumento each. Veja no help dessa função que each é um argumento
cujo valor default é 1
> rep(1:4,each=3) # compare com o comando anterior
> rep(c("A","B"),5) # repete A B cinco vezes.
> rep(c("A","B"),each=5) # repete A e B cinco vezes.
> rep(c("Três","Dois","Sete","Quatro"),c(3,2,7,4)) # Veja que neste caso a

# primeira parte do comando indica as palavras que devem ser repetidas e a segunda parte
# indica quantas vezes cada palavra deve ser repetida. Para isso
Dados aleatórios
runif(n,min,max) – para distribuições uniformes
Com a sintaxe runif(n, min, max), vc cria uma sequência de n valores, com o intervalo de min
a max. O programa gera números reais conforme a especificações:
> runif(200,80,100) # 200 valores com mínimo de 80 e máximo 100
> temp<-runif(200,80,100) #Gera novamente e agora salva no objeto temp
> hist(temp) # Faz um histograma de freqüências dos valores.
rnorm(n,mean,sd) – para distribuições normais

Diferentemente da distribuição uniforme, os parâmetros que descrevem uma distribuição normal são
sua média e seu desvio padrão. Então a rnorm(n, mean, sd) gera n valores com distribuição
uniforme de m, com mean e desvio padrão sd.
> rnorm(200,0,1) # 200 valores com média 0 e desvio padrão 1
> temp2<-rnorm(200,8,10) # 200 valores com média 8 e desvio 10 salvos em temp2
> hist(temp2) # Faz um histograma de freqüências dos valores
> hist(rnorm(200,8,10)) # Os dois comandos acima reunidos em apenas um, Repita esse
# comando algumas vezes e veja se os gráficos parecem com uma distribuição normal.
17
Tirar amostras aleatórias

sample(objeto,size,replace)
O comando sample é utilizado para realizar amostras aleatórias de um conjunto de valores
predeterminados por você. A sua sintaxe é sample(x, size=y, replace = FALSE), onde x é
conjunto de dados do qual as amostras serão retiradas, size é o número de amostras e replace
refere-se ao uso de reposição (TRUE) ou não (FALSE). Lembre-se que o default é sem reposição
(replace= FALSE).
> sample(1:10,5) # tira amostras com 5 elementos do conjunto de valores entre 1 e 10
> sample(1:10,15) # erro?? Porque isso acontece

Como o replace é FALSE, a amostra de 15 é maior que o universo de 10 valores (1 a 10) portanto
não é possível retirar 15 valores sem repetir nenhum!
> sample(1:10,15,replace=TRUE) # agora sim!
Vamos criar uma moeda e "jogá-la" para ver quantas caras e quantas coroas saem em 10 jogadas.
> moeda<-c("CARA","COROA")
> sample(moeda,10) #Ops! Esqueci de colocar replace=TRUE
> sample(moeda,10,replace=TRUE) # agora sim

Agora queremos testar se essa função consegue amostrar aleatoriamente mesmo. Vamos jogar
essa moeda 100 vezes e ver quantas caras e quantas coroas temos:
> teste<-sample(moeda,100,replace=TRUE)
> table(teste) # a função table() faz uma tabela de freqüência dos valores existentes
Rode várias vezes os dois comandos acima e veja o quanto o resultado se aproxima de 1:1.
Ordenar e a atribuir postos (ranks) aos dados

Vamos criar um vetor desordenado para servir de exemplo:
> exemplo<-sample(1:100,10) # amostra de 10 valores entre 1 e 100
> exemplo # veja que os valores não estão em ordem. Talvez com muita sorte os seus
valores estejam.
[1] 94 27 89 82 24 51 2 54 37 38 # seus valores serão diferentes
sort
A função sort(obj)retorna os valores de um objeto em ordem crescente ou em ordem
decrescente.
> sort(exemplo) # para colocar em ordem crescente
[1] 2 24 27 37 38 51 54 82 89 94
> sort(exemplo,decreasing=TRUE) # para colocar em ordem decrescente

[1] 94 89 82 54 51 38 37 27 24 2
18
order ATENÇÃO!!!
A função order(objeto) retorna a posição original dos É fundamental entender o

valores de um objeto em ordem crescente, i.e., a posição do menor comando order, ele é o
valor, a posição do segundo menor valor, a posição do terceiro comando que permite ordenar
menor valor... uma planilha de dados inteira em
função de uma das suas variáveis.
> order(exemplo)
Veremos como fazer isso adiante
[1] 7 5 2 9 10 6 8 4 3 1
Note que o primeiro valor acima é 7, isso indica que se quisermos colocar o objeto "exemplo" em
ordem crescente, devemos pegar o 7º elemento, segudo do 5º, do 2º e assim por diante, até que
teremos pego todos os elementos na ordem crescente de valor. Também podemos aplicar a função para
ordem decrescente:
> order(exemplo,decreasing=TRUE)
[1] 1 3 4 8 6 10 9 2 5 7
rank
A função rank(objeto) retorna a posição dos elementos caso eles fossem ordenados:
> exemplo ## apenas para relembrar os valores do exemplo

[1] 94 27 89 82 24 51 2 54 37 38
Agora vamos ver o rank destes valores
> rank(exemplo) # Para atribuir postos (ranks) aos valores do exemplo
[1] 10 3 9 8 2 6 1 7 4 5
Veja que 94 é o maior valor do exemplo, portanto recebe o maior rank, no caso 10.
EXERCÍCIOS COM OPERAÇÕES BÁSICAS

1. Suponha que você marcou o tempo que leva para chegar a cada uma de suas parcelas no
campo. Os tempos em minutos foram: 18, 14, 14, 15, 14, 34, 16, 17, 21, 26. Passe estes valores para o
R, chame o objeto de tempo. Usando funções do R ache o tempo máximo, mínimo e o tempo médio que
você levou para chegar em suas parcelas.
1.1. Ops, o valor 34 foi um erro, ele na verdade é 15. Sem digitar tudo novamente, e usando
colchetes [ ], mude o valor e calcule novamente o tempo médio.
2. Você consegue prever o resultado dos comandos abaixo? Caso não consiga, execute os
comandos e veja o resultado:
2.1. x<-c(1,3,5,7,9)
2.2. y<-c(2,3,5,7,11,13)
2.3. x+1
2.4. b)y*2
2.5. c)length(x) e length(y)
2.6. d) x + y
2.7. e) y[3]
2.8. f) y[-3]
3. Use as funções union, intersect e setdiff para encontrar a união, o intersecto e

as diferenças entre os conjuntos A e B. Aprenda no HELP como utilizar estas funções.
A (1 2 3 4 5)
19
B (4 5 6 7)
4. Todos os anos, o trinta-réis-ártico (Sterna paradisuea), uma avezinha preta e branca, com pouco
menos de 40 centímetros, realiza um longo vôo de pólo a pólo. Durante nove meses, ele percorre 20000
quilômetros, do Circulo Polar Ártico até o limite da Antártida, e retorna, então, ao ponto de partida.
Usando a calculadora do R, em apenas uma linha de comando, calcule a velocidade média em m/s
dessa ave (assuma o mês como tendo 30 dias). (Gabarito: 1.71 m/s)
3 2 3 2
5. Calcule |2 -3 |. Módulo de 2 -3 . Faça isso em apenas uma linha de comando.
6. Suponha que você coletou na sua monografia 10 amostras em duas reservas, as 5 primeiras
amostras foram na reserva A e as 5 ultimas na reserva B. Crie um objeto do tipo vetor, chamado
"locais" que especifica apenas os rótulos das reservas onde as amostras foram coletadas.
7. Você deseja jogar na mega-sena, mas não sabe que números jogar, use a função sample do R
para escolher os seis números para você jogar. A mega-sena tem valores de 1 a 60.
8. Crie uma seqüência de valores de 1 a 30 apenas com números impares. Use a função seq().
9. Einstein disse que Deus não joga dados, mas o R joga! Simule o resultado de 25 jogadas de um
dado. Você precisará criar o objeto dado, e usar a função sample().
10.Crie um objeto com estes valores: 9 0 10 13 15 17 18 17 22 11 15 e chame-o de temp.

Calcule:
10.1. A raiz quadrada de temp
10.2. O log natural de temp. O que acontece com o segundo elemento?
10.3. O log natural dos valores de temp+1. O problema persiste?
10.4. Eleve os valores de temp ao quadrado.
Crie um objeto chamado info que contem seu nome, idade, altura, peso, email e telefone.
Feche o R: Ao fechar aparecerá um a pergunta sobre salvar ou não o Workspace, diga que sim. Abra
o R novamente e confira se seus objetos ainda estão salvos usando o comando ls().
20
DIA 2 – USANDO O SCRIPT E APRENDENDO A FAZER GRÁFICOS
Usar o script do R para digitar os comandos

Uma maneira que otimiza o uso do R e que poupa muito tempo é usar um script para digitar seus
comandos. Neste caso, os comandos não são digitados na linha de comandos e sim em um editor de
texto (R editor). Um script é um arquivo txt, onde você digita todas as análises e comandos. Com o script
você facilmente faz alterações e correções, além de salvar o script e poder refazer rapidamente suas
análises após algum tempo. Daqui em diante use o script para fazer os cálculos e exercícios da apostila.
Para criar um script clique em File no menu do R e clique em New Script. Uma janela será aberta
(veja figura abaixo). O script aparece com o nome de R Editor (editor do R) e a extensão do arquivo é .R.
Digite 3+3 no script e aperte Ctrl+R. O 3*3 será enviado para a linha de comandos do R e o
resultado aparecerá na tela. Para fazer outro comando aperte Enter e escreva outro comando na outra
linha do script (cada comando deve ser digitado em uma linha diferente). Podemos também enviar os
comandos para o R selecionando uma parte de linha ou algumas linhas com o mouse e aí digitar Ctrl+R.
Daqui em diante sempre use o script do R. Tudo ficará mais rápido! No script você também pode
inserir observações sobre o que foi feito, usando # para indicar a presença de um comentário. Por
exemplo:
> x<-sample(1:10,20,replace=TRUE) # criar um objeto chamado x, composto de 20
# valores amostrados ao acaso entre 1 e 10. O replace=TRUE indica que a amostragem foi feita
# com reposição.
> mean(x) # uso da função mean para calcular a média de x.
21
Exercícios com o script do R

1. O seu workspace está uma bagunça!!! Você deve ter um grande número de objetos os quais
você nem faz idéia do que contém. Trate de arrumar a casa, confira os objetos existentes com comando
ls()e remova todos menos o objeto aves, moeda e dado.
2. Faça alguns comandos que você já aprendeu usando um script. Por exemplo: crie objetos,
seqüências, operações e insira comentários para lembrar o que foi feito. Ao terminar salve o script. Para
salvar clique no "disquete" que aparece nos menus do R (veja figura acima), salve o script na pasta do
curso, dê o nome que quiser sempre usando a extensão .R para salvar (ex: meuScript.R) Feche o
script, mas não feche o R. Para abrir o script novamente clique em File e em Open script selecione o
script salvo para abri-lo.
GRÁFICOS DO R
Produzir gráficos de qualidade é uma ótima forma de apresentar e explorar dados. O R é
reconhecido por ter grande potencial para geração de gráficos. Você pode fazer praticamente qualquer
gráfico que imaginar, mas particularmente nesse campo as coisas podem se tornar difíceis. Os gráficos
mais comuns são os gráficos de barras, pizza e de pontos (gráfico de dispersão).
Gráficos de barras – barplot(objeto)

Para fazer gráficos de barras no R a função é barplot(objeto). Haverá uma coluna para cada
valor do objeto.
> barplot(sample(10:100,10))
Se o objeto for uma matriz, pode-se fazer um gráfico com blocos de barras agrupados,
correspondendo a cada coluna da matriz. Para tanto use o parâmetro beside=TRUE
> aves2<-sort(aves) # cria aves2 com os dados de aves ordenados

> barplot(matrix(c(aves,aves2),10,2),beside=TRUE)
Se você tiver dificuldade de entender o comando acima, apenas decomponha. Peça para rodar as
funções da mais interna para a mais externa. Por exemplo, rode a função c( ), depois matrix( ), depois
barplot( ).
O R tem uma sessão de exemplos que nos permite ter uma noção de seu potencial:
> example(barplot) ## clique na janela do gráfico para ir passando os exemplos.
Histogramas – hist(objeto,breaks)
Nós já vimos este tipo de gráfico, mas não custa relembrar. O histograma, é diferente do gráfico de
barras pois retorna a freqüência de valores dentro de intervalos, enquanto o barplot retorna uma barra
para cada valor. O número de barras depende do número de intervalos em que a distribuição será
dividida. Ele é definido por um algoritmo próprio, mas mexendo no argumento breaks você pode
controlar quantas barras haverão, indicando onde estarão as quebras entre barras.
> hist(rnorm(300,100,10))
> hist(rnorm(300,100,10),breaks=seq(60,140,5)) # com barras de largura=5

Veja outras aplicações da função com:
> example(hist)
22
Gráficos de pizza – pie(objeto)

Para fazer gráficos de pizza a função pie.
> pie(c(1,5,7,10))
Veja os exemplos de gráficos de pizza
> example(pie)
Gráfico de pontos – plot(x,y)

Gráficos com variáveis numéricas
Primeiro vamos inserir os dados de duas variáveis numéricas. Lembre-se que a forma mais simples
de inserir dados no R é usando a função de concatenar dados "c".
> y<-c(110,120,90,70,50,80,40,40,50,30)
> x<-1:10
Apesar de não ser uma norma, colocar a variável resposta no eixo y (vertical) dos gráficos é um
consenso entre a maioria dos estatísticos, daí a letra y para dados resposta. x é chamada de variável
independente ou explicativa e aparece no eixo x (horizontal).
É extremamente simples fazer um gráfico de pontos de y contra x no R. A função utilizada é plot()
e precisa de apenas dois argumentos: o primeiro é o nome da variável do eixo X, o segundo é o da
variável do eixo Y.
> plot(x,y)
Para usuários de outros programas que usam linha de comando, é comum trabalhar com a lógica
“plote y em função de x” de maneira que o primeiro argumento é sempre a variável resposta. Se sua
cabeça está acostumada com essa forma de pensar, vc pode usar:
> plot (y~x) # mesmo comando da linha acima
Gráficos com variáveis explanatórias categóricas.

Variáveis categóricas são fatores com dois ou mais níveis (você verá isso no curso de estatística).
Por exemplo, sexo é um fator com dois níveis (macho e fêmea). Podemos criar uma variável que indica o
sexo como isto:
> sex<-c("macho","fêmea")
A variável categórica é o fator sexo e os dois níveis são "macho" e "fêmea". Em princípio, os níveis
do fator podem ser nomes ou números (1 para macho e 2 para fêmea). Use nomes aqui para facilitar.
Vamos supor que estamos avaliando o peso de machos e fêmeas de uma dada espécie. Digamos
que na nossa amostra, os 5 primeiros elementos eram machos e os últimos cinco eram fêmeas. Vamos
criar uma variável que informa isso:.
> sexo<-c("Ma","Ma","Ma","Ma","Ma","Fe","Fe","Fe","Fe","Fe")
Se fossem 20 machos e 20 fêmeas, ia dar um trabalhão fazer esse comando ein!! Então tente
recriar a variável sexo com 5 “Ma” e 5 “Fe” usando o comando rep(x,vezes).
O peso dos animais será dado pelos valores do objeto y que criamos há pouco. Apenas indique
isso:
> peso<-y # peso é igual a y
> peso
23
Agora vamos fazer o gráfico:

> plot(sexo,peso)
Observe que o comando não funcionou, deu erro! Isso ocorreu porque não informamos que sexo é
um fator. Vamos verificar o que o R acha que é a variável sexo.
> is(sexo) # o que é sexo?
Veja que o R trata a variável sexo como sendo um "vetor de caracteres". Mas nós sabemos que
sexo é o nosso fator, então precisamos dar esta informação ao R. A função factor(objeto),
transforma o vetor de caracteres em fator. O fator é um novo tipo de objeto que ainda não tínhamos
visto. É caracterizado por um conjunto de dados categóricos ou nominais que podem assumir um
número finito de níveis. Várias funções do R requerem que as variáveis categóricas sejam apresentadas
na forma de fator. Talvez você queira voltar aos tipos de objetos na 13 para anotar essa nova informação
lá. Seguindo adiante, vamos converter sexo em fator:
> factor(sexo)
Veja que o R mostra os "valores" e depois mostra os níveis do fator.

Agora podemos fazer o nosso gráfico adequadamente:
> plot(factor(sexo),peso) # produz um boxplot!!!!
Gráficos do tipo boxplot são bons quando o número de observações (de dados) é muito grande.
Neste caso, um gráfico com pontos seria melhor, pois podemos ver quantas observações foram
utilizadas para produzir o gráfico e comunicarmos os dados reais ao leitor.
Para fazer um gráfico de pontos quando uma variável é categórica precisamos usar a função
stripchart(y~x).
> stripchart(peso~sexo) # faz o gráfico, mas na horizontal
> stripchart(peso~sexo,vertical=TRUE) # agora o gráfico está na vertical, porém os

# pontos aparecem nas extremidades. TRUE pode ser abreviado para apenas T.
> stripchart(peso~sexo,vertical=T,at=c(1.3,1.7)) # agora os pontos estão
# centralizados, pois com o argumento at, nós especificamos a localização dos pontos no eixo X.
Note que agora só há um problema. Eram cinco fêmeas e no gráfico aparecem apenas 4. Isso
ocorreu porque duas fêmeas tinham o mesmo peso. Para melhorar o gráfico é necessário usar o
argumento method="stack", para que os pontos não fiquem sobrepostos.
> stripchart(peso~sexo,vertical=T,at=c(1.5,1.7),method="stack")
Os pontos não estão mais totalmente sobrepostos, mas um símbolo ainda está sobre o outro. #
Usando o argumento offset=valor conseguimos separá-los.
>_stripchart(peso~sexo,vertical=T,at=c(1.3,1.7),method="stack",offset=1)
Alterando a aparência (parâmetros do gráfico)

Para a proposta de apenas explorar os dados, o gráfico acima geralmente é o que você precisa.
Mas em publicações é necessário saber melhorar a aparência do gráfico. Sempre é bom ter nomes
informativos nos eixos (no R a opção default de nome das legendas é o próprio nome dos objetos).
Suponha então que queremos mudar o nome da variável do eixo x para "Variável explanatória". Para
isso, o argumento xlab ("x label") é utilizado. Use as setas do teclado para voltar ao comando anterior e
coloque uma "vírgula" após o y e depois da vírgula coloque o comando da legenda do eixo x
(xlab="Variável explanatória")
> plot(x,y, xlab="Var explanatória")
24
Você pode alterar a legenda do eixo y da mesma forma, porem usando ylab. Use as setas e
coloque o argumento da legenda do eixo y.
> plot(x,y,xlab="Var explanatória",ylab="Var resposta")
Também é fácil mudar os símbolos do gráfico, neste momento você está usando a opção default,
que é a "bolinha vazia" (pch=1). Se você deseja que o símbolo seja um "x" use pch=4. Use a seta para
cima pra inserir o argumento pch.
> plot(x,y,xlab="Var explanatória",ylab="Var resposta",pch=4)
Para colocar título no gráfico uso o argumento main:

> plot(x,y,xlab="Var explanatória",ylab="Var resposta" ,pch=4,
main="Título do gráfico")
Há uma infinidade de parâmetros para serem alterados em gráficos. Use a função help( ) para
barplot e para plot e veja quantas coisas você pode alterar em gráfico. No quadro abaixo nós
relacionamos alguns parâmetros relativamente importantes para o uso cotidiano
PARÂMETROS COMUNS A DIVERSOS TIPOS DE GRÁFICOS
 pch=nº(1:20)– define símbolo dos pontos

 col=nº(1:8)– define cor dos pontos
Confira a gráfico na última pagina para ver modelos
 cex=nº – define tamanho dos símbolos (default=1)
 log=”x”/”y”/”xy” – define se um ou ambos eixos estão em escala logo
 main=”text” – título do gráfico
 xlab/ylab=”text” – define rótulo do eixo x ou y
 xlim/ylim=c(min,max) – define intervalo do eixo x ou y
 xaxp/yaxp=c(min,max,n) – define mínimo, máximo e número de tick
marks do eixo.
 asp=y/x – define o formato do gráfico (o default é quadrado)
Adicionando linhas a um gráfico de pontos
A função utilizada para inserir linhas é abline(arg1,arg2,arg3,..).Ele é usado em uma linha

de comando após aquela que cria o gráfico. Vamos usar a função abline() para inserir uma linha que
mostra a média dos dados do eixo Y.
ATENÇÃO
> abline(h=mean(y)) # o h indica que será uma linha
# horizontal, passando pela média Abline() exige que o
# de y. gráfico esteja aberto
Para passar uma linha que passa pela média de x

> abline(v=mean(x)) # o v é de vertical
Vamos passar uma linha que passa pelo valor 7 do eixo x e mudar a cor da linha
> abline(v=7,col="red") # pode escrever o nome da cor ou números (abaixo)
Também é possível inserir as duas linhas ao mesmo tempo:

> plot(x,y)
> abline(h=mean(y),v=mean(x),col=4) # indicando a cor pelo número 4
E com cores diferentes
25
> abline(h=mean(y), v=mean(x),col=c(2,4))
Há, no entanto, uma linha muito mais interessante e útil que podemos inserir num gráfico de pontos:
aquela que expressa a relação linear entre duas variáveis. No curso de estatística, aprendemos que a
equação da reta é y= a + bx. Assim para produzir a linha no gráfico, basta informar quais os valores das
constantes a (intercepto) e b (ângulo).
Para extrair rapidamente essa informação (sem entrar em detalhes sobre regressão linear) nós
usamos a função lm(y~x)que significa linear model de y em função de x. Em seguida fazemos o
gráfico e inserimos a linha informando as constantes
> lm(y~x)
Call:
a - intercepto
lm(formula = y ~ x)
Coefficients:
(Intercept) x
118.667 -9.212 b - ângulo
> abline(a=118.667,b=-9.212) # a representa o intercepto e b o ângulo
Agora que você já entendeu como o R faz para inserir a linha do modelo, você gostará de saber que
há uma maneira mais fácil e direta de inserir esta informação no gráfico:
Plotar a linha de um Modelo Linear de Regressão

> abline(lm(y~x))
 read.mtp() - Minitab
Adicionar mais pontos ao gráfico  read.spss() - SPSS
 read.ssd() - SAS
Em alguns casos podemos querer inserir pontos de outro local no mesmo gráfico, usando símbolos
diferentes para o novo local. Suponha que temos novos valores da variável resposta e da variável
explanatória, coletados em outro local, e queremos adicionar estes valores no gráfico. Os valores são
> v<- c(3,4,6,8,9) ## novos valores da variável explanatória
> w<-c(80,50,60,60,70) ## novos valores da variável resposta

Para adicionar estes pontos ao gráfico, basta usar a função points(). Assim como abline() ela
também é inserida numa linha de comando em separado. Portanto, primeiro vamos refazer o gráfico com
x e y e depois adicionar os novos pontos usando uma cor diferente para diferenciar
> plot(x,y,pch=16, col=”black”)
> points(v,w,pch=16, col="blue")
É possível adicionar pontos nos gráficos indicando com o mouse onde eles deverão ficar usando a
função locator(n). O n indica o número de pontos que você deseja indicar no gráfico. A função
locator(n) permite que você clique no gráfico com o mouse e adicione o texto na posição desejada
> points(locator(2),pch=16,col=”red”)
Inserir texto em gráficos

Para inserir textos em gráficos a função é text. Ela funciona assim:
> text(cooX,cooY,"texto")
Neste caso cooX e cooY indicam as coordenadas do eixo X e do eixo Y onde o texto deverá ser
inserido. Vamos criar um gráfico simples:
26
> plot(1:10,1:10)
Agora vamos adicionar "seu nome" no gráfico nas coordenadas 6 e 7. Isso indica que seu nome
ficará na posição 6 do eixo X e na posição 7 do eixo Y.
> text(6,7,"Seu.Nome")
Para inserir duas palavras:
> text(c(2,3),c(8,6),c("nome","sobrenome")) # A primeira palavra ficará na posição
# 2-8 e a segunda palavra ficará na posição 3-6.
Também é possível adicionar texto aos gráficos usando a função locator(n). Para mais de um
texto:
> plot(1:10,1:10)
> text(locator(3),c("texto 1","texto 2","texto 3"))
Dividir a janela dos gráficos

Em alguns casos em que se deseja apresentar ou comparar dois ou mais gráficos é possível dividir
a janela de gráficos do R. A função par(arg1,arg2,arg3,...) controla diversas características dos
gráficos. Sempre que quiser melhorar algum aspecto de seu gráfico consulte o help da função par
(?par) e descubra o argumento necessário. Tome um tempo agora para dar uma olhada nesse help.
Vamos dividir a janela de gráficos e preencher com diferentes gráficos:
> par(mfrow=c(nl,nc)) # nl indica o número de linhas e nc o número de colunas que a
# janela deverá ter. Primeiro vamos dividir a janela em duas colunas.
> par(mfrow=c(1,2)) # uma linha e duas colunas, ou seja, um gráfico no lado do outro
> hist(rnorm(300,0,2),breaks=20,col=1) # apenas para gerar um gráfico qualquer

> hist(runif(300,0,2),breaks=20,col=1)
Agora vamos dividir a janela em duas linhas e uma coluna:
> par(mfrow=c(2,1))
> hist(rnorm(300,0,2),breaks=20,col=1)
Agora vamos dividir a janela em duas linhas e duas colunas (para plotar 4 gráficos)
> par(mfrow=c(2,2))
> hist(rnorm(300,0,2),breaks=20,col=1)
> hist(rnorm(300,0,2),breaks=10)
> hist(runif(300,0,2),breaks=10)
Salvar os gráficos
Existem diversas opções para salvar os gráficos do R. A mais simples é clicar com o botão direito
do mouse sobre o gráfico e depois em "save as metafile". Esse formato não perde qualidade quando
transferido para o Microsoft Office e continua como desenho vetorial no Corel Draw. Para quem usa o
editor de texto LATEX e sabe o que é um arquivo postscript também existe esta opção com o "save as
postSscript".
27
Também é possível salvar os gráficos em PDF, JPEG, BMP, PNG ou outros formatos. Para tanto
clique sobre o gráfico e depois clique em Arquivo e em salvar como. Escolha a opção que deseja salvar.
EXERCÍCIOS COM GRÁFICOS

1. Um biólogo foi ao campo e contou o número de sapos em 20 locais. Ele também anotou a
umidade e a temperatura em cada local. Faça dois gráficos de pontos para mostrar a relação do número
de sapos com as variáveis temperatura e umidade. Use a função par() para dividir a janela em duas e
visualizar os dois gráficos simultaneamente:
Os dados são:
sapos 6-5-10-11-26-16-17-37-18-21-22-15-24-25-29-31-32-13-39-40
umid 62-24-21-30-34-36-41-48-56-74-57-46-58-61-68-76-79-33-85-86
temp 31-23-28-30-15-16-24-27-18-10-17-13-25-22-34-12-29-35-26-19
2. Um biólogo interessado em saber se o número de aves está relacionado ao número de uma

determinada espécie de árvore realizou amostras em 10 locais. Os valores obtidos foram:
> aves<-c(22,28,37,34,13,24,39,5,33,32)
> arvores<-c(25,26,40,30,10,20,35,8,35,28)
Faça um gráfico que mostra a relação entre o número de aves e o número de árvores.
2.1. Um colega coletou mais dados sobre aves e árvores, em outra área, que podemos aproveitar.
Os dados são:
> arvores2<-c (6,17,18,11,6,15,20,16,12,15)
> aves2<-c(7,15,12,14,4,14,16,60,13,16)
Inclua estes novos pontos no gráfico com um símbolo diferente e cor azul.
2.2. Junte o seu arquivo de aves com o arquivo de aves do seu amigo, para que fique em um arquivo
completo: aves.c<-c(aves,aves2). Faça o mesmo para árvores.
2.3. Os dados do exercício anterior foram coletados em regiões diferentes (você coletou no local A e
seu amigo no local B). Faça um gráfico para ver qual região tem mais aves e outro para ver qual
tem mais árvores. Lembre que você precisa criar um vetor indicando o local de cada coleta (local
A ou local B). Use função stripchart.
2.4. Existem locais com o mesmo número de aves, e no gráfico estes pontos apareceram
sobrepostos. Faça o gráfico sem pontos sobrepostos (lembre-se dos argumentos method e
offset)
Existem milhares de outros comandos para alterar a aparência de gráficos, veja esta página do help
(?par) para ver alguns comandos sobre como alterar a aparência de gráficos. Não se preocupe se você
ficar confuso sobre as opções do help(par), apenas praticando você irá começar a dominar estes
comandos.
28
DIA 3 - IMPORTAR CONJUNTO DE DADOS PARA O R

Passe a tabela abaixo (locais, abundância de macacos e de árvores frutificando) para o Excel e
salve-a (na pasta do curso) em formato de "texto separado por tabulações" (No Excel clique em "salvar
como" e em texto (separado por tabulações)). Salve com o nome de amostras.txt na pasta do
working directory. Deixe a célula onde está escrito Amostra em branco!!!
amostra reserva macacos frutas
A1 A 22 25
A2 A 28 26
A3 A 37 40
A4 A 34 30
A5 A 13 10
A6 A 24 20
A7 A 39 35
A8 A 5 8
A9 A 33 35
A10 A 32 28
B1 B 7 6
B2 B 15 17
B3 B 12 18
B4 B 14 11
B5 B 4 6
B6 B 14 15
B7 B 16 20
B8 B 60 16
B9 B 13 12
B10 B 16 15
Note que esta tabela contém variáveis numéricas e categóricas, portanto este é um exemplo de
objeto do tipo dataframe. Para importar a tabelas em formato “txt separado por tabulações” para o R a
função é read.table.
> read.table("amostras.txt",header=TRUE)
O argumento header=TRUE informa que os dados possuem cabeçalho, ou seja, a primeira linha
contém os nomes dos atributos (variáveis) e a primeira coluna possui o nome das amostras.
Não se esqueça de atribuir os dados à um objeto, não basta importar, é preciso salvar também.
> macac<-read.table("amostras.txt",header=TRUE)
O objeto macac é um objeto do tipo dataframe. Isso quer dizer que macac é um objeto que
possui linhas e colunas (observações nas linhas e variáveis (atributos) nas colunas). Para ver os dados
digite o nome do arquivo.
> macac
29
Importar arquivos de outros programas
>library(foreign) Arquivos lidos pelo R
Se você possui seus dados em outros  read.systat() - Systat

programas estatísticos, saiba que o R  read.dbf() – Família Base
tem flexibilidade para importar vários  read.dta() – Stata
tipos de arquivos. Para isso é preciso  read.mtp() - Minitab
carregar o pacote foreign (estrangeiro)  read.spss() - SPSS
que possui as ferramentas para tais  read.ssd() – SAS
importações.  read.csv() – Excel
Arquivos .csv são arquivos de texto com células separadas por vírgulas. O Excel salva neste
formato e pode ler este formato diretamente como uma planilha, sem maiores dificuldades. Você deve
ficar atento, no entanto, a língua do seu computador. Computadores em português tendem a usar “;”
como separador de células em arquivos csv. Se este for o caso, use o comando read.csv2() que irá
automaticamente reconhecer esta diferença.
Procurar os dados dentro do computador

Os comando para importar dados como o read.table() sempre procuram pelos arquivos no working
directory. No entanto, você pode chamar arquivos de outras pastas se souber indicar corretamente o
endereço completo do arquivo, por exemplo:
> read.table(“C:\Users\Zucco\Documents\Rfiles\macac.txt”,header=TRUE)
No ambiente Windows, você pode usar tanto as barras duplas // ou a barra invertida \. Caso você
não lembre o nome do arquivo de dados que deseja importar existe a opção de procurar os dados no
computador com a função file.choose(), que abre uma caixa de diálogo onde você procura pelo
arquivo como em outros programas para Windows.
> macac<-read.table(file.choose(),header=T) # encontre o arquivo macac.txt
Você também pode conferir se um determinado arquivo de dados existe no seu working directory:
> file.exists("macac.txt")
Transformar vetores em matrizes e data frames

Além de importar tabelas, existe opções juntar vetores em um arquivo dataframe ou matriz. Para
criar uma matriz use “column bind” cbind(vetor1,vetor2,...) ou o “row bind” rbind(vetor1,
vetor2,...). Vamos ver como funciona. Vamos criar três vetores e depois juntá-los em uma matriz.
> aa<-c(1,3,5,7,9)
> bb<-c(5,6,3,8,9)
> cc<-c("a","a","b","a","b")
> cbind(aa,bb) # junta os vetores em colunas
> rbind(aa,bb) # junta os vetores em linhas
Lembre que matrizes podem conter apenas valores numéricos ou de caracteres. Por isso, se
juntarmos o vetor cc, nossa matriz será transformada em valores de caracteres.
30
> cbind(aa,bb,cc) # junta os vetores em colunas, mas transforma números

em caracteres.
Para criar uma dataframe com valores numéricos e de caracteres use a função data.frame:
> data.frame(aa,bb,cc) # agora temos variáveis numéricas e categóricas
Acessar partes da tabela de dados (matrizes ou dataframes)

Agora vamos aprender a selecionar (extrair) apenas partes do nosso conjunto de dados macac
usando [] colchetes. Como já vimos, uso de colchetes para objetos em duas dimensões funciona
assim: objeto[linhas,colunas], onde está escrito linhas você especifica as linhas desejadas,
na maioria dos casos cada linha indica uma unidade amostral. Onde está escrito colunas, você pode
especificar as colunas (atributos) que deseja selecionar. Veja abaixo:
> macac[,1] # extrai a primeira coluna e todas as linhas
> macac[,2] # extrai a segunda coluna e todas as linhas
> macac[1,] # extrai a primeira linha e todas as colunas
> macac[3,3] # extrai a terceira linha e a terceira coluna, 1 valor
> macac[1,3] # extrai o valor da primeira linha e terceira coluna
> macac[c(1:5),c(2,3)] # extrai as linhas 1-5 e as colunas 2-3
Existem outras duas maneiras de extrair dados de uma dataframe. Uma é usando a função
attach(objeto), que torna as variáveis acessíveis apenas digitando o nome delas na linha de
comandos, como se elas fossem objetos também.
Digite macacos na linha de comandos e veja o que acontece!
> macacos
Error: object "macacos" not found
Agora use a função attach(), digite macacos novamente e veja o que acontece.
> attach(macac) #variáveis de macaco estão acessíveis como se fossem
objetos
> macacos # agora os dados macacos está disponível
> frutas # para ver o número de frutas
> reserva # para ver as reservas
> plot(macacos,frutas)
IMPORTANTE!!!
A função attach apesar de parecer "uma mão na roda" pode ser problemática. Se
"atacharmos" duas dataframes, e elas tiverem variáveis com o mesmo nome, é "perigoso"
usarmos por engano a variável errada. Se você usar a função attach é seguro
"desatachar" o objeto imediatamente após o seu uso. Para isso use detach().
> detach(macac)
> macacos #macacos não está mais disponível
31
Uma melhor forma de acessar colunas pelo nome é usar o símbolo cifrão ($), e não usar a função
attach(). O cifrão funciona apenas com objetos do tipo lista. Como já dissemos na página 13 que
dataframe’s são um tipo especial de lista, por isso o cifrão funciona também com dataframes. O uso é
basicamente o seguinte: objeto$variável (a variável corresponde à coluna que deseja extrair). Por
exemplo, para extrair a coluna macacos use:
> macac$macacos
Ou então usar colchetes e o nome da variável:
> macac[,"macacos"]
Vamos fazer o gráfico de macacos X frutas usando $.
> plot(macac$frutas,macac$macacos)
Faça o gráfico de frutas X macacos usando colchetes ao invés de usar $.
Operações usando dataframes

Ordenar a tabela
Os dados de macac estão dispostos na ordem em que foram coletados. Em alguns casos podemos
querer colocá-los em outra ordem. Por exemplo, na ordem crescente de quantidade de árvores
frutificando. Para isso use a função order().
> macac[order(macac$frutas),] # ordena as linhas de macac pela ordem crescente de

# frutas
O parâmetro decreasing=TRUE/FALSE controla se o ordenamento é crescente ou decrescente.
O default é FALSE. Por isso para fazer ordenamento decrescente é necessário informar:
> macac[order(macac$frutas,decreasing=TRUE),]
Tome um tempo para entender porque o ordenamento de tabelas funciona com comando order()
e não com o comando sort(). Para tanto vamos decompor o comando em passo a passo. Primeiro
olhamos a função order().
> order(macac$frutas)
Veja que o output indica um sequência de números que correspondem a posição dos elementos na
coluna macac$frutas em ordem crescente. Ou seja, os elementos 11 e 15 são os que possuem menores
valores de frutas, seguidos de 8, 5, 14. Ao colocar esse comando dentro de macac[ ,] estamos
dizendo que queremos a sequência de linhas expressas por order(macac$frutas).
Calcular a média de uma linha ou de uma coluna

Podemos calcular a média de cada coluna da dataframe usando.
> mean(macac[,"macacos"]) # média de macacos ou use
> mean(macac$macacos)
> mean(macac) # média de cada coluna de um dataframe

Repare que resultado para reservas foi NA e em seguida apareceu uma mensagem de aviso. NA
indica Not Available, pois não é possível calcular a média de variáveis categóricas.
Nós calculamos a média de macacos por unidade amostral, mas sem considerar a reserva onde as
amostras foram coletadas. O que fazer para calcular a média de macacos em cada reserva? Basta
selecionar as linhas correspondentes a cada reserva.
32
> mean(macac[1:10,2]) # média de macacos na reserva A
> mean(macac[11:20,2]) # média de macacos na reserva B
Soma de todas as linhas ou colunas

Agora, vamos usar dados sobre a abundância de moluscos que foram coletados em dez parcelas. A
tabela também contém informações sobre quantidade de chuva em cada parcela e em qual de duas
reservas (A ou B) a parcela estava localizada. O arquivo com os dados é moluscos.txt e está na
pasta da disciplina, importe-o para o R. Chame os dados do arquivo de mol para facilitar.
Desejamos somar os valores de colunas ou linhas usando as funções colSums(objeto) para

somar colunas e rowSums(objeto) para somar linhas.
> colSums(mol[,1:6]) #Note que estamos somando apenas as informações sobre as 6

# espécies (colunas 1 a 6)
> rowSums(mol[,1:6])
Qual informação biológica vc obteve ao usar os dois comandos acima? Discuta com seus colegas.
Médias de todas as linhas ou colunas

Calcular a média das colunas e linhas. Abundância média por parcela e abundância média por
espécie.
> colMeans(mol[,1:6])
> rowMeans(mol[,1:6])
E se quisermos calcular apenas a abundância média de moluscos nos pontos da reserva A (linhas
de 1 a 5)? Você consegue fazer este cálculo? Veja as quatro opções abaixo e diga qual delas fará o
cálculo correto.
1 - mean(mol[,1:6])
2 - rowMeans(mol[1:5,1:6])
3 - colMeans(mol[1:5,1:6])
4 - mean(rowSums(mol[1:5,1:6]))
Operações em sub-conjuntos – família de comandos apply

Um procedimento bastante comum no processamento de dados é a execução de funções
(matemáticas, estatísticas ou contagem) por grupos dentro dos seus dados. Um exemplo prático desse
tipo de demanda foi posto agora há pouco quando nós quisemos calcular a média de macacos por
unidade amostral para cada reserva em separado. Nesse caso, temos uma função sendo executada em
série pelo sub-conjunto reserva. Nesse caso, foi fácil solucionar o problema com um comando simples
como:
> mean(macac[1:10,2]) # para reserva A
> mean(macac[11:20,2]) # para reserva B

Porém, imagine esse tipo de solução quando os seus dados são extensos, e por exemplo, vc possui
coletas em 30 reservas. Você precisaria de um comando para cada reserva (30 linhas de comandos).
Uma alternativa mais elegante e simples é poder dizer ao R “calcule a média de macacos em cada
unidade amostra por reserva”. O comando tapply( ) executa esse procedimento assim:
> tapply(dados,grupos,função)
33
Segundo essa sintaxe está dito que será calculada a função nos dados em relação ao grupo
indicado. Vamos demonstrar a aplicação do comando na base dados do arquivo “deer.txt” com
resultados de monitoramento de GPS de 11 veados campeiros (Ozotoceros bezoarticus) no Pantanal de
Mato Grosso do Sul. Durante esse estudo, os receptores GPS eram programados para obter uma
localização a cada 5 minutos.
> deers<- read.table(“deers.txt”, header=TRUE)
> dim(deers)
[1] 31620 8
> names(deers) # para ver os nomes das variáveis do objeto deers
Nesse objeto há 31.620 linhas que correspondem às localizações geográficas obtidas durante o
monitoramento. A coluna ID, identifica o indivíduo à qual a localização se refere.
> table(deers$ID) # retorna a quantidade de pontos de cada indivíduo
2 3 5 6 9 10 12 13 14 15 20
653 1025 2049 1610 5035 3594 2231 4837 3718 3639 3229
É possível perceber que o estudo obteve 653 localizações do veado #2, 1025 localizações do veado
#3, 2049 localizações do veado #4, etc. A coluna deer$DIST, contém a informação de distância que o
animal se deslocou desde a última localização. Se desejarmos saber quanto cada animal se deslocou
durante o período de seu monitoramento, bastaria somar o deslocamento entre todas as localizações.
Assim queremos somar os valores de distância deslocada (deer$DIST) por indivíduo (deer$ID). Vejamos
como fazer usando tapply().
> distancia<-tapply(deers$DIST,deers$ID,sum) # somar distâncias por indivíduo

> distancia
A família apply, possui outros três tipos de aplicação além do tapply(). Abaixo explicamos
brevemente a aplicação de cada uma:
apply (dados, MARGIN, função, simplify=TRUE)
O apply() executa a função definida nos dados por coluna ou linha e não por grupo como o
tapply(). O argumento, MARGIN pode ser igual a 1 para indicar linha; 2 para indicar colunas ou
c(1,2) para indicar ambos. Se a função desejada for somatório, o apply() faz a mesma coisa que
as funções colSums e rowSums como visto acima. Se a função for média, aí ele equivale ao
colMeans e rowMeans. A importância do apply() é que ele permite a execução de qualquer
função no conjunto de dados. Veja os exemplos
> apply(mol[,1:6],MARGIN=2,sum) # somar colunas de mol(colunas 1- 6)
> apply(mol[,1:6],MARGIN=1,mean) # média das linhas de mol(colunas 1-6)

lapply(dados,função) e sapply(dados,função, simplify=TRUE)
O lapply() executa a função definida em cada elemento de um objeto tipo lista. Como
resultado lapply() apresenta uma nova lista, em que cada elemento é resultado da função que foi
usada. O sapply() faz o mesmo que lapply() mas apresenta um argumento simplify=TRUE, que
tenta devolver o resultado em um forma mais simples que uma lista, isto é, como um vetor ou se for o
caso, uma matriz
34
EXEMPLO COM DADOS REAIS

Na pasta do curso existe um arquivo chamado simu.txt. Este arquivo contém amostras de
Simuliidae (borrachudos - piuns) coletadas em 50 riachos da Chapada Diamantina - Bahia. Importe este
arquivo e vamos ver alguns exemplos de opções que podemos fazer com este conjunto de dados.
> simu<-read.table("simu.txt",header=T)
Use names()para ver o nome das variáveis que estão no arquivo.

> names(simu)
Note que as 6 primeiras variáveis são ambientais e depois os dados de 20 espécies. Estes dados
foram coletados em três municípios dentro da chapada diamantina (Lençóis, Mucugê e Rio de Contas).
Primeiro vamos separar os dados das espécies dos dados ambientais:
> ambi<-simu[,1:6]
> spp<-simu[,7:26]
Vamos ver os gráficos que mostram as relações entre as variáveis ambientais.
> plot(ambi[,"temperatura"],ambi[,"altitude"])
> plot(ambi[,"altitude"],ambi[,"pH"])
> plot(ambi[,"condutividade"],ambi[,"pH"])
No R a função pairs()faz um gráfico cruzando todos os pares de variáveis possíveis em um

dado objeto. É um passo inicial da exploração de dados mas deve ser usado com parcimônia.
> pairs(ambi)
Vamos calcular a abundância total de borrachudos em cada riacho.

> rowSums(spp) # soma das linhas (riachos)
Para salvar a abundância:

> abund<-rowSums(spp)
E para calcularmos a riqueza de espécies em cada riacho? Primeiro precisamos transformar os

dados em presença e ausência (0 para ausência e 1 para presença). Primeiro vamos criar uma cópia do
arquivo original.
> copia<-spp # cópia é igual a spp
Agora vamos criar o arquivo de presença e ausência:

> copia[copia>0]<-1 # quando copia for maior que 0 o valor será substituído por 1
> pres.aus<-copia # apenas para mudar o nome do arquivo
> pres.aus # veja que agora os dados estão apenas como 0 e 1

Para encontrar a riqueza de espécies basta somar as linhas do arquivo de presença e ausência.
> riqueza<-rowSums(pres.aus) # número de espécies por riacho (riqueza)
Para calcular a riqueza média de todos os riachos:
> riq.media<-mean(rowSums(pres.aus))
Vamos calcular a riqueza média por município onde foram realizadas coletas.
> riq.muni<-tapply(riqueza,ambi[,"município"],mean)
35
Agora use a função colSums() para ver em quantos riachos cada espécie ocorreu e qual a
abundância total de cada espécie. Qual a espécie que ocorreu em mais riachos? Qual era a mais
abundante?
Para transformar os dados de abundância de espécies em log:
> simu.log<-log(spp)
Veja o resultado em log:
> simu.log # Note a presença do valor -inf
Relembrando: o valor -inf ocorre porque não é possível calcular o log de 0. Veja:
> log(0)
Por isso é comum você ver em trabalhos os dados transformados em log(x+1):
> spp.log<-log(spp+1)
> spp.log
Agora vamos retornar ao nosso arquivo completo, simu, e ordenar a tabela de acordo com a
altitude, de forma que o primeiro riacho seja o que está localizado em menor altitude.
> simu[order(simu[,"altitude"]),]# tabela ordenada pela altitude
Agora vamos fazer 4 gráficos da riqueza de espécies em relação a altitude, pH, temperatura e
condutividade. Primeiro vamos dividir a janela de gráficos em 4 partes.
> par(mfrow=c(2,2))
Riqueza X altitude
> plot(simu[,"altitude"],rowSums(pres.aus))
EXERCÍCIO: Faça os outros três gráficos.
Agora vamos fazer um gráfico para ver a riqueza de espécies nas três áreas (Lençóis, Mucugê e
Rio de contas).
> stripchart(riqueza~factor(simu[,"município"]))
EXERCÍCIO: Coloque o gráfico na vertical e separe os pontos coincidentes.
As funções aggregate e by
As funções by(dados,grupo,função) e aggregate(dados,grupo,funçao) podem ser
utilizadas para aplicar uma função em todas as colunas de uma tabela, enquanto a função tapply() faz
isso apenas uma coluna por vez. As duas funções retornam os mesmos resultados, mas de formas
diferentes. Para calcular a média de cada espécie de borrachudo em cada um dos 3 locais use:
> aggregate(spp,list(simu[,1]),mean)
Veja que a função aggregate() retorna uma dataframe com os valores para cada local em cada
coluna. Agora tente o seguinte comando:
> by(spp,simu[,1],mean)
A função by() retorna uma lista com os valores para cada local. Para acessar os valores de uma
lista é preciso usar duplo colchetes:
> med.local<-by(spp,simu[,1],mean)
> med.local
36
> med.local[["Lençóis"]]
> med.local[["Mucugê"]]
> med.local[["R.Contas"]]
LEMBRE-SE!!
Aggregate
by (dados, grupo, função)
tapply
 Os três comandos executam funções nos dados estratificadas por grupo;

 tapply() só roda em 1 variável (coluna) por vez;
 aggregate() e by() rodam em diversas variáveis(colunas) de uma só vez;
 aggregate() exige que o grupo seja convertido em list
 output de by() é uma list, bom para visualização, ruim para manipulação;
 output de aggregate() é um dataframe, bom para manipulação
Transpor uma tabela de dados

Em alguns casos é necessário transpor uma tabela de dados, ou seja, colocar as informações das
linhas nas colunas e as colunas nas linhas. A função é t() e indica transpose.
> t(spp)
COMANDOS DE LÓGICA
Opções para manipular conjunto de dados.
Primeiro vamos ver o significado dos comandos abaixo.
> Maior que >= maior que ou igual a
< Menor que <= menor que ou igual a
== igualdade
!= diferença
> x<-c(1,2,9,4,5)
> y<-c(1,2,6,7,8)
> x>y # Retorna TRUE para os maiores e FALSE para os menores

> x>=y
> x<y
> x==y # Retorna TRUE para os x que são iguais a y
> x!=y # Retorna TRUE para os x que são diferentes de y

Agora vamos selecionar partes dos dados que obedecem a algum critério de seleção.
37
which(teste lógico)
A função which(teste lógico) retorna a especificação lógica TRUE ou FALSE para uma dada
condição lógica apresentada. Na prática ele funciona como se fosse a pergunta: Quais?
> a<-c(2,4,6,8,10,12,14,16,18,20)
> a>10 # retorna um vetor contendo TRUE se for maior e FALSE se for menor
> which(a>10) # Equivale a pergunta: "Quais valores de a são maiores que 10?".
# Note que a resposta é a posição dos valores (o sexto, o sétimo…) e não os valores que são
# maiores que 10.
> a[6] # selecionamos o sexto valor de a
> a[c(6:10)] # selecionamos do sexto ao décimo valor

Tente prever o que ocorrerá usando o comando abaixo.
> a[which(a>=14)]
Acertou? Selecionamos os valores de a que são maiores ou igual a que 14!
Também podemos usar a função which() para selecionar partes de uma tabela de dados. Por
exemplo, vamos selecionar apenas as parcelas dos dados de moluscos onde a chuva é maior que 1650
mm.
Lembre-se que para selecionarmos partes de uma tabela podemos usar colchetes
[linhas,colunas] e especificar as linhas e colunas que desejamos usar. Então vamos usar o
comando which() para escolher apenas as linhas (parcelas) onde a chuva é maior que 1650mm:
> mol[which(mol$chuva>1650),]
Poderíamos alternativamente, escolher apenas a parte da tabela que corresponde às amostras da
reserva A:
Lembrar: mol$reserva é uma variável de
> mol[which(mol$reserva=="A"),] caracteres, logo precisamos usar aspas
Também podemos incluir um segundo critério de escolha usando & (que significa "e"). Vamos
escolher apenas as parcelas da reserva B e que tenham o valor de chuva maior que 1650mm.
> mol[which(mol$reserva=="B" & mol$chuva>1650),]
Ifelse(teste lógico ,valor se TRUE, valor se FALSE)

Agora vamos aprender a usar o comando ifelse() que significa: “se for isso, então seja aquilo,
se não, seja aquilo outro”. O comando funciona da seguinte maneira: ifelse(teste lógico, valor caso o
teste for verdade, valor caso seja falso). Complicado? Vamos ver alguns exemplos para facilitar as
coisas.
Primeiro crie no R um objeto com o valor do salário de dez pessoas. Os valores são:
> salarios<-c(1000, 400, 1200, 3500, 380, 3000, 855, 700, 1500, 500)
As pessoas que ganham menos de 1000 ganham pouco, concorda? Não chega nem a uma mísera
bolsa de mestrado. Então aplicamos o teste e pedimos para retornar "pouco" para quem ganha menos
de 1000 e "muito" para quem ganha mais de 1000.
> ifelse(salarios<1000,"pouco","muito") # Se o salário é menor que 1000, seja
# pouco, se for maior seja muito.
38
Também podemos usar o comando ifelse para transformar os dados em presença e ausência.
Vamos usar os dados das espécies de borrachudos (spp) da Chapada Diamantina.
> ifelse(spp>=1,1,0) # se o valor de spp for maior ou igual a 1 seja 1, se não, seja 0
EXERCÍCIOS COM DATAFRAMES E COMANDOS DE LÓGICA:

1. Calcule a média de macacos e frutas dentro de cada reserva do conjunto de dados macac.
2. Quais informações podem ser obtidas da tabela de moluscos quando usamos os quatro
comandos abaixo.
2.1. mean(mol[,1:6])
2.2. rowMeans(mol[1:5,1:6])
2.3. colMeans(mol[1:5,1:6])
2.4. mean(rowSums(mol[1:5,1:6]))
3. Use a função t para transpor os dados de moluscos (apenas as espécies).

4. Multiplique o valor da abundância de cada espécie de molusco pelo valor de chuva da parcela
correspondente. Por exemplo: Na parcela 1 a chuva foi de 1800 mm e nesta parcela ocorreram 10
indivíduos da espécie 1, portanto o novo valor para a sp1 na parcela 1 será de 1800 x 10 = 18000.
5. Faça um gráfico de pontos para comparar o número de macacos na reserva A com o número de
macacos na reserva B. Use o conjunto de dados macac. Use a função stripchart.
6. Importe para o R o arquivo minhocas.txt que está na pasta do curso. Este arquivo possui dados
sobre a densidade de minhocas em 20 fazendas. As variáveis medidas são: área, inclinação do terreno,
tipo de vegetação, pH do solo, se o terreno é alagado ou não e a densidade de minhocas.
6.1. Veja a tabela na forma original e depois a ordene de acordo com o tamanho da área.
6.2. Faça um gráfico para ver a relação entre minhocas e área do terreno e outro gráfico para ver a
relação entre minhocas e tipo de vegetação.
6.3. Selecione a parte da tabela que contém apenas dados de locais alagados.
6.4. Calcule a densidade média de minhocas, e a densidade média em locais alagados e em locais
não alagados.
6.5. Qual a área média das fazendas?
7. Podemos usar a função ifelse() para transformar dados de abundância em dados de presença
e ausência. Transforme os dados de abundância de moluscos mol em dados de presença e
ausência.
8. Com os dados transformados em presença e ausência, use a função rowSums para ver
quantas espécies de moluscos ocorrem em cada parcela. Use colSums para ver em quantas
parcelas cada espécie estava presente.
Os monitoramento de veado campeiro foi planejado para avaliar padrões de atividade. Um dos
padrões mais básicos de se investigar é o ligado ao ciclo diário. Com os dados de veado-campeiro deers
faça:
8.1. um gráfico de barras que expresse o deslocamento total por hora do ciclo diário. Para tanto,
basta somar os deslocamento associado a todos os pontos obtidos dentro de cada intervalo de
hora. Como a variável hora dec fornece a hora décima exata de cada localização, vc pode usar o
comando round() para fazer com que cada ponto seja atrelado a uma faixa de horário e possa
executar os somatórios por faixa
8.2. um gráfico de barras que expresso o deslocamento total por hora do ciclo diário apenas para o
veado #5.
39
DIA 4 – APRENDER A CRIAR FUNÇÕES (PROGRAMAÇÃO)

Enquanto o R é muito útil como uma ferramenta para análise de dados, o ponto mais relevante de
seu funcionamento é a possibilidade dada aos usuários de criarem suas próprias funções, seja de
simples manipulação de dados, seja de análise estatística complexa. Esta é uma das maiores vantagens
do R. Além de ser um programa para análises estatísticas, o R é acima de tudo uma linguagem de
programação, praticamente ilimitada. Seus limites quase sempre serão dados pelos limites de
processamento do seu computador.
Na sequência vamos aprender o funcionamento básico de programação, incluindo os comandos
function(){ } e for(){ }
Sintaxe para escrever funções

A sintaxe básica é:
> funçãoA <- function(lista de argumentos){corpo da função}
Function(){} é a função para criar funções. No comando acima, está dito: "estou criando uma
função que vai se chamar funçãoA". A partir de agora, essa função será um objeto no seu workspace.
Na verdade, todas as funções de R são objetos, mas elas estão contidas nos pacotes e não precisam
figurar como objetos de seu workspace. Aquelas funções criadas pelo usuário, por outro lado, precisam
ser materializadas como objetos do workspace.
Na sequência são listados todos os argumentos que a funçãoA terá. Eles serão usados no corpo
da função que é a parte onde é escrito o "algoritmo" dos procedimentos a serem executados. Esta parte
vem entre chaves.
Praticando o comando function( ){ }

Vamos ver como criar funções começando por uma função simples, que apenas simula o sorteio de
objetos como moedas ou dados. Neste caso a função terá dois argumentos (x e n). x será o elemento a
sortear e n será o número de vezes que deseja jogar a moeda.
Vamos dar o nome a esta função de jogar.moeda
> jogador<-function(x,n){ # Não digite tudo na mesma linha
> sample(x,n, replace=T)
> } # Fim da função
DICA DE PROGRAMAÇÃO!!
Embora não seja uma obrigação, é praxe entre programadores, colocar a chave de abertura
da função “{“ no fim da primeira linha e a chave de encerramento “}” numa linha separada após o
fim do corpo da função. Isso auxilia na leitura de linhas de programação quando elas são muito
extensas e possuem funções dentro de funções.
O comando sample(x,n) indica que desejamos amostrar x, n vezes (jogar a nosso objeto de
soirteio moeda n vezes).
Agora vamos usar nossa função para jogar uma moeda. Primeiro criamos a moeda para então
jogar:
> moeda<-c("Cara","Coroa")
40
> jogador(moeda,2)
> jogador(moeda,10)
> jogador(moeda,1000)
Veja que jogando 1000 moedas ficou difícil saber quantas caras e quantas coroas saíram. Lembra
como fizemos para conferir isso dois dias atrás??? Use a função table():
> table(jogador(moeda,1000))
Agora vamos usar nosso jogador para arremessar dados:

> dado<-1:6
> jogadora(dado,2)
> table(jogador(dado,200))
A função jogador é muito simples e nem é necessária, pois podemos jogar moedas facilmente sem
ela. No fundo apenas mimetizamos a função sample().
> sample(c("cara","coroa"),10,replace=T)
Agora suponha que você não sabe qual função do R calcula a média, mas você sabe a fórmula para
calcular média..
Conhecendo a fórmula você pode criar sua própria função que calcula a média. Note que você pode
inserir comentários dentro da função para depois lembrar o que fez:
> media<-function(dados){ # função chamada media
+ n<-length(dados) # n é o número de observações
+ med<-sum(dados)/n # calcula a média
+ return(med) # return determina o que deve aparecer no output da função criada
+ } # Fim da função
Vamos usar a função criada (media) para calcular a média dos valores abaixo:
> valores<-c(21, 23, 25, 19, 10,1 ,30, 20, 14, 13)
> média(valores)
Use a função do R mean() para verificar se o cálculo foi feito corretamente.
Comando for()
O comando for é usado para fazer loopings, isto é, repetir um mesmo procedimento inúmeras
vezes. Funciona da seguinte maneira:
for(i in 1:n){comandos}
Isso quer dizer que: para cada valor i o R vai calcular os comandos que estão entre as chaves. O
"(i in 1:n)" indica que i assumirá todos os valores no intervalo entre 1 e n. Ou seja, na primeira
rodada do for o i será igual a 1, na segunda i = 2, e assim por diante até i = n. Para salvar os
resultados que serão calculados no for precisamos criar um objeto vazio que receberá os valores
calculados. Criamos este objeto vazio assim:
Nunca esquecer de criar
> resu<-numeric(0) objeto vazio para receber
os resultados do for
41
Agora vamos usar o for(){} para elevar i valores ao quadrado:
> for(i in 1:5){ ## o i será i = 1; i = 2; i = 3; i = 4; i = 5

2
+ resu[i]<-i^2 ## Na primeira rodada o i = 1, então será 1
+ } # Fim do for (i)
> resu ## Para ver os resultados

Antes de continuar, vamos fazer uma espécie de
"filminho" mostrando o que o for faz. Primeiro vamos Nota sobre comando for
fazer um gráfico com limites xlim =0:10 e ylim=0:10.
 A linha de {comandos} em for só faz sentido se
> plot(0:10,0:10, type="n") ela incluir o i como um dos seus elementos.
Agora vamos usar o for para inserir textos no  O n do i in 1:n pode ser dado no corpo dos
gráfico a cada passo do for: comandos ou a priori diretamente no lugar do n.
 O loop for executa o mesmo procedimento
> for(i in 1:9){
repetidamente para cada valor que i assume, por
+ text(i,i, paste("Passo", i)) isso é mais lento do comandos com execução
+ } direta sobre todo o objeto.
O R fez tudo muito rápido, de forma que não conseguimos ver os passos que ele deu. Vamos fazer
novamente, mas agora inserindo uma função que retarde o R em 1 segundo. Ou seja, cada passo irá
demorar 1 segundo.
> plot(0:10,0:10, type="n")
> for(i in 1:9){
+ text(i,i, paste("Passo", i))
+ Sys.sleep(0.5) ## retarda os passos em meio segundo

+ }
Entendeu o que está sendo feito? No primeiro passo do for, o i é igual a 1, portanto apareceu o
texto "passo 1" na coordenada x=1, y=1 do gráfico. No segundo passo o i é igual a 2 e aparece o texto
"passo 2" na coordenada x=2, y=2, e assim por diante.
O for é um comando bastante utilizado em diversas funções e na simulação de dados. Fique
atento ao uso do for nas funções seguintes e pergunte caso não tenha entendido.
A seqüência de Fibonacci é uma seqüência famosa na matemática (Braun & Murdoch 2007). Os
dois primeiros números da seqüência são [1, 1]. Os números subseqüentes são compostos pela soma
dos dois números anteriores. Assim, o terceiro número da seqüência de Fibonacci é 1+1=2, o quarto é
1+2=3, e assim por diante. Vamos usar a função for para descobrir os 12 primeiros números da
seqüência de Fibonacci (Este exemplo foi retirado e adaptado de: Braun & Murdoch 2007 pp, 48).
> Fibonacci<-numeric(0)
> Fibonacci[c(1,2)]<-1 # o 1° e 2° valores da seqüência devem ser = 1
> for (i in 3:12){ # 3 a 12 porque já temos os dois primeiros números [1,1]

+ Fibonacci[i]<-Fibonacci[i-2]+Fibonacci[i-1]
+ }
> Fibonacci
42
Exercícios
1. Modifique o código para gerar a seqüência de Fibonacci de forma que:
1.1. os dois primeiros elementos da seqüência sejam 2 e 2
1.2. os dois primeiros elementos da seqüência sejam 3 e 2
1.3. modifique o código para que os valores sejam compostos pela diferença entre os dois valores
anteriores.
1.4. modifique o código para que os valores sejam compostos pela diferença entre os dois valores
imediatamente anteriores somada ao terceiro valor imediatamente anterior. Faça inicialmente
com que a seqüência Fibonacci comece com 3 valores [1,1,1].
Brincando com funções

Índice de Diversidade de Shannon
Agora vamos usar o for para fazer uma função mais complexa e também mais útil para nosso dia
a dia. Vamos elaborar uma função que calcula o índice de diversidade de Shannon-Wiener. Este índice,
bastante conhecido entre nós, mede a diversidade em uma comunidade, requerindo para tanto valores
de abundância (absoluta ou relativa). O índice tem seu valor incrementado com o aumento do número de
espécies e com o aumento do componente conhecido como equitatividade. A fórmula do índice de
Shannon é:
onde Pi é a freqüência relativa da espécie na comunidade ( ), ln é o logaritmo natural

e S é a riqueza (número de espécies).
> shannon<-function(dados){ # Cria a função shannon
+ prop<-dados/sum(dados) # calcula o pi
+ resu<-numeric() # objeto numérico vazio que receberá os valores do for
+ n<-length(prop)
+ for(i in 1:n){
+ resu[i]<-if(prop[i]>0){prop[i]*log(prop[i])}
+ else{0} # veja abaixo sobre o uso do if e do else

+ H<- -sum(resu)
+ return(H)
Nota: Durante o cálculo do índice de Shannon precisamos pular do calculo quando o valor
de proporção é zero, porque log(0) não existe (-inf). Por isso usamos o if e o else, ou
seja, se (if) o valor for maior que zero faça o calculo, se não (else) retorne 0.
> log(0) # veja o resultado do log de zero
Usando o if(condição) {comando se TRUE} else{comando se FALSE} a sintaxe

fica diferente do ifelse() em que tanto condição quanto comandos são apresentados nos
argumentos entre parênteses.
43
Agora vamos usar a função shannon para calcular o índice de Shannon dos dados apresentados
no livro da Anne Magurran página 45, tabela 2.1 (Magurran, 1988). Os dados são:
> magur<-c(235,218,192,0,20,11,11,8,7,4,3,2,2,1,1)
# O valor 0 foi alterado propositalmente, no livro o valor é 87.
> shannon(magur)
Esta função que criamos para calcular o índice de diversidade de Shannon calcula o índice de
apenas um local por vez (roda em uma coluna ou vetor apenas). Agora vamos criar uma função que
calcula o índice de Shannon de vários locais ao mesmo tempo, isto é, que aceita uma matriz de dados
com cada coluna representando um local ou unidade amostral. Neste caso teremos que usar o comando
for duas vezes.
> shan<-function(dados){ # nome de shan para diferenciar da função acima
+ nl<-nrow(dados) # número de locais (linhas)
+ nc<-ncol(dados) # número de espécies (colunas)
+ H<-numeric() # variável vazia que receberá os valores H de cada local

+ for(i in 1:nl){
+ prop<-dados[i,]/sum(dados[i,]) ## dados do local i em proporção
+ resu<-numeric()
+ for(k in 1:nc){
+ resu[k]<-if(prop[1,k]>0){prop[1,k]*log(prop[1,k])}
+ else{0}
+ } # Fim do for (k)

+ H[i]<--sum(resu)

+ names(H)<-rownames(dados)
+ return(H)
Vamos calcular o índice de Shannon dos dados de borrachudos (spp).

> shan(spp)
Veja que alguns casos, como no Riacho 4 e 5, o índice foi zero. Como isso é possível. Confira os
dados e veja se faz sentido.
Índice de Similaridade de Jaccard.

Em ecologia de comunidades, um dos índices de similaridade (resemblance measures) mais
básicos e conhecidos é o índice de Jaccard que se aplica para comunidades amostradas por métodos
qualitativos (que registram apenas a presença e ausência
Onde, no caso de uma matriz de espécies: a = número de espécies compartilhadas pelos locais 1 e
2; b = número de espécies presentes apenas no local 1; c = número de espécies presentes apenas no
local 2. Vamos criar uma função para calcular o índice de similaridade de Jaccard:
> jaccard<-function(dados.spp){
44
+ # Vamos inserir uma mensagem de erro, caso dados não sejam de presença-ausência
+ if(any(dados.spp>1))
+ stop("Erro: é preciso fornecer uma tabela com dados de presença e
+ ausência")
+ n<-nrow(dados.spp) # número de locais
+ jac<-matrix(NA,n,n) ## Matriz que receberá os valores de similaridade
+ colnames(jac)<-rownames(dados.spp) ## Dar os nomes dos locais
+ rownames(jac)<-rownames(dados.spp) ## Dar os nomes dos locais

+ for(i in 1:n){
+ for(j in 1:n){
+ # número de espécies presentes em ambos locais, i e j ( a )

+ a<-sum(dados.spp[i,]==1 & dados.spp[j,]==1)
+ # número de espécies presentes apenas no local i ( b )

+ b<-sum(dados.spp[i,]==1 & dados.spp[j,]==0)
+ # número de espécies presentes apenas no local j ( c )

+ c<-sum(dados.spp[j,]==1 & dados.spp[i,]==0)
+ jac[i,j]<- a /(a+b+c) ## Fórmula de Jaccard

+ }
+ }
+ return(as.dist(jac))
+ }
> jac<-jaccard(pres.aus) ## os cálculos demoram um pouco

> jac
Para fim de comparação vamos calcular o Jaccard com o pacote vegan. O R não calcula
similaridade, apenas distâncias (inverso da similaridade). Portanto, usamos 1-distância para recuperar o
valor de similaridade:
> jac.vegan<-1-vegdist(pres.aus,"jaccard")
> jac.vegan
> cbind(jac,jac.vegan) # coloque os valores lado a lado e compare. Está correto?
Índice de similaridade de Bray-Curtis.

Outro índice de similaridade muito utilizado em ecologia, mas para dados de abundância das
espécies é o índice de Bray-Curtis. Esse índice tem como características relevante pesar diferenças nas
abundâncias de espécies raras tanto quanto de espécies comuns:
45
Onde: y1j é a abundância da espécie j no local 1 e y2j é a abundância da espécie j no local 2. Esta
fórmula calcula a dissimilaridade e não similaridade (diferente do exemplo anterior do Jaccard). Então
vamos criar uma função para calcular o índice de similaridade de Bray-Curtis.
> bray<-function(dados.spp){
+ n<-nrow(dados.spp)
+ BrayCurtis<-matrix(NA,n,n)
+ for(i in 1:n){
+ for(j in 1:n){
+ numerador<-sum(abs(dados.spp[i,]-dados.spp[j,]))
+ denominador<-sum(dados.spp[i,]+dados.spp[j,])
+ BrayCurtis[i,j]<- numerador/denominador
+ }
+ }
+ return(as.dist(BrayCurtis))
+ }
Vamos usar nossa função bray para a comunidade de borrachudos e comparar com o resultado
obtido usando a função vegdist do pacote vegan.
> bra<-bray(spp)
> bra.vegan<-vegdist(spp,"bray")
> cbind(bra,bra.vegan)
> bra==bra.vegan ### veja se os resultados são TRUE
EXERCÍCIOS DE CRIAR FUNÇÕES:

1. Você é professor de biologia e, chegando no fim do semestre, precisa calcular as notas de seus
alunos. No entanto, suas avaliações tiveram peso diferente e o cálculo precisa ser de uma média
ponderada. Os dados estão na pasta do curso, no arquivo “alunos.txt”. Cada linha corresponde a uma
avaliação, a primeira coluna indica o peso das avaliações e as demais colunas indicam o os nomes dos
alunos. Quem é o melhor aluno da turma? Olhando para os nomes, era necessário calcular as notas
para responder a pergunta anterior?
2. Crie uma função para calcular o índice de diversidade de Simpson dos dados de borrachudos da
Chapada Diamantina (objeto spp). Faça com que a função possa fazer o procedimento em várias
unidades amostrais ao mesmo tempo.
onde pi é a freqüência relativa de cada espécie.
Confira o resultado usando a função diversity do pacote vegan:
> library(vegan)
> diversity(spp,"simpson",MARGIN=1) # O argumento MARGIN indica se

# você quer fazer os cálculos por linhas ou por colunas. Use 1 para linhas e 2 para colunas.
3. Crie uma função para calcular a distância (dissimilaridade) de Hellinger dos dados de
abundância de borrachudos. A fórmula é:
46
Onde: y1j são os valores de abundância de cada espécie j no local 1; y2j são os valores de abundância
de cada espécie j no local 2; y1+ é a soma total das abundâncias do local 1; y2+ é a soma total das
abundâncias do local 2. Não se assuste com a fórmula, tente dividi-la em partes dentro da função.
Para calcular a distância de Hellinger no R e conferir com resultado da sua função use:
> hel.vegan<-vegdist(decostand(spp,"hellinger"),"euclid")
4. Desafio: Calcule o índice de Shannon usando apenas 3 linhas de comando e o índice de
Simpson usando apenas uma linha de comandos.
DIA 5 – DIFERENÇA ENTRE CRIAR UMA FUNÇÃO E ESCREVER UM CÓDIGO

Existem milhares de formas de se trabalhar em R. Algumas pessoas preferem escrever pedaços de
códigos e executá-lo quantas vezes seja necessário, enquanto outras preferem criar funções mais
automatizadas, mas ambas produzindo o mesmo resultado. Em alguns casos vocês irão se deparar com
códigos e em outros casos com funções. É preciso saber diferenciar os dois tipos, pois seu uso é
levemente diferente e pode gerar confusões.
Vamos gerar um código que escolhe números para a mega sena e depois vamos criar uma função
que faz a mesma coisa.
> njogos<-20 # quantos jogos queremos produzir
> numeros<-matrix(NA,6,njogos) # arquivo que irá receber números dos jogos

> for(i in 1:njogos){
+ numeros[,i]<-sample(1:60,6)
+ }
> numeros
Agora, caso você queira mudar o número de jogos (njogos), é preciso mudar o valor e rodar o
código todo novamente.
Crie agora 50 jogos.
Vamos transformar nosso código em uma função e ver o que muda, apesar dos comandos serem
quase os mesmos.
> megasena<-function(njogos){ # cria a função com nome de megasena
> numeros<-matrix(NA,6,njogos) # cria o arquivo que recebe os jogos

> for(i in 1:njogos){
> numeros[,i]<-sample(1:60,6)
> }
> return(numeros)
> }
> megasena(100)
O interessante em criar uma função, é que após ela estar funcionando você precisa mudar apenas
um argumento, que nesse caso é o njogos.
> megasena(10)
47
> megasena(5)
Em geral, muitas pessoas criam um código, conferem se ele está funcionando e depois transformam
o código em uma função para facilitar o processo de repetição.
CRIAR UMA FUNÇÃO PARA FAZER UM GRÁFICO COMPOSTO (GENÉRICO)

A função generico foi criada para produzir um gráfico que ordena espécies em relação a um
gradiente ambiental. Veja a figura abaixo onde uma comunidade de aves foi ordenada em relação ao
gradiente de altitude. Esta função será bastante utilizada no curso de comunidades e no de estatística
multivariada, portanto é importante que entenda como a função funciona. O código da função segue
abaixo, bem como comentários que explicam o que fazer para usar corretamente a função.
114.7
0.0
Altitude
Ramphastos vitellinus
Lanio fulvus
Bucco capensis
Index Microbates collaris
Hylophilus ochraceiceps
Terenotriccus erythrurus
Corapipo gutturalis
Lipaugus vociferans
Dendrocolaptes certhia
Deconychura longicauda
Myrmotherula gutturalis
Micrastur gilvicollis
Thamnomanes caesius
Relative density of species
Dendrocincla fuliginosa
Galbula albirostris
Mionectes macconnelli
Glyphorynchus spirurus
Dixiphia pipra
Tachyphonus surinamus
Dendrexetastes rufigula
Dendrocincla merula
Phaethornis superciliosus
Turdus albicollis
Pithys albifrons
Formicarius colma
Thalurania furcata
Xiphorhynchus pardalotus
Geotrygon montana
Hylexetastes perrotii
Sclerurus mexicanus
Thamnomanes ardesiacus
Xenops minutus
Frederickena viridis
Percnostola rufifrons
Cyanocompsa cyanoides
Platyrinchus coronatus
Momotus momota
Sclerurus rufigularis
Hypocnemis cantator
Deconychura stictolaema
Myrmotherula menetriesii
Cyphorhinus arada
Hylophylax poecilinotus
Schiffornis turdina
Myrmotherula axillaris
Philydor pyrrhodes
Leucopternis melanops
Myiobius barbatus
Sites
Abaixo segue o código da função genérico, você irá copiar e colar o código no R da parte indicada
abaixo até a parte final indicada no fim da função. Não modifique este código, uma vez que ele seja
colado no R você não precisará copiar e colar novamente, desde que salve o seu workspace.
Script da funcão
#####################Copie e cole no R daqui! ################################
48
# Função para GRÁFICO COMPOSTO (Genérico)

### Criada por Victor Lemes Landeiro ######
### Última atualização em 18-07-2008 ###
generico<-function(tabela,gradiente,at,grad,eixoY,eixoX){
## Começo da função onde são especificados todos os 6 argumentos:
# “tabela”, “gradiente”, at, grad, eixoY, eixoX. Abaixo seguem alguns
comentários e exemplos sobre a função e seus argumentos.
####### Argumentos #######
# generico<-function(tabela, gradiente ,at,"grad","eixoY","eixoX")
# tabela  é a tabela de espécies, uma data frame ou matriz com os dados
das espécies
# gradiente  arquivo com os valores do gradiente
# at  é usado para alterar a posição do nome das espécies no gráfico,
comece com o valor 1 e vá aumentando até os nomes ficarem na posição
desejada.
# grad  é o texto para a legenda que deseja colocar no gráfico
mostrando o nome do gradiente. Esta legenda não pode ser muito longa. Deve
vir entre aspas.
# eixoY e eixoX  são as legendas que deseja colocar nos eixos x e Y.
Deve vir entre aspas.
##Para colocar o nome das espécies no local desejado é preciso mudar o
valor do argumento at
#### Abaixo segue o código da função.

tabela<-as.matrix(tabela)
gradiente<-as.matrix(gradiente)
media.pond<-colSums(tabela*gradiente[,1])/colSums(tabela)
sub.orden<-tabela[order(gradiente[,1],decreasing=F),] # Ordenar parcelas
de acordo com o gradiente
sub.orde<-sub.orden[,order(media.pond,decreasing=T)] # colocar espécies
ordenadas pela média ponderada
dados.pa<-matrix(0,nrow(tabela),ncol(tabela))
dados.pa[tabela>0]<-1
ordenado<-sub.orde[,which(colSums(dados.pa)>0)] ## para deletar possíveis

colunas vazias (espécie que não ocorreu)
49
par(mfrow=c(ncol(ordenado)+1,1),mar=c(0,4,0.2,10),oma=c(3,1,1,6))
layout(matrix(1:(ncol(ordenado)+1)),heights=c(3,rep(1,ncol(ordenado))))
plot(sort(gradiente[,1]),axes=F,ylab="",mfg=c(21,1),lwd=10,las=2,lend="bu
tt",frame.plot=F,xaxt="n",type="h",col="black",ylim=c(min(gradiente),max(grad
iente)))
axis(side=2,at=c(0,max(gradiente)),las=2)
mtext(grad,4,outer=T,font=2,line=-10,padj=-18.5,las=2)
for(i in 1:ncol(ordenado)){
barplot(ordenado[,i],bty="l",axisnames=F,axes=FALSE,col="black")
#axis(side=2,at=max(ordenado[,i]),las=2)
mtext(colnames(ordenado)[i],3,line=-1.0,adj=0,at=at,cex=.8,font=3)
}
mtext(eixoX,1,outer=T,font=2,line=1.2)
mtext(eixoY,2,font=2,outer=T,line=-2)
}
# Este gráfico será construído através de uma matriz de dados de espécies

(Presença e ausência ou abundância) que será ordenada de acordo com a média
ponderada, calculada a partir dos dados de um gradiente ecológico.
############## Até Aqui! ###################################
Exemplo de como usar a função genérico

Depois de copiar e colar a função você precisará digitar apenas a linha abaixo para produzir seu
gráfico genérico. Vamos usar os dados dos borrachudos para fazer o gráfico
> ambi<-simu[,1:6] ## Variáveis ambientais
> spp<-simu[,7:26] ## Dados das espécies

> altitude<-ambi[,6]
>generico(spp,altitude,1,"Altitude(m)","Densidade relativa de
Simuliidae","Ordenado pela altitude")
Agora basta ir mudando o valor at para que o nome saia na posição desejada.
Em geral, esta função irá servir para propostas exploratórias, caso queria usar este gráfico em
alguma publicação talvez seja necessário fazer algumas modificações no código. Uma das restrições é
que o R permite que sua janela gráfica seja dividida em no máximo 50 linhas. Portanto, é impossível
construir esse gráfico para ordenar mais de 48 espécies.
50
REFERÊNCIAS
Braun,W.J. & Murdoch,D.J. (2007) A first course in statistical programming with R, -163, Cambridge
University Press, Cambridge.
Burns, P. 2006. R Relative to Statistical Packages: comment 1 on Techniqucal Report Number 1 (Version
1.0) Strategically using General Purpose Statistics Packages: A look at Stata, SAS and SPSS.
Disponível em http://www.ats.ucla.edu/technicalreports/default.htm
Chambers,J.M. (2008) Software for data analysis: Programming with R. Springer .
Fox, J. The R Commander: A Basic-Statistics Graphical Use Interface to R. Journal of Statistical
Sofware, 14(2). Disponível em http://www.jstatsoft.org/
Owen, W.J. 2007 - The R Guide. Disponível em
http://w ww.m at hc s .r ic h m ond. e du / ~ wo we n/T h eRG u i de .p df
Lam, L. 2007. An Introduction to R. Bussiness and Decision: Amsterdan
nd
Legendre P & Legendre R. 1998. Numerical Ecology. 2 Edition. Amsterdam: Elsevier Science.
Magurran, A.E. Diversidad Ecológica y su Medición. Barcelona: Vedra, 200p.
Oksanen, J., Kindt, R., Legendre, P., O'Hara, R. B., and Stevens, M. H. H (2007) vegan: Community
Ecology Package. R package version 1.8-8. http://cran.r-project.org/, http://r-forge.r-
project.org/projects/vegan/
R Development Core Team (2010) R: A language and environment for statistical computing. R
Foundation for Statistical Computing, Vienna, Austria. ISBN 3-900051-07-0, http://www.R-
project.org.
Venable, W.N., Smith, D.M. and R Development Core Team. 2010. An Introduction to R. Disponível em
http://cran.r-project.org/doc/manuals/R-intro.pdf
Verzani, J. 2002. simpleR - Using R for Introductory Statistics. Disponível em
www.math.csi.cuny.edu/Statistics/R/simplesR/printable/simpleR.pdf
51

Landeiro Et Al 2013 - Introdução Ao Uso de R

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Landeiro Et Al 2013 - Introdução Ao Uso de R

Enviado por

Direitos autorais:

Formatos disponíveis

Landeiro, Zucco, Menezes e Oliveira-Santos, 2010

Introdução ao uso do programa R

 O R é um software livre para computação estatística e construção de gráficos.

Esta versão foi modificada por

Gráficos de barras – barplot(objeto) .......................................................................................... 22

PARA QUÊ APRENDER A USAR O R

NOTA SOBRE O USO DESTA APOSTILA:

DIA 1 – PRIMEIRO CONTATO

A CARA DO R E ALGUMAS INFORMAÇÕES BÁSICAS:

Figura 1 – Layout da interface do R

A sintaxe básica dos comandos de R

 ( ) parênteses SEMPRE aparecem depois de funções contendo os argumentos

O workspace e o working directory do R (área de trabalho).

Como usar um pacote do R

> library(vegan) ## carrega a biblioteca

Como citar o R, ou um pacote do R em publicações

O R como calculadora (operadores matemáticos simples)

> sqrt(3*3^2) # raiz quadrada de 27

> sqrt((3*3)^2) # raiz quadrada de 81

prod(x1,x2,x3,...,xn) é a função para multiplicação da lista de argumentos

> prod(2,2) # O mesmo que 2*2

> prod(2,2,3,4) # O mesmo que 2*2*3*4

> log(3,10) # log de 3 na base 10

Logarítmos em base 2 e 10 possuem atalhos log2(x) e log10(x). Veja:

Para obter valores em módulo, podemos usar a função abs(x)

> abs(3-9) # modulo de 3-9 ou |3-9|

Para fazer o fatorial de algum número use factorial()

> factorial(4) #4 fatorial ou (4!)

Acessar o menu de ajuda do R (HELP!!!!)

O help.search (para quando se está bem perdido)

Também é possível buscar ajuda na internet, no site do R, com a função RSiteSearch()

> RSiteSearch("analysis of variance") # abre uma página na internet, mas

Objetos do R (O que são?):

Como criar objetos

A função length fornece o número de observações (n) dentro do objeto.

Criar vetores com caracteres (letras, variáveis categóricas).

Operações com objetos

> min(aves) # valor mínimo

> sum(aves) # soma dos valores de aves

> aves+2 # adiciona 2 a cada elemento

> aves2/10 # divide os elementos de aves2 por 10

> aves^2 # eleva elementos de aves ao quadrado

> media.aves<-sum(aves)/n.aves # cálculo da média

> media.aves # para ver a média

Acessar valores de elementos de um objeto [colchetes]

> capitais[3] # Qual o terceiro elemento de capitais?

Para excluir um valor, use o sinal de subtração antes do elemento:

> aves[1]<-22 # Vamos voltar ao valor antigo

> aves2[3,2] # Valor na linha 3 e coluna 2

> aves2[3,] # Retorna toda linha 3

Você consegue deduzir o que é aves2[,1]???

> log10(aves) #log(aves) na base 10, apenas

> log(aves) # logaritmo natural de aves

> asin(sqrt(aves/sum(aves))) # arco seno da raiz quadrada da freq. relativa de aves

> aves.log # retorna o novo objeto com valores transformados

Listar e remover objetos salvos

> aves.log # você verá a mensagem:

> seq(1,100,5) # de 1 a 100 em intervalos de 5

> seq(0.01,1,0.02) # vc conseque deduzir como será essa sequência?

> rep("a",5) # repete a letra "a" 5 vezes

> rep(1:4,3) # repete a seqüência de 1 a 4 três vezes

> rep(c("A","B"),5) # repete A B cinco vezes.

> rep(c("A","B"),each=5) # repete A e B cinco vezes.

> rep(c("Três","Dois","Sete","Quatro"),c(3,2,7,4)) # Veja que neste caso a

> prod(2,2,3,4) # O mesmo que 223*4