Apostila Introdução Ao R

2021
Sumário
1. Introdução ............................................................................................................................... 4
2. Como instalar o R ................................................................................................................... 5
2.1. Windows........................................................................................................................... 6
2.2. Rstudio no Windows ...................................................................................................... 13
2.3. OS X ou Linux ............................................................................................................... 18
3. Layout do R........................................................................................................................... 19
4. Noções gerais sobre o R ........................................................................................................ 21
5. Script no R ............................................................................................................................ 23
6. Pacotes do R .......................................................................................................................... 25
6.1. Instalação de pacotes ...................................................................................................... 25
6.2. Uso dos pacotes .............................................................................................................. 29
6.3. Como citar um pacote no R ............................................................................................ 29
7. A ajuda do R ......................................................................................................................... 30
8. Uso inicial do R .................................................................................................................... 32
8.1. Operações e operadores aritméticos ............................................................................... 32
8.2. Operadores lógicos ......................................................................................................... 32
8.3. Objetos (Variáveis) do R ................................................................................................ 33
8.3.1. Vetores .................................................................................................................... 35
Experimental Analytics Corporation – leoazevedop@gmail.com - +55 31 99502 4915

2
8.3.2. Matrizes................................................................................................................... 35
8.3.3. Data frame ............................................................................................................... 37
8.3.4. Listas ....................................................................................................................... 39
8.3.5. Funções ................................................................................................................... 40
8.4. Conversão de tipos de varáveis ...................................................................................... 40
9. Indexação no R ..................................................................................................................... 41
9.1. Indexação de vetores ...................................................................................................... 41
9.2. Indexação de matrizes .................................................................................................... 42
9.3. Indexação de data frame ................................................................................................. 44
9.4. Indexação de listas ......................................................................................................... 46
10. Gerar sequências ................................................................................................................ 47
11. Gerar repetições ................................................................................................................. 47
12. Listar e remover objetos salvos.......................................................................................... 48
13. Gerar dados aleatórios........................................................................................................ 49
14. Fazer amostras aleatórias ................................................................................................... 50
15. Arredondamento ................................................................................................................ 52
16. Ordenar e atribuir postos e ranks ....................................................................................... 53
17. Manipulação dos dados ...................................................................................................... 54
17.1. Definir o local de trabalho (ou dados) ........................................................................ 54
17.2. Importar conjunto de dados para o R.......................................................................... 55

3
17.3. Comando head() e tail() ................................................................................... 57
17.4. Operações com vetores e matrizes.............................................................................. 58
17.5. Salvando arquivos no R .............................................................................................. 61
18. Gráficos básicos no R ........................................................................................................ 61
18.1. Atributos dos gráficos ................................................................................................. 61
18.2. Gráficos de barras ....................................................................................................... 75
18.3. Gráficos de pizza ........................................................................................................ 76
18.4. Gráficos de dispersão.................................................................................................. 77
18.4.1. Gráficos com variáveis numéricas ...................................................................... 77
18.4.2. Gráficos com variáveis explanatórias que são categóricas ................................. 78
18.5. Histogramas ................................................................................................................ 84
19. Estatística ........................................................................................................................... 87
19.1. Estatística descritiva ................................................................................................... 87
19.1.1. Média................................................................................................................... 88
19.1.2. Mediana ............................................................................................................... 88
19.1.3. Moda.................................................................................................................... 89
19.1.4. Variância ............................................................................................................. 90
19.1.5. Desvio padrão ...................................................................................................... 90
19.1.6. Amplitude total.................................................................................................... 91
19.1.7. Erro padrão da média .......................................................................................... 91

4
19.1.8. Coeficiente de variação ....................................................................................... 91
19.1.9. Covariância e correlação ..................................................................................... 92
19.2. ANOVA ...................................................................................................................... 93
19.3. Regressão .................................................................................................................... 96
19.4. Teste de média .......................................................................................................... 102
20. Noções de Programação ................................................................................................... 107
20.1. if() sozinho ........................................................................................................... 107
20.2. if() com o else ................................................................................................... 109
20.3. ifelse() ............................................................................................................... 113
20.4. Vetorização e ifelse() ................................................................................................ 114
1. Introdução
O uso de softwares e pacotes estatísticos para análise de dados é de grande importância, desde
o desenvolvimento e aplicação de métodos até a análise e interpretação de resultados. Contudo,
normalmente observa-se que esses softwares e pacotes apresentam custo de aquisição
relativamente elevado. Atualmente, é grande a procura e também ao incentivo ao uso dos
chamados softwares livres.
Dentre os softwares de domínio público, um em especial tem ganhado destaque e cada vez
mais adeptos e colaboradores têm ajudado para o seu desenvolvimento. Este software é conhecido
como Ambiente R ou simplesmente R. O R é uma linguagem de programação e ambiente de
software para análise estatística, representação gráfica e relatório. É uma linguagem de

5
programação estatística mais utilizada no mundo, além disso é gratuito, tem código fonte aberto,
podendo ser modificado ou implementado com novos procedimentos e funções desenvolvidas
pelos usuários a qualquer momento. Os seguintes são as características importantes do R:
➔ É uma linguagem de programação bem desenvolvida, simples e efetiva que inclui
condicionais, loops, usando funções recursivas definidas e facilidade de entrada e saída;
➔ Possui uma facilidade efetiva de armazenamento e manuseio de dados;
➔ Fornece um conjunto de operações para cálculos em arrays, listas, vetores e matrizes.
➔ Fornece uma coleção grande, coerente e integrada de ferramentas para análises de dados;
➔ Fornece recursos gráficos para análise de dados e exibição diretamente no próprio
computador ou impressão nos papéis.
O R é uma importante ferramenta na análise e manipulação de dados, por apresentar uma gama
de ferramentas como testes paramétricos e não paramétricos, modelagem linear e não linear,
análises de séries temporais, análise de sobrevivência, simulação e estatística espacial, além da
facilidade da elaboração de diversos tipos de gráficos, dentre outros.
2. Como instalar o R
O R pode ser obtido gratuitamente em http://www.R-project.org, onde pode ser encontrado o
software nas versões para os sistemas operacionais Windows, LINUX e OS X (Mac).
Além da plataforma R existe a opção mais interativa conhecida como RStudio que pode ser obtido
em https://www.rstudio.com. O RStudio tem as mesmas funções que o R.

6
2.1. Windows
Os passos para instalação do R em Windows são:
1 – Acesse a página do R.
2 – Clique sobre a palavra CRAN (repositório) na seção download da barra de menu à esquerda
e em seguida escolha um dos servidores (espelho: mirror) disponíveis para a transferência do
arquivo de instalação.

7
3 – Nesta nova página selecione o sistema operacional utilizado em seu computador. Para
Windows ME ou Windows XP selecione a opção Windows (95 and later). Clique então na palavra
base para transferir o arquivo principal de instalação, ou sobre a palavra contrib para escolher
entre os inúmeros pacotes extras disponíveis.
4 – Nesta nova página encontramos o arquivo de instalação principal e algumas outras informações
sobre instalação e novidades com relação aos lançamentos anteriores. Clique então sobre o link
para o arquivo de instalação (Download Setup 3.4.1. for Windows).

8
5 – Na nova janela clique na opção referente a salvar arquivo e selecione a pasta onde o arquivo
será salvo.
6 – Localize o arquivo que foi salvo e clique nele. A seguir selecione a linguagem e clique em OK.
7 – Clique no botão avançar.

9
8 – Em seguida leia o contrato de Licença de Uso e, caso aceite, clique sobre Eu aceito os termos
do contrato e em seguida em avançar.
9 – Selecione a pasta onde o R será instalado, ou caso aceite a sugestão do programa de instalação,
apenas clique em avançar.

10
10 – Existem algumas opções de seleção dos arquivos para instalação, como documentação de
ajuda, manuais, etc. Se estiver instalando o R pela primeira vez, selecione o tipo de instalação
completa e clique em avançar.
11 – Escolha o nome da pasta para o atalho que será criado no menu iniciar, ou aceite a sugestão
e clique em avançar.

11
12 – Selecione o local onde o programa de instalação criará os atalhos e clique em avançar.
13 – Em seguida aparecerá uma tela para você marcar se deseja criar um ícone do R na área de
trabalho além de outras opções. Selecione aquelas que desejar e clique em avançar.

12
14 – Aguarde o programa de instalação copiar os arquivos necessários e efetuar o registro do
programa.
– Clique em concluir para fechar o programa de instalação.

13
2.2. Rstudio no Windows
1 - Para baixar o RStudio entre no endereço www.rstudio.com.
2 - Clique no link Products > Rstudio.
3 - Selecione a versão Desktop.

14
4 - Clique em DOWNLOAD RSTUDIO DESKTOP.

15
5 - Será exibida uma página com a recomendação para você baixar o RStudio 0.99.467 - Windows
Vista/7/8.
6 - Clicando nesse link, você irá baixar o arquivo RStudio-0.99.467.exe.

16
7 - Depois é só clicar no setup que foi salvo e começar a instalar. Clique em next.
8 – Escolha o diretório onde o programa será instalado. Clique em next.

17
9 - Escolha o nome do folder que você deseja criar e clique em install.
10 – Em seguida é só esperar o software ser instalado.
11 – Clique em finish para terminar o processo de instalação.

18
Após a instalação, você pode abrir o RStudio pelo ícone, e o estará pronto para ser utilizado.
2.3. OS X ou Linux
1 - Para instalar o R no linux basta digitar o seguinte comando via Terminal:
sudo apt-get install r-base-core
2 – Caso seja solicitado a instalação do pacote “libjpeg62”, basta inserir o nome do pacote no
comando citado acima. Vale ressaltar que, para utilizar o RStudio, a versão do R deve ser igual
ou superior a v.2.11.1.
3 - Agora, para a instalação do RStudio, além de fazer o download do programa
(http://www.rstudio.com/ide/download/desktop), os seguintes pacotes são
necessários:”libssl0.9.8″, “libapparmor1” e “apparmor-utils”. Para instala-los, basta usar o mesmo
comando anterior:
apt-get install libssl0.9.8 libapparmor1 apparmor-utils

19
4 - A instalação do RStudio, por ser disponibilizado em formato binário (.deb), basta estar na pasta
onde o arquivo foi salvo e executar o comando:
sudo dpkg -i rstudio-0.97.551-i3862.deb
5 - Uma vez executado, é preciso entender e se adaptar ao novo sistema que agora permite
visualizar, não apenas o console do R, mas também visualizar os gráficos gerados, todos os objetos
do workspace e etc., no mesmo ambiente através de diferentes janelas que podem ser configuradas
conforme o seu gosto e necessidade.
3. Layout do R
O layout do R é bem simples. Onde apenas a tela de console é exibida na tela inicial do R.
Nesta tela o usuário pode digitar diretamente nela e todos os resultados também serão
mostrados nela. Além disso o usuário pode digitar em uma tela especial chamada script (Editor do
R) que nada mais é do que uma tela de texto.

20
Já o RStudio apresenta quatro telas na sua interface inicial: A tela do console e a tela do
script que são iguais as telas do R, e tela do history que mostra todas as funções que foram
executadas no RStudio e a tela onde são exibidos os arquivos (file), os gráficos (plot), os pacotes
(packages) e a tela de ajuda (help).

21
4. Noções gerais sobre o R
Na barra de ferramentas do R existe basicamente cinco abas: Arquivos, Editar, Pacotes, Janelas
e Ajuda.
Na aba de arquivos o usuário pode criar um script, abrir um novo script, fechar um script que
já não está sendo usado, e salvar um script que ainda não foi salvo ou a tela do console do R.
Quando se salva a tela do console do R todas as funções que foram executadas e arquivos criados
ficam salvos.
Na aba Editar é possível recortar, copiar, colar ou excluir qualquer parte de um script ou
texto escrito no console. Ainda tem as opções executar linha de comando (Ctrl + R), selecionar
tudo (Ctrl + A), executar tudo, localizar (Ctrl + F) e substituir (Ctrl + H). Existe também a função
de limpar o console (Ctrl + L). Além disso tem a aba preferencias de interface gráfica onde o
usuário pode mudar formatação de letra, cor de fundo, entre outras funções.

22
Na aba Pacotes existem as opções instalar, atualizar e carregar pacotes, escolher o espelho
CRAN, selecionar repositórios. E install packages from local files que é utilizado quando o arquivo
do pacote já existe no computador e deseja-se instalar o pacote via este arquivo.
Na aba Janelas existem as opções de posicionar as janelas (console, script, janela gráfica)
na posição desejada tais como Cascada, Dividir na Horizontal, e Dividir Lado a Lado.

23
Na aba Ajuda encontra-se todos os locais onde é possível buscar ajuda sobre funções e
pacotes no R tais como Manuais (em PDF), Funções R (texto), Ajuda Html, Procurar na ajuda,
search.r-project.org, Página principal do projeto R, e Página principal do CRAN.
5. Script no R
Uma maneira que otimiza o uso do R e que poupa muito tempo é usar um script (um arquivo
.txt) para digitar seus comandos. Neste caso, os comandos não são digitados diretamente na linha
de comandos (console do R) e sim em um editor de texto (por exemplo: R editor, notepad, tinn-
R). Um script do R é apenas um arquivo .txt onde você digitará todos os comandos e análises.
Ao usar um script você pode facilmente fazer alterações e correções em seus comandos, pois
salvando o script você poderá refazer rapidamente suas análises, por exemplo, caso algum revisor
de um de seus artigos solicite uma mudança em uma de suas análises ou em um de seus gráficos.

24
Para criar um script dentro do RStudio clique em File no menu do R, depois clique em
New File (Novo arquivo) e clique em R script. Uma janela será aberta (veja figura abaixo). O
script aparece com o nome de “Untitled1” (Sem título 1). Para salvar o seu script após digitar seus
comandos dê um nome ao arquivo e inclua a extensão “.R” no final do nome (p. ex. análises.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” para passar para a linha de
baixo e escreva outro comando (recomendação: cada comando deve ser digitado em uma linha
diferente). 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=2+2 # Operação matemática: somatório em que o resultado será armazenado no objeto
de nome x.

25
6. Pacotes do R
Pacotes ou bibliotecas são os nomes mais usados para designar um conjunto de funções
(comandos) e, ou, dados agrupados. As funções básicas do R por exemplo estão em uma biblioteca
chamada “base”. Existem inúmeras bibliotecas e algumas já estão inclusas na instalação padrão do
R. Várias delas foram desenvolvidas por usuários do R que, em determinado momento, julgaram
importante criar funções que suprissem suas necessidades. Depois, esses usuários disponibilizaram
estas funções na forma de um pacote (uma biblioteca) com certo nome, para que outras pessoas
que necessitem usar as mesmas funções não precisem implementá-las novamente. É essa
colaboração mútua que faz do R um programa amplo e interdisciplinar.
6.1. Instalação de pacotes
A instalação de pacotes no R base é simples e requer apenas alguns passos.

26
1 – Abra o R como mostrado anteriormente e clique na barra de ferramentas em pacotes -> instalar
pacotes.
2 – Escolha o espelho que deseja utilizar e clique em ok.
3 – Escolha o pacote que deseja instalar como por exemplo o pacote ExpDes muito útil em
estatística experimental. Depois clique em ok para instalar.

27
4 - Pronto. Agora é só usar o pacote.
A instalação de pacotes no RStudio:
1 – Abra o RStudio como mostrado anteriormente e clique na barra de ferramentas em
ferramantas -> instalar pacotes.

28
2- Digite o nome do pacote (por exemplo: MASS) na caixa em azul (figura abaixo). Depois aperte
o botão instalar.

29
Outra forma de instalar pacotes é pela função install.packages("NOME DO PACOTE").
O argumento dependencies = TRUE é usado para ativar a instalação das dependências do pacote,
como segue:
install.packages("MASS", dependencies=TRUE)
6.2. Uso dos pacotes
Não basta apenas instalar um pacote. Para usá-lo é necessário "carregar" o pacote sempre que você
abrir o R e for usá-lo. Use a função library(NOME DO PACOTE) para carregar um pacote.
Digite na linha de comandos do R:
Após isso a funcionalidade do MASS estara pronta para serem usadas.
OBS: Lembre-se que sempre que abrir o R será necessário carregar o pacote novamente.
DICA: Ao criar um script, deixe os comandos de carregar os pacotes library() que serão
utilizados nas análises, nas primeiras linhas. Pois, toda vez que você abrir e executar o script, os
pacotes serão carregados.
6.3. Como citar um pacote no R
No R existe um comando que mostra como citar o R ou um de seus pacotes. Veja como
fazer:
citation() #Mostra como citar o R

30
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 MASS, basta colocar o nome do pacote entre aspas.
citation("MASS") #citanto um pacote no R
7. A ajuda do R
A ajuda em linha do R pode ser muito útil quando se deseja saber como empregar certa função.
Considere o seguinte exemplo de aplicação da ajuda em linha do R.
Exemplo: Suponha que você deseja fazer um histograma de um conjunto de dados (um vetor)
armazenado em um objeto chamado “test”, porém, tem necessidade de colocar em azul a cor das
barras no histograma. Suponha ainda que você já saiba que o comando que cria histograma é o
hist(). Assim, se você quiser obter informações sobre este comando, inclusive como trocar a
cor das barras, digite: help(hist)ou simplesmente ?hist.
A ajuda sobre o comando que cria histograma irá aparecer na Janela Direita Inferior do RStudio.
(Olhar a imagem abaixo).

31
As seguintes formas de ajuda podem ser obtidas no R.
1 – Obter ajuda sobre o comando X – help(comando X);
2 – Obter ajuda sobre um pacote Y – help(package=Y);
3 - Procurar por uma estatística W em todos os pacotes instalados – help.search(“W”);
4 – Comando para procurar objetos com um determinado nome como por exemplo modelo –
apropos(“modelo”);
5 – Mostrar exemplos do comando X – example(comando X);
6 – Listas as funções e operações contidas no pacote base do R – ls(“package:base”).
7- Ver a variedade de coisas que R pode fazer. demo(graphics)

32
8. Uso inicial do R
8.1. Operações e operadores aritméticos
A linguagem R permite executar operações aritméticas básicas (soma, subtração,
multiplicação, divisão e potenciação):
Operadores Nome Operações

+ Somatório 5+2
- Subtração 3-2
/ Divisão 10/2
* Multiplicação 2*2
^ ou ** Potenciação 5^3
Digite no R os seguintes comandos:
2+2
2*2
2/2
2-2
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
8.2. Operadores lógicos
Alguns dos principais operadores lógicos estão descritos na tabela a seguir:
Operadores Descrição
< Menor que ...
> Maior que ...
<= Menor igual que ...
>= Maior igual que ...
== Igual à ...

33
& E (para vetores)

| Ou (para vetores)
!= Diferente de ...
! Não ...
is.na() Valor numérico ou faltante
Digite no R os seguintes comandos:
7 > 4
2 == 2
1 != 4
2 < 8
8.3. Objetos (Variáveis) do R
Para que o R deixe de ser uma simples calculadora, será necessário aprender, dentre outras
coisas, o uso de variáveis. No contexto do R, vamos entender variável como um objeto, ou seja,
como uma estrutura predefinida que vai “receber” algum valor. Utilizando uma linguagem mais
técnica, objeto (ou variável) é um pequeno espaço na memória do seu computador onde o R
armazenará um valor ou resultado de um comando, utilizando um nome que você mesmo definiu.
Para criar um objeto, utiliza-se o símbolo <- ou =
Exemplo:
x <- 10 # O objeto x representa o valor 10. Para comprovar, execute apenas o nome do objeto
x, o R mostrará o conteúdo dele.
x + 5 # Operação de soma utilizando o objeto x
y <- x + 5 # Armazenado o processo de soma em um novo objeto de nome y.
OBS: Todos os objetos que forem criados estarão disponíveis na aba Ambiente. Na Janela Direita
Superior do RStudio.

34
É importante destacar que o nome de um objeto deve começar com uma letra qualquer,
maiúscula ou minúscula, que pode ser seguida de outra letra, número ou caracteres especiais como
um ponto (.) ou underline ( _ ).
Exemplo:
x <- 7 # o objeto x receberá o valor 7
z = 32 # o objeto z receberá o valor 32
idx_1 = 15 # o objeto idx_1 receberá o valor 15
Observe que existe diferença entre maiúscula e minúscula. Por exemplo:
X <- 8
x <- 8
Os objetos X e x são diferentes.
OBS: O nome do objeto não pode ter símbolos de funções ou operações matemáticas (+, /, -, *, ^)
e nem espaço entre os nomes dos objetos.
Todo objeto em R tem uma classe, que pode ser descoberta usando a função class().
Os objetos-vetores podem ser do tipo numeric, logical, character, integer, fator e etc. Outros
objetos incluem matrizes, data frames, funções, listas, arrays.
Existem muitos tipos de objetos no R que só passamos a conhecê-los com o passar do
tempo. Por enquanto vamos aprender os tipos básicos de objetos.
Exemplo:
inteiro = 5L

35
numeric = 12.3 ou 12 ou 5e2
caracter = “teste”
logico = FALSE ou TRUE
8.3.1. Vetores
Uma sequência de valores numéricos ou de caracteres (letras, palavras) organizados em apenas
uma dimensão, sendo que todos os seus elementos constituintes devem ter, obrigatoriamente, a
mesma natureza (classe).
A função c() é usada para criar um vetor a partir de seus argumentos. Exemplos:
x <- c(8,9,11,35,4) # criando um vetor de valores numericos
y <- c("Acapu", "Araucaria", "Mogno", "Cedro", "Ipe")
OBS: A função assign() também pode ser usada para concatenar.
Exemplo:
c("Acapu", "Araucaria", "Mogno", "Cedro", "Ipe")
assign("especie", c("Acapu", "Araucaria", "Mogno", "Cedro",
"Ipe"))
8.3.2. Matrizes
As matrizes diferenciam-se dos vetores por admitirem duas dimensões, expressas por linhas e
colunas. Uma matriz pode ser formada por elementos numéricos e/ou caracteres (strings) na sua
estrutura.

36
A construção de matrizes no R pode ser feita com uso das funções rbind()e cbind().
As funções rbind() e cbind() organizam objetos-vetores em linhas ou colunas,
respectivamente. No entanto, o mecanismo mais eficiente para construir matrizes é por meio
da função matrix().
Quando utilizadas as funções rbind() e cbind() para construir matrizes a partir de
vetores de diferentes classes, todos os dados numéricos da matriz são convertidos em
caracteres, fato evidenciado pelos números entre aspas na saída.
- rbind()
v_1 = c(1, 3, 4, 6)
v_2 = c(10, 14, 12, 17)
v_3 = c ("a", "b", "c", "d")
m_1 = rbind(v_1, v_2); m_1
class(m_1)
m_2 = rbind(m_1, v_3); m_2
- cbind()
m.1 = cbind(v_1, v_2); m.1
m.2 = cbind(m.1,v_3); m.2
- matrix()
mat_2 = matrix(c(1,2,3,4,5,6), nrow=2, ncol=3)
mat_3 = matrix(1:12, ncol=3)
No exemplo mat_3 foi constituída uma matriz de 3 colunas e 4 linhas, usando-se os
números de 1 a 12. Note que a matriz é preenchida ao longo das colunas. Para inverter este padrão

37
deve-se adicionar o argumento byrow=TRUE, para dizer que a matriz deve ser preenchida por
linhas.
Exemplo:
mat_3 = matrix(1:12, ncol=3, byrow=TRUE) # preenchendo por linhas
Você pode verificar a dimensão de uma matriz com a função dim() como segue:
dim(mat_3) # dimensões da matriz y
O valor retornado é um vetor com o número de linhas e colunas da matriz, nesta ordem. A
função summary() opera em cada coluna da matriz como se cada uma delas fosse vetor,
calculando algumas medidas descritivas.
Exemplo:
summary(mat_3)
Se deseja um resumo de todos os elementos da matriz deve-se utilizar o comando
summary(as.numeric(x)).
8.3.3. Data frame
São muito parecidos com matrizes. Entretanto, diferentemente das matrizes, cada coluna pode
armazenar elementos de diferentes tipos (numérico, caracteres, lógicos, complexos, inteiros).
Geralmente nós guardamos nossos dados em objetos do tipo data frame, pois sempre temos
variáveis numéricas e variáveis categóricas (por exemplo, largura do rio e nome do rio,
respectivamente).
Esse tipo de objeto é a melhor forma de armazenar dados, pois cada linha corresponde a uma
unidade, indivíduo ou pessoa, e cada coluna representa uma medida realizada em cada unidade,

38
ou quando temos um conjunto de dados oriundos de um experimento planejado que será
posteriormente submetido a uma análise de variância, por exemplo.
Para criar data frames diretamente no R pode-se usar a função data.frame().
Exemplo:
alunos <- data.frame(c("José da silva", "Pedro de Souza", "Carlos
Santos", "Rodrigo Pereira", "Tiago Castro", "Felipe Sena", "Diogo
Santolin"), c(32,35,16,23,25,22,23),c("Ensino Médio", "Ensino
Médio", "Ensino Médio", "Ensino Superior", "Ensino Superior",
"Ensino Superior", "Ensino Superior"), c("primeiro", "terceiro",
"primeiro", "segundo", "terceiro", "segundo", "segundo"),
c("repetente", "repetente", "não_repetente", "não_repetente",
"repetente", "não_repetente", "não_repetente"))
colnames(alunos) <- c("Nomes", "Idade", "Escolaridade",
"Situação", "Repetente")
Após criar um data frame, é interessante avaliar a sua estrutura por meio das funções
str() e dim(). A função str() retorna as colunas com suas respectivas classes e número de
observações por variável. A função dim() informar as dimensões do data frame (número de
linhas e colunas).
dim(alunos)
str(alunos)
Ainda, deve-se notar que a função data.frame() transforma, por default, as variáveis qualitativas
em fatores (classe factor) com a especificação da quantidade de níveis (levels). Isso ocorre devido à

39
argumentação stringsAsFactors = TRUE que por padrão transforma qualquer variável
qualitativa em fator. Caso a transformação não seja desejável, basta modificar o comando para
stringsAsFactors = FALSE. Assim, as variáveis qualitativas serão mantidas no formato
character. Exemplo:
data.frame(x, stringsAsFactors = FALSE)
8.3.4. Listas
São objetos muito úteis, pois são usados para combinar diferentes coisas em um mesmo objeto,
ou seja, vetores, matrizes, números e, ou, caracteres e até mesmo outras listas. A função para
criação de uma lista é list().
Diferentemente do data.frame, as listas admitem vetores de comprimentos distintos. O
número de componentes de uma lista (nível superior) pode ser obtido usando a função
length(). Os componentes da lista são introduzidos usando a forma usual (nome=argumento)
de atribuir argumentos em uma função. Quando você exibe um objeto que é uma lista, cada
componente é mostrado com o seu nome (precedido do símbolo $) e valor.
Exemplos:
ID <- list(nome="Pedro", idade=18, notas=c(75,86,98))
length(ID)
Quando a intenção for unir diferentes listas em um único objeto pode-se usar a função c().
ID_1 <- list(nome="Carlos", idade=19,notas=c(80,93,88))
ID_2 <- c(ID, ID_1); ID_2

40
8.3.5. Funções
As funções criadas para fazer diversos cálculos também são objetos do R. Entenda função
como uma sequência de comandos preparados para serem usados de forma simples e, assim,
facilitar sua vida. Funções são usadas para tudo que você possa imaginar: cálculos mais
complexos, estatística, análise de dados, manipulação de dados, gráficos, relatórios etc. Assim que
você o instala, o R já vem configurado com várias funções prontas para uso. A partir de agora,
chamaremos esse conjunto de funções que já vem por padrão como R de R Base. Claro que as
funções do R base não serão suficientes para resolver todos os problemas que você encontrará pela
frente. Nesse sentido, o R também mostra outro ponto forte. Você pode instalar conjuntos extras
de funções específicas de maneira muito simples: usando pacotes.
raiz.quadrada <- sqrt(16)
logaritimo = log(10)
OBS: Objeto funções é visto em um curso específico.
8.4. Conversão de tipos de varáveis
Quando é feito o carregamento de algum arquivo de dados no R, ele tenta “deduzir” os tipos
de dados de cada coluna. Nem sempre essa dedução sai correta e, vitualmente, você precisará,
converter de um tipo para o outro. O R tem algumas funções para fazer essas conversões
(as.numeric, as.character, as.integer, etc).
Exemplo:
class("2015")
as.numeric("2015")
as.character(55)

41
as.interger(3.14)
as.logical(1)
as.factor(“M”)
as.numeric(FALSE)
9. Indexação no R
Quando o interesse é extrair, excluir ou substituir elementos de objetos é possível fazê-lo
por meio de algum mecanismo de indexação, que dependerá do tipo de objeto manejado. Para
isso, utilizam-se operadores básicos para localizar a posição do elemento.
Para indexar elementos ou subconjuntos de objetos no R existem três operadores básicos: [ ],
[[ ]] e $.
9.1. Indexação de vetores
Para extrair, excluir ou substituir elementos no objeto-vetor usa-se o comando [ i ]. O índice i
indica a posição do elemento no objeto e inicia-se no valor 1. A função c() pode ser usada para
concatenar as posições desejadas dentro de colchetes
nome <- c("Carlos", "Fernando", "Caio", "Bruno")
idade <- c(32, 45, 18, 38)
1. Extração por indexação positiva: específica (entre colchetes) os elementos a serem
extraídos.
nome[2]
idade[1:3]
nome[c(1,3)]

42
2. Extração por indexação negativa: específica (entre colchetes) os elementos a serem

excluídos, retornando os demais. Deve-se usar o sinal negativo (-) para um ou mais
elementos do objeto-vetor que se deseja excluir [ -i ].
nome[-2]
idade[-(1:3)]
nome[-c(1,3)]
3. Extração por indexação lógica: a extração de elementos no objeto-vetor pode ser feita
com uso de operadores lógicos.
idade > 33
idade[idade > 33]
4. Substituição por indexação: algumas vezes deseja-se substituir um ou mais elementos do

objeto-vetor por outro.
nome[4] <- "Maria"
9.2. Indexação de matrizes
Para extrair, excluir ou substituir elementos de uma matriz usa-se o comando [ i, j ]. O índice
i indica as linhas e o índice j indica as colunas da matriz.
• Se o argumento for do tipo [i, ] ter-se-á acesso a todos os elementos da linha i
especificada.
• Se o argumento for do tipo [ , j] ter-se-á acesso a todos os elementos da coluna j
especificada.

43
• Se nem o número da linha e nem o número da coluna é informado [ , ]: a matriz é
acessada por completa.
1. Extraindo elementos: usando indexação positiva.
M <- matrix(1:9, nrow=3,ncol=3,byrow=T)
colnames(M) <- c("C1", "C2", "C3")
rownames(M) <- c("L1", "L2", "L3")
M[2,2]
M[1,]
M[,3]
M[c(1,3),c(2,3)]
2. Extraindo elementos: usando indexação negativa.
print(M)
M[,c(-1,-3)]
M[-1,-3]
3. Substituir elementos
print(M)
M[1,1] <- 10; M
M[c(2,3)] <- c(0,0) # Substitui elementos nas posições 2 e 3 por zero. A contagem é
feita por coluna (default)

44
4. Extração por indexação lógica: a extração de elementos no objeto-matriz pode ser feita
M >= 5
9.3. Indexação de data frame
O acesso a um determinado vetor em um data frame pode ser realizado utilizando-se do
comando [ ] (similar às matrizes) ou dos comandos [[ ]] e $ (similar às listas).
inf <- data.frame(nome = c("Maria", "Lucia", "Carla", "Julia"),
idade = c(25,41,30,19), altura = c(1.65, 1.74, 1.70, 1.60), filho
= c("Não", "Sim", "Sim", "Não"), stringsAsFactors = TRUE)
1. Comando [ ] e [[ ]]
inf[2,1]
inf[[2,1]]
inf[,c(1,2,4)]
2. Comando $
inf$idade
inf$idade[c(2,4)]
3. Adicionar linhas ou colunas ao data frame
inf$casada <- c("Sim", "Sim", "Não", "Não")
inf[5,] <- c("Tereza",38,1.81,"Sim","Sim")

45
## Warning message:
## In `[<-.factor`(`*tmp*`, iseq, value = "Tereza") :
## invalid factor level, NA generated
inf$nome <- as.character(inf$nome)
inf[5,] <- c("Tereza",38,1.81,"Sim","Sim"); inf
Quando adicionamos um novo vetor-linha, o que acontece?
Surgirá uma mensagem de erro atestando que o nível de fator é inválido. Isso ocorre porque o
nome “Tereza” foi adicionado com classe character e a coluna nome está como classe factor.
Assim, um NA será impresso no lugar do nome “Tereza”. Idealmente, para evitar problemas deste
tipo, pode-se manter todas as colunas qualitativas como character. Para tanto, deve-se usar o
argumento stringsAsFactors = FALSE ou transformar a coluna nome em character
usando o seguinte comando:
inf$nome = as.character(inf$nome)
inf$casada == "Sim"
inf[inf$casada == "Sim",]
A função split() pode ser usado para dividir data frame. Para tanto, especifique dois
argumentos básicos: a) data frame que se almeja dividir; b) fator a ser considerado para a divisão.
casada <- split(inf, inf$casada)

46
9.4. Indexação de listas
A indexação de lista pode ser feita com uso dos comandos [[ ]] e $. Ainda, para acessar sub-
índices dos componentes da lista pode-se fazer: [[ ]][ ]. Para exemplificar, considere a lista
“list.1” que contém 3 componentes (vetor, matriz e data frame):
list.1 = list(idade=idade, matriz=M, DF=inf); list.1
list.1[[1]]
list.1[[2]][1,]
Se a lista estiver seus componentes nomeados o acesso é facilitado pelo uso de comando $.
list.1$DF
list.1$DF[2,]
list.1$matriz[c(2,5,7,8,9)] <- c(2,3,7,8,9) # Substituindo os elementos das
posições 2, 5, 7, 8 e 9 por 2,
3, 7, 8 e 9.
list.1$idade <- NULL # Excluindo componentes da lista
list.1
list.1$DF <- list.1$DF[-5,] # Excluindo linha 5 do componente DF
list.1[[3]][list.1[[3]][2] > 29,]
Você pode exibir os componentes da lista com a função names(). Exemplo:

47
names(list.1) # Exibi todos os componentes da lista list.1
10. Gerar sequências
Uma forma especial de se gerar um vetor é gerando uma sequência. Por exemplo, para se gerar
uma sequência de números inteiros usam-se os : como segue:
a<-1:10 # cria sequência de inteiros de 1 a 10
Se o vetor é muito longo e não “cabe” em uma linha, o R vai usar as linhas seguintes para
continuar imprimindo o vetor como pode ser visto a seguir:
z<-1000:950 # sequência decrescente de 1000 a 950
Uma forma mais comum de produzir sequências de valores é usar a função seq(), que tem como
argumentos o início, o fim, e os passos da sequência, respectivamente.
seq(20,30,1) # o mesmo que 20:30
seq(1,10,2) # observe que não terminará em 10
seq(10,1,3) # ordem inversa, equivocada
seq(10,1,-3) # o correto é usando passos negativos
11. Gerar repetições
Outra função útil para produzir vetores é a rep(), que retorna o primeiro argumento repetido o
número de vezes indicado pelo segundo argumento:
rep(1,10) # cria uma repetição

48
rep(c(1,2),10) # cria repetições alternadas de 1 e 2
c(rep(0,10),rep(1,5)) # cria um vetor onde os primeiros 10 elementos são 0 e os cinco
últimos são 5.
Pode-se ainda usar variáveis como argumento da função como segue:
x<-20
rep(c(1,2),x) # repetição de “c(1,2)” x vezes
Se ambos os argumentos têm mais de um elemento, cada elemento do primeiro argumento
será associado ao elemento correspondente do segundo argumento.
Exemplos:
rep(7:10,1:4)
rep(c(99,88,77),c(3,2,1))
12. Listar e remover objetos salvos
A função ls() mostra os objetos que existem em sua área de trabalho. Por exemplo:
A <- 1; b <- 2; c <- 3 # use ; para separar os comandos
x <- "uso"; y <- "do comando"; z <- "list()"
ls() # lista todos os objetos existentes na memória
A função para remover objetos no R é remove(), ou simplesmente rm(). Para usar esta
função basta fornecer o objeto a ser removido como segue:
A<-6 # cria o objeto A

49
B<-10 # cria o objeto B
rm(A,B) # remove os objetos A e B
Para remover todos os objetos de sua área de trabalho digite:
rm(list=ls()) # remove tudo
OBS: Tome cuidado ao usar esta função, pois uma vez excluído o objeto, este se torna
irrecuperável.
13. Gerar dados aleatórios
Várias funções são utilizadas para gerar dados aleatórios no R. A seguir são mostradas as
principais. runif() é utilizada para gerar dados aleatórios com distribuição uniforme. Veja:
runif(n, min=0, max=1) # gera uma distribuição uniforme com n valores, começando em
min e terminando em max.
runif(200,80,100) # gera 200 valores que vão de um mínimo de 80 até um máximo de 100
temp<-runif(200,80,100)
hist(temp) # Faz um histograma de frequências dos valores
A função rnorm() é utilizada para gerar dados aleatórios com distribuição normal. Veja:
rnorm(n, mean=0, sd=1) # gera n valores com distribuição uniforme, com média 0 e
desvio padrão 1.
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 padrão 10
hist(temp2) # Faz um histograma de frequências dos valores
Além destas funções a tabela a seguir mostra outras funções para as mais variadas distribuições.

50
Distribuição Função
Beta rbeta(n,shape1,shape2)
Binomial rbinom(n,size,prob)
Binomial negativa rnbinom(n,size,prob)
cauchy rcauchy(n,location=0,scale=1)
Estatística de Wilcoson’s rwilcox(nn,m,n,n),
rsignrank(nn,n)
Exponencial rexp(n,rate=1)
Fisher-Snedecor (F) rf(n,df1,df2)
Gamma rgamma(n,shape,scale=1)
Gauss (normal) rnorm(n,mean=0,sd=1)
Geométrica rgeom(n,prob)
Hipergeométrica rhyper(nn,m,n,k)
Logística rlogis(n,location=0,scale=1)
Log-normal rlnorm(n,meanlog=0,sdlog=1)
Poisson rpois(n,lambda)
Qui-quadrado rchisq(n,df)
Student (t) rt(n,df)
Uniforme runif(n,min=0,max=1)
Weibull rweibull(m,shape,scale=1)
O significado de todos os parâmetros pode ser verificado no help() do R para cada função
exemplificada acima. Veja também o help() da função ?Distributions para conhecer
outras formar de gerar dados aleatórios com diferentes distribuições.
14. Fazer amostras aleatórias
A função sample() permite gerar amostras aleatórias de um determinado vetor ou
conjunto de dados, com ou sem reposição dos elementos sorteados. Ao usar a função é
necessário usar conjuntamente a função set.seed() para garantir a reprodutibilidade dos
números aleatorizados. Caso a função set.seed() não seja inserida, a cada execução da
função sample() um novo conjunto de amostras aleatórias será gerado. Funciona assim:

51
sample(x, size=1, replace = FALSE), onde x é o conjunto de dados do qual as
amostras serão retiradas, size é o número de amostras e replace é onde você indica se a
amostra deve ser feita com reposição (TRUE) ou sem reposição (FALSE). Veja:
set.seed(1)
sample(1:10,5) # tira 5 amostras com valores entre 1 e 10
Como não especificamos o argumento replace o padrão é considerar que a amostra é sem
reposição (= FALSE).
sample(1:10,15)
Neste exemplo ocorre erro, pois a amostra é maior que o conjunto de valores, temos 10
valores (1 a 10) portanto não é possível retirar 15 valores sem repetir nenhum! Assim:
sample(1:10,15,replace=TRUE)
Com a função sample() nós podemos criar vários processos de amostragem aleatória.
Por exemplo, vamos criar uma moeda e "jogá-la" para ver quantas caras e quantas coroas saem em
10 jogadas.
moeda<-c("CARA","COROA") # primeiro criamos a moeda
sample(moeda,10, replace=TRUE)

52
15. Arredondamento
Muitas vezes, numa certa análise estatística, podemos estar interessados em apresentar os
resultados com certo número de casas decimais. Assim existem alguns comandos utilizados para
aproximações e arredondamentos.
O comando round() é usado quando se deseja arredondar um valor ou um conjunto de
valores em um número preestabelecido de casas decimais. Por exemplo:
x<-pi # x recebe o valor de pi
x # exibindo x
round(x,3) # arredondando para 3 casas decimais
O comando round() ora suado não alterou, por exemplo, o valor de x, apenas o exibiu
arredondando em 3 casas decimais. Para que x assuma o valor arredondado, deve-se fazer:
x<-round(x,3) # x recebe valor arredondado
Truncar um valor significa considerar apenas a parte inteira deste, descartando seus
decimais, sem qualquer tipo de arredondamento. Isso pode ser feito no R usando o comando
trunc() como visto a seguir:
pi # valor de pi
trunc(pi) # valor de pi truncado
Por vezes desejamos arredondar ou aproximar valores desconsiderando-se o número de
casas decimais, mas não o de algarismos significativos. Isso pode ser feito com o comando
signif(). Veja a comparação com o round():
pi # valor de pi

53
signif(pi,3) # com 3 algarismos significativos
round(pi,3) # arredondado com 3 casas decimais
Adicionalmente, os comandos celling() e floor() podem ser usados para aproximar
um valor para o menor inteiro superior ao valor especificado (teto) e o maior inferior ao valor
especificado (piso) como segue no exemplo:
pi # valor de pi
ceiling(pi) # teto
floor(pi) # piso
16. Ordenar e atribuir postos e ranks
Primeiro vamos criar um vetor desordenado para servir de exemplo:
exemplo <- sample(1:100,10) # amostra ao acaso 10 valores entre 1 e 100
exemplo
A função sort() coloca os valores de um objeto em ordem crescente ou em ordem
decrescente.
sort(exemplo) # para colocar em ordem crescente
sort(exemplo, decreasing=TRUE) # para colocar em ordem decrescente
A função order() retorna a posição original de cada valor do objeto "exemplo" caso os valores
do objeto "exemplo" sejam colocados em ordem.
order(exemplo)

54
Note que o primeiro valor acima é 53, isso indica que se quisermos colocar o objeto
"exemplo" em ordem crescente o primeiro valor deverá ser o sétimo valor do "exemplo", que é o
valor 1 (o menor deles). Na sequência devemos colocar o quarto valor do objeto "exemplo", que é
3, depois o terceiro, depois o sexto… até que objeto "exemplo" fique em ordem crescente.
order(exemplo,decreasing=TRUE)
É importante entender o comando order(), pois ele é muito usado para colocar uma
planilha de dados seguindo a ordem de alguma de suas variáveis.
A função rank() atribui postos aos valores de um objeto.
rank(exemplo) # Para atribuir postos (ranks) aos valores do exemplo
17. Manipulação dos dados
Nesta sessão veremos como importar, exportar, alterar e manejar um arquivo de dados dentro
do R. Acessar partes de um conjunto de dados é uma tarefa rotineira dentro do R e da análise de
dados em geral. Por exemplo, em diversos casos teremos que selecionar linhas ou colunas dentro
de uma planilha, ou em outros casos precisaremos agregar linhas ou colunas. Veremos como fazer
coisas desse tipo nesta sessão.
17.1. Definir o local de trabalho (ou dados)
O R sempre trabalha com o conceito de Working direcotry, ou seja, uma pasta de trabalho
onde vai “ler” e “escrever” os dados. Para verificar qual o diretório que o R está “olhando”, utilize
o seguinte comando:

55
getwd()
Para informar ao R em qual pasta ele deve ler os arquivos, utilizamos o comando set
working directory, que muda o diretório padrão do R para leitura e escrita:
setwd('D:/caminho do arquivo')
17.2. Importar conjunto de dados para o R
O conjunto de dados a ser usado em determinada análise pode ser digitado diretamente no
console do R ou lido de arquivos externos. Neste caso, os comandos podem ser usados com a
finalidade de ler ou editar dados. Entre eles podemos citar read.table() e edit().
A função read.table() é a mais utilizada para entrada de dados no R. O R permite a
entrada de dados via arquivo de texto (ASCII), Excel, SAS, SPSS, etc, e até mesmo acessar banco
de dados SQL. Porém, as funções necessárias para realização de alguma destas operações não se
encontram na biblioteca BASE. Por esse motivo, apenas os arquivos de texto serão estudados aqui.
Assim a função read.table() é usada da seguinte maneira:
read.table("endereço completo do arquivo ", header=T, sep= " ",dec=
". ")
OBS: header=T é um argumento necessário se a primeira linha do arquivo de dados contiver as
informações sobre o nome das colunas (linha de cabeçalho). Caso contrário, escrever header=F
ou omitir esse argumento. O argumento sep é usado para definir o separador das colunas,
podemos o delimitador ser virgula (sep= ","), ponto-virgula (sep= ";"), espaço (sep= " "). O

56
argumento dec é usado para definir o separador decimal usado no arquivo. Outra observação
importante é que as barras no endereço devem estar neste sentido "/ " ou utilizar "\\", mesmo
quando o sistema operacional em questão é Windows.
Exemplo:
Deseja-se ler os dados do arquivo “dados.txt” que contêm as coordenadas espaciais de 15 pontos.
As colunas estão separadas por um espaço em branco. Observe que a primeira linha é um
cabeçalho. Se este arquivo estiver salvo no diretório “R” dentro da pasta-raiz, por exemplo, basta
entrar com o comando:
dados <- read.table("exemplo.txt", h=T, sep= ", ")
A função edit() é útil na edição de objetos já existentes, sejam esses vetores, data frame,
funções, etc.
Suponha que você tenha os dados:
dados <- c(25,46,70,89,105)
Porém você detectou um erro onde o penúltimo elemento não deveria ser 89 e sim 98. Você
não precisa criar novamente o objeto “dados” se usar a função edit(). Veja:
dados1<-edit(dados)

57
Depois de alterar o vetor assim como se usa um editor de textos, basta fechar a janela e
salvar que o novo objeto “dados1” é atribuído com a edição de “dados”.
17.3. Comando head() e tail()
O head e o tail são funções para ver a “cabeça” e o “rabo” dos seus dados, ou seja, o começo
e o fim das amostras. É muito importante sempre observar a “aparência” dos dados após o
carregamento. Essa observação ajuda a identificar erros básicos no carregamento, possibilitando
ajustes o quanto antes, impedindo que esses erros se propaguem. Repare que na primeira linha
temos os nomes das colunas e, em seguida, os registros.
head(alunos) # Mostrar as 6 primeiras linhas do objeto
tail(alunos) # Mostra as 6 ultimas linhas do objeto

58
17.4. Operações com vetores e matrizes
A seguir será apresentado um exemplo para mostrar algumas operações possíveis com
vetores e matrizes.
Exemplo:
Primeiramente criaremos vetores que irão compor as colunas de uma matriz.
coluna1<-c(1,2,3)
coluna2<-c(4,5,6)
coluna3<-c(7,8,9)
Agora criaremos uma matriz de nome “dados” com os vetores já criados utilizando uma
das formas de criar matrizes já estudadas.
dados <- cbind(coluna1,coluna2,coluna3)
Obtendo a transposta de “dados”:
t(dados)
Fazendo a multiplicação da transposta de “dados” pela “dados”:
t(dados)%*%dados
Obtendo o produto de vetores:
t(coluna1)%*%coluna1 # multiplicação da coluna 1 por ela mesma
Se você deseja calcular o quadrado dos valores do vetor, então faça:
t(coluna1)*coluna1
Daí a importância do uso do símbolo “%” antes e depois do asterisco.

59
Para calcular a inversa de uma matriz pode-se fazer:
solve(dados)
Caso haja dúvidas você pode ainda testar a veracidade da operação anterior usando álgebra
simples. Multiplique a inversa de uma matriz pela sua matriz original e o resultado deve ser uma
matriz identidade com as mesmas dimensões da matriz a qual se deseja testar. Veja:
solve(dados)%*%dados
O determinante de uma matriz é facilmente obtido da seguinte forma:
det(dados)
Para obtenção da inversa generalizada de Moore-Penrose use a função ginv(), após carregar o
pacote MASS.
library(MASS)
ginv(dados)
Os autovalores e autovetores de uma matriz quadrada podem ser obtidos através da função
eigen(). Veja:
eigen(dados)
Na tabela a seguir são mostrados algumas operações lógicas e outras funções úteis disponíveis no
R.
Símbolo Significado
!= Diferente
%% Módulo (resto da divisão inteira)

60
%/% Divisão inteira

+, -, *, / Adição, subtração, multiplicação, divisão
** ou ^ Potência
<, > Menor que, maior que
<=, >= Menor ou igual a, maior ou igual a
== Igual
length() Número de elementos
Max(), min(), range() Máximo, mínimo e amplitude
which,max() Índice do maior valor
which.min() Índice do menor valor
sum() Soma dos elementos
prod() Produto dos elementos
mean() Média aritmética
var() Variância amostral
cor() Correlação
median() Mediana
order() Vetor contendo as posições ordenadas
rank() Vetor com o ranqueamento
sort() Versão ordenada crescente
rev() Vetor com a ordem inversa
cov() Covariância
colSums() Soma das colunas
rowSums() Soma das linhas
colMeans() Média das colunas
rowMeans() Média das linhas
Exemplo:
x<-0:20 # criando uma sequência de 0 a 20
sum(x) # soma do vetor x
sum(x<10) # quantos valores são menores que 10?
sum(x[x<10]) # soma dos valores menores que 10
x<10 # obtendo a resposta lógica de x<10
which(x<=8) # obtendo a posição dos valores de x menores ou iguais a 8

61
17.5. Salvando arquivos no R
Para salvar arquivos no R o seguinte comando deve ser utilizado: write.table(nome
do arquivo no ambiente R, "nome em que se deseja que o arquivo
seja salvo.extensão", quote= , row.names= , col.names= , ...). Veja:
dados<-c(1:10) # criando um vetor
write.table(dados, "novo arquivo.txt", quote=FALSE,
row.names=FALSE, col.names=FALSE)
18. Gráficos básicos no R
O R é uma poderosa ferramenta no que diz respeito a confecção de gráficos. Em análises
estatísticas por exemplo podemos usufruir das ferramentas gráficas para fazermos um estudo
inicial da planilha de dados. Muitas vezes, é muito mais simples o entendimento de um problema
ou de uma situação se conseguirmos visualizar as variáveis graficamente.
Aqui serão apresentados alguns tipos mais comuns de gráficos no R. Porém se o usuário tiver
interesse em saber mais sobre a confecção de gráficos mais avançados no R digite
demo(graphics) no prompt de comando e vera alguns exemplos de gráficos que podem ser
criados com o R.
18.1. Atributos dos gráficos
A função plot() é a função mais simples para fazer gráficos. Em sua forma mais simples,
ela recebe os valores das coordenadas x e y.
Exemplo:
x<-1:20

62
y<-x^3
plot(x,y) # plota os pares x e y
Qualquer uma das funções gráficas faz com que uma nova tela seja aberta no R contendo
o gráfico criado pela função. A criação de um novo gráfico sobrepõe o gráfico anterior.
Gráficos com linhas suaves ligando os pontos podem ser obtidos utilizando-se o argumento
opcional type=”l” na função plot() como segue:
plot(x,y,type="l") # por default type = ”p” (pontos)

63
Existem outras opções como pode ser visto a seguir:
plot(x,y,type= "b")
plot(x,y,type="o")

64
plot(x,y,type="c")
plot(x,y,type="h")

65
É possível adicionar pontos e linhas a um gráfico já existentes usando as funções
points() e lines(), respectivamente.
Exemplo:
plot(x,y)
points(rev(x),y) # adicionando pontos
lines(x,8000-y) # adicionando linhas

66
O argumento pch= é usado para mudar os padrões de pontos existentes no R. Diferentes tipos
de símbolos são associados a diferentes números. Podem-se ainda usar caracteres quando
desejado. Veja:
plot(x,y)
points(rev(x),y,pch=3) # adicionar cruzes
points(x,8000-y,pch= "$") # adicionar cifrão
Os primeiros símbolos numéricos para gráficos são os seguintes: os números de 0 a 7 são
os símbolos básicos; os números de 8 a 14 são composições de símbolos obtidos por
sobreposição dos símbolos básicos; e os números de 15 a 18 são versões solidas dos símbolos
de 0 a 4. Veja:
plot(0:24,0:24,pch=0:24)

67
A largura das linhas pode ser mudada com o argumento lwd= enquanto eu o estilo da linha
pode ser modificado com o argumento lty= que assume um valor numérico que varia de 0 a
6. Veja:
plot(x,y)
lines(rev(x),y,lwd=4) # linha grossa
lines(x,8000-y,lty=2) # linha tracejada

68
Se você quiser preencher o mesmo gráfico com linhas e pontos que possuem diferentes
amplitudes, recomenda-se usar, primeiramente, o argumento type=”n”. Com esse
argumento, um “gráfico em branco” é criado e são ajustados apenas as margens e os eixos
desse gráfico de acordo com os valores iniciais dos argumentos x e y em plot. A seguir,
adicionam-se as linhas e os pontos desejados. É necessário fornecer coordenadas x e y que
cubram a amplitude valores de todos os elementos que você deseja adicionar ao gráfico. Veja:
plot(c(0,20), c(-8000,8000),type= "n")
lines(x,y)
lines(x,-y)
plot(c(0,20),c(0,30),type= "n") # gráfico em branco
segments(5,3,15,20) # adicionando um segmento de reta
lines(c(12,15,7), c(3,10,8), col= "red", lty=3) # adicionando duas
pequenas linhas vermelhas pontilhadas
abline(30,-2,lty=2,col=4) # adicionando uma linha tracejada azul

69
Você pode dar nome aos eixos com os argumentos xlab= e ylab=. O título pode ser
fornecido usando a função title() numa nova linha de comando fora da função plot(),
ou empregando ao argumento main= dentro da função plot(). Além disso, qualquer texto
pode ser adicionado em qualquer lugar do gráfico, utilizando a função text(). Observe que
os nomes dos eixos, o título ou o texto devem vir entre aspas.
plot(x,y,xlab= "Eixo x", ylab= "Eixo y")
title("Exemplo")
text(6,4000, "texto em qualquer lugar")

70
O parâmetros pos= pode ser usado dentro da função text() para controlar a posição do
texto em relação as coordenadas de inserção deste, pos=1 – abaixo, pos=2 à esquerda,
pos=3 acima, pos=4 à direita.
O comando “\n” usado no comando title() pode ser empregado também em outros
comando, por exemplo, o text(), quando se deseja inserir um parágrafo.
Algumas vezes pode ser interessante identificarmos alguns pontos especificamente em um
gráfico gerado. Essa identificação pode ser facilmente obtida e de maneira bem interativa
quando usamos o comando identify().
Exemplo:
Suponhamos que haja um conjunto de cidades e suas coordenadas planas (x e y). Assim,
cada cidade pode ser por elas identificadas, individualmente. Veja:
x<-c(2,3,4,5,6,7,8,9) # coordenadas x
y<-c(15,46,56,15,81,11,61,55) # coordenadas y
nomes<-paste("cidade", LETTERS[1:8],sep="") # nome das cidades
cidades<-data.frame(x,y,row.names=nomes) # juntando os arquivos

71
OBS: O comando paste() é usado para concatenar (juntar) variáveis.
Assim, a cidade A tem coordenadas (2,15), a cidade B (3,46), e assim sucessivamente.
Podemos plotar as coordenadas das cidades, de modo a visualizar sua distribuição espacial.
Veja:
plot(cidades)
É difícil distinguir na figura onde está localizada qual cidade, mas este problema pode ser
resolvido quando temos indexados os nomes das cidades às coordenadas plotadas no gráfico.
Isto é feito usando-se o comando identify(). Após darmos o comando, quando passarmos
o mouse sobre o gráfico, ele ganha a forma de cruz, e, ao clicar próximo ao ponto que se deseja
identificar, sua descrição é exibida instantaneamente. Se desejarmos, por exemplo, identificar
quatro cidades, assim é o procedimento:
identify(x,y,nomes,n=4)
Como podemos perceber, o programa ainda exibe, no prompt, os valores dos índices das
referências.

72
Por meio de instruções você pode fazer com que o programa mostre diversos gráficos em
uma mesma janela ao invés de um gráfico apenas. Para isso, use a função par(), juntamente
com o argumento mfrow=. Veja:
x<-30:50
y<-x/sqrt(x)
par(mfrow=c(2,2)) # arranjamento “2 por 2”
plot(x,y)
plot(rev(x),y)
plot(x,2*y)
plot(x,log(y))
Outros arranjos de gráficos podem ser definidos na janela gráfica, sempre lembrando que
o primeiro número no comando informa o número de divisão horizontais, e o segundo número
do comando informa o número de divisões verticais na janela gráfica.
Com a função par() podem-se fazer diversas outras coisas relacionados aos gráficos,
conforme demonstrado adiante.

73
Para apresentar várias curvas num único gráfico, cada uma originada de uma coluna de
uma matriz, use a função matplot(). Além disso, legendas podem ser adicionadas aos
gráficos usando a função legend(). Veja:
x<-seq(0,10,1)
x1<-.4*exp(-.4*x)
x2<-.3*exp(-.3*x)
X<-cbind(x1,x2)
matplot(X,type="l")
legend(80,.3,c("x1", "x2"), lty=c(1,2), col=c(1,2))
Alguns parâmetros podem ser usados no intuito de personalizar um gráfico no R. A lista
completa deste parâmetros pode ser obtida com o comando ?par.
Exemplo:
x<-(1:10) # criando x
y<-c(2,5,9,6,7,8,4,1,3,10) # criando y

74
Agora compare os gráficos a seguir. Observe que ambos se referem aos mesmos objetos.
Porém, o segundo contêm uma série de recursos adicionais. Compare também os códigos
usados para gerar cada um deles.
plot(x,y) # plota x e y
plot(x,y, # plota x e y
xlab="Eixo x", # nomeia o eixo x
ylab="Eixo y", # nomeia o eixo y
main="Gráfico personalizado", # nomeia o título do gráfico
xlim=c(0,10), # limites do eixo x
ylim=c(0,10), # limites do eixo y
col="red", # cor dos pontos
pch=22, # formato dos pontos
bg="blue", # cor de preenchimento
tcl=0.4, # tamanho de traços nos eixos
las=1, # orientação do texto em y

75
cex=1.5, # tamanho do ponto
bty="l") # altera as bordas
18.2. Gráficos de barras
Para fazer gráficos de barras no R a função é barplot().
barplot(sample(10:100,10))

76
Veja os exemplos de gráficos de barras:
example(barplot) # clique na janela do gráfico para ir passando os exemplos.
18.3. Gráficos de pizza
Para fazer gráficos de pizza a função pie().
dados = data.frame(rebanho = c("bovino","caprino","ovino","búfalo"),
contagem = c(50000,10000,15000,5000))
pie(dados$contagem)
pie(dados$contagem, labels=dados$rebanho)

77
pie(dados$contagem,labels=dados$rebanho,col=c("red","blue","gree
n","yellow"))
Veja os exemplos de gráficos de pizza
example(pie)
18.4. Gráficos de dispersão
18.4.1. Gráficos com variáveis numéricas
Primeiro vamos inserir os dados de duas variáveis numéricas.
y<-c(110,120,90,70,50,80,40,40,50,30)
x<-1:10
y geralmente é a letra usada em livros texto para indicar a variável resposta, a que aparece no eixo
Y. 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 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.

78
plot(x,y)
18.4.2. Gráficos com variáveis explanatórias que são 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
sempre nomes para facilitar.
Vamos supor que os 5 primeiros valores da nossa variável y eram machos e os 5 últimos
eram fêmeas e criar a variável que informa isso.
sexo<-c("Ma","Ma","Ma","Ma","Ma","Fe","Fe","Fe","Fe","Fe")

79
Para parecer um exemplo mais real vamos supor que y são valores de peso, para isso vamos
apenas salvar um objeto chamado peso que é igual a y.
peso<-y # peso é igual a y
Agora vamos fazer o gráfico:
plot(sexo,peso)
Error in plot.window(...) : valores finitos são necessários para 'xlim'

In addition: Warning messages:
1: In xy.coords(x, y, xlabel, ylabel, log) : NAs introduced by coercion
2: In min(x) : no non-missing arguments to min; returning Inf

3: In max(x) : no non-missing arguments to max; returning -Inf
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)
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 fator(),
transforma o vetor de caracteres 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)

80
Usando a função boxplot()
boxplot(y~sexo)
boxplot(y~sexo, col=c("red","blue"))

81
Você também pode salvar a variável sexo já como um fator.
sexo.f<-factor(sexo)
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.
Para fazer um gráfico de pontos quando uma variável é categórica precisamos usar a função
stripchart().
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.

82
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),

83
method="stack")
Os pontos não estão mais totalmente sobrepostos, mas um símbolo ainda está sobre o outro.
Usando o argumento offset conseguimos separá-los.
stripchart(peso~sexo,vertical=T,at=c(1.3,1.7),method=
"stack",offset=1)

84
18.5. Histogramas
A função hist() produz um histograma dos dados informados em seu argumento. Veja:
x<-c(8,8,8,8,8,9,9,9,5,5,5,5,10,10,10,10,7,6,6) # vetor qualquer
hist(x) # histograma de x
Para auxiliar na interpretação do histograma, pode-se usar a função table(). Veja:
table(x)
5 6 7 8 9 10
4 2 1 5 3 4
Observe que a coluna de 5 a 6 do histograma indica que há seis elementos nessa classe.
Isso acontece porque o padrão do comando hist() considera intervalos de classe fechados a
direita (right=TRUE), ou seja, o 6 também está incluído na primeira classe do histograma acima,
sendo o intervalo (5,6). Então porque o 5 foi contabilizado se o intervalo é aberto em 5? Isso
acontece por causa do parâmetro include.lowest=, que tem como padrão (defaut) o valor

85
TRUE. Isso inclui o primeiro valor do vetor na primeira classe, quando os intervalos de classe são
fechados à direita e o último quando fechados à esquerda. Outro argumento importante é o
breaks=, que definem os intervalos a serem usados no eixo das abscissas do histograma.
Veja:
hist(x, # histograma de x
right=T, # intervalos fechados à direita
include.lowest=F, # não soma extremos do vetor
breaks=c(4,5,6,7,8,9,10)) # intervalo das classes
Os histogramas criados no R seguem certo padrão (conhecido como argumentos defaut) e
podem ser alterados de acordo com a preferência do usuário.
Exemplo:
Vamos criar um conjunto de dados que siga distribuição qui-quadrado com 2000 elementos
e com 15 graus de liberdade.
x<-rchisq(2000,15) # criando uma distribuição qui-quadrado

86
Compararemos agora dois histogramas gerados por códigos diferentes: o primeiro é criado
de maneira mais simples possível, enquanto na geração do segundo são usados vários parâmetros
que podem ser alterados de acordo com a necessidade do usuário.
hist(x) # criando o histograma de x
hist(x, # criando o histograma de x
main="Histograma\nQui-quadrado", # adicionando título
xlab="Valores", # adicionando texto do eixo das abscissas
ylab="probabilidade", # adicionando texto nos eixos das ordenadas
br=c(c(0,5),c(5,10),5*3:10), # intervalo das classes
xlim=c(0,30), # limites do eixo x
ylim=c(0,0.1), # limites do eixo y
col="lightblue", # cor das colunas
border="white", # cor das bordas das colunas
prob=T, # mostrar probabilidades
right=T, # intervalo fechado à direita

87
adj=0, # alinhamento dos textos
col.axis="red", # cor do texto nos eixos
col.main="green", # cor do titulo do gráfico
col.lab="blue") # cor do nome dado os eixos
19. Estatística
19.1. Estatística descritiva
Estatística descritiva é a parte da Estatística que apenas descreve e avalia certo grupo de dados,
seja ele população, seja amostra. No caso de estarmos trabalhando com amostras, o simples uso
de estatísticas descritivas não nos permite tirar quaisquer conclusões ou inferências sobre um grupo
maior.
Para estabelecimento de inferências ou conclusões sobre um grupo maior (a população)
precisaríamos usar algo além do que será visto em Estatística Descritiva. Na verdade, esse “algo

88
mais” seria uso de métodos estatísticos que caracteriza a área da Estatística conhecida como
“Estatística Indutiva” ou “Inferência Estatística”.
Na estatística descritiva existem dois métodos que podem ser usados para a apresentação dos
dados: métodos gráficos (envolvendo apresentação gráfica e, ou, tubular) e métodos numéricos
(envolvendo apresentações de medidas de posição e, ou, dispersão, entre outras).
19.1.1. Média
A média é a medida de posição amis conhecida e pode ser facilmente obtida no R pelo
comando mean(). Veja:
x<-c(1,3,5,7,9,11) # criando um vetor
mean(x) # obtendo a média
19.1.2. Mediana
Uma estatística utilizada para indicar o centro de um conjunto de dados é a mediana
amostral, que pode ser definida, de maneira simplificada, como o valor intermediário do conjunto
de dados, cujos valores são dispostos ordenadamente.
A mediana é uma medida de posição (tendência central) indicada quando o conjunto de
dados possui valores extremos discrepantes dos demais, o que pode comprometer a discussão dos
dados baseados simplesmente na média. A medida é obtido no conjunto de dados quando este se
encontra ordenado, não importando se crescente ou decrescente. Porém o R já realiza
automaticamente a ordenação, sem a necessidade de o usuário ordenar manualmente os dados
antes de executar o comando que retorna o valor da mediana. Veja:
x<-c(5,9,14,18,22) # criando um vetor

89
median(x) # obtendo a mediana
19.1.3. Moda
A moda é outra medida utilizada para indicar a tendência central de um conjunto de
observações. Um conjunto de dados pode ser amodal quando nenhum valor do conjunto pode ser
considerado moda; unimodal, quando o conjunto possui apenas um valor modal; bimodal, quando
o conjunto possui dois valores de moda; e multimodal, quando o conjunto de dados possui mais de
dois valores modais.
A moda pode ser obtida da seguinte forma no R. Como não existe uma função para calcular
a moda no R nós desenvolvemos uma. Veja:
moda<-function(x)
if((is.numeric(x)==TRUE) && (is.list(x)==FALSE))
xx<-table(x)
valores<-which(xx==max(xx))
vmodal<-0
for(i in 1:(length(valores)))
if(i==1) vmodal<-as.numeric(names(valores[i]))
else
vmodal<-c(vmodal, as.numeric(names(valores[i])))
if(length(vmodal)==length(xx))
print("conjunto sem valor modal")
else return(vmodal)

90
else print("o parâmetro deve ser um vetor ou uma matriz")
x<-c(7,8,9,10,7,8,9,10,7,6,5,4,7) # criando vetor
moda(x) # obtendo a moda
19.1.4. Variância
A variância amostral de um conjunto de dados, x1, x2,...,xn é assim definida:
2
∑𝑛𝑖=1(𝑥𝑖 − 𝑥̅ )2 𝑆𝑄𝐷𝑠
𝑠 = =
𝑛−1 𝑛−1
Em que 𝑆𝑄𝐷𝑠 corresponde à soma de quadrados dos desvios de X.
Com apenas um comando podemos obter a variância amostral usando o R. Veja:
var(x)
19.1.5. Desvio padrão
O desvio padrão é definido como a raiz quadrada positiva da variância, o desvio padrão
exerce grande vantagem sobre a variância, já que é apresentado na mesma unidade de medida dos
dados brutos. O desvio padrão pode assim obtido no R:
sd(x) # calculando o desvio padrão

91
19.1.6. Amplitude total
A amplitude total é a diferença entre o maior (máximo) e o menor (mínimo) valor de um
conjunto de dados. Tem a vantagem de ser calculada de forma rápida e fácil, porém, fornece
número (índice) grosseiro da variabilidade de uma distribuição, por levar em conta apenas dois
valores de um conjunto.
A amplitude total pode ser obtida de forma indireta no R fazendo a subtração do máximo
valor de um conjunto de dados pelo mínimo. Veja:
x<-c(1,3,5,7,9) # obtendo um vetor
range(x) # mostrando o valor mínimo e máximo
max(x)-min(x) # amplitude total obtida indiretamente
19.1.7. Erro padrão da média
O erro padrão da média mede a precisão da média. Ele é obtido da seguinte forma:
𝑠𝑥2 𝑠𝑥
𝑠(𝑋̅) = √𝑉(𝑋̅) = √ =
𝑛 √𝑛
Médias com menor erro padrão são consideradas mais precisas. Veja:
x<-c(1,3,5,7,9,11,13,15) # criando um vetor
sd(x)/sqrt(length(x)) # obtendo o erro padrão da média
19.1.8. Coeficiente de variação
O coeficiente de variação é uma medida de dispersão relativa, e é útil para comparar, em
termos relativos, o grau de concentração em torno da média, dos dados. Por ser um número

92
adimensional, permite a comparação de variáveis de unidades diferentes. O coeficiente de variação
é estimado da seguinte forma:

𝑠𝑥
𝐶𝑉(%) = 100
𝑋̅
Amostras com menos CV são ditas mais homogêneas. Veja:
x<-c(1,3,5,7,9,11,13,15) # criando um vetor
(sd(x)/mean(x))*100 # Obtendo o CV de x
19.1.9. Covariância e correlação
Covariância e correlação são utilizadas no estudo do comportamento conjunto de duas
variáveis quantitativas. Medem a variação conjunta (covariância) ou o grau de associação
(correlação) entre duas variáveis aleatórias X e Y.
Sejam duas amostras relativas as variáveis X e Y organizadas em pares de valores (Xi, Yi),
para i=1,2,...,n. O coeficiente de correlação entre as variáveis X e Y é dado por:
𝑆𝑃𝐷𝑋𝑌
𝐶𝑂̂𝑉(𝑋, 𝑌) 𝑛−1 𝑆𝑃𝐷𝑋𝑌
𝑟𝑋𝑌 = = =
√𝑆𝑄𝐷𝑋 𝑥 𝑆𝑄𝐷𝑌 √𝑆𝑄𝐷𝑋 𝑥 𝑆𝑄𝐷𝑌 √𝑆𝑄𝐷𝑋 𝑥𝑆𝑄𝐷𝑌
𝑛−1 𝑛−1 𝑛−1 𝑛−1
No R, a covariância e a correlação entre dois conjuntos de dados quaisquer podem ser
obtidos pelos comandos cov(x,y) e cor(x,y), respectivamente. Veja:
x<-c(1,2,3,4,5) # criando um vetor x
y<-c(35,40,24,78,89) # criando um vetor y
cov(x,y) # obtendo a covariância entre x e y
cor(x,y) # obtendo a correlação entre x e y

93
Se tivermos uma matriz “dados” com seis colunas e n linhas, onde cada coluna representa
os valores de cada variável tomadas em cada indivíduo i (linha da matriz de dados, i=1, ..., n), os
comandos cov(dados) e cor(dados) fornecerão, respectivamente, a matriz de covariâncias
e a matriz de correlações das seis variáveis tomadas nos n indivíduos.
19.2. ANOVA
Estudos estatísticos contemplam a análise de variância como um procedimento que permite
identificar e quantificar as variações corridas em um experimento, discriminando as partes das
variações associadas ao modelo pelo qual o experimento foi procedido, da variação que se dá ao
acaso.
No R são encontrados os diversos procedimentos para se executar a ANOVA. Entretanto
o usuário deve estar atento ao escolher e realizar a análise, pois alguns erros são frequentes, por
exemplo, não especificar algum fator ou esquecer sinal no módulo.
Na tabela a seguir são mostrados alguns modelos e suas usuais formulações.
Modelo Fórmula Comentários

DIC y~t Em que t é uma variável categórica
DBC y~t+b Em que t e b são variáveis categóricas
DQL y~t+l+c Em que t, l e c são variáveis categóricas
Fatorial DIC y~N*P Igual a N+P+N:P
Fatorial DBC y~b+N*P Igual a b+N+P+N:P
DIC – delineamento inteiramente casualizado; DBC – delineamento em blocos casualizados; DQL
– delineamento em quadrado latino; t – tratamentos; b – blocos; l – linhas; c – colunas; N –
número de tratamentos 1; P – número de tratamentos 2.
Os comandos utilizados para realizar o procedimento de ANOVA no R são aov()
utilizada para modelos com erros normais e independentes, e glm() utilizada modelos com
estrutura de erros independentes.

94
Aqui falaremos apenas do modelo inteiramente casualizado. Quem quiser saber mais sobre
os outros modelos de ANOVA sugerimos se matricular no curso “Estatística experimental”
oferecido pela Experimental Analytics Corporation.
O delineamento inteiramente casualizado (DIC) trata-se de experimentos em que os dados
não são pré-separados ou classificados em categorias (blocos). O modelo estatístico para este tipo
de delineamento é:
𝑦 = 𝜇+𝑡+𝜖
Em que y é valor da variável, 𝜇 é a média experimental, t é o efeito de tratamento, e 𝜖 é o erro.
Exemplo:
Suponha os dados abaixo provenientes de um experimento com quatro tratamentos.
Trat1 Trat2 Trat3 Trat4

100 120 102 140
105 125 98 150
98 115 120 128
80 108 103 132
102 135 115 145
A entrada dos dados no R pode ocorrer da seguinte maneira:
dados<-c(100,120,102,140,
105,25,98,150,
98,115,120,128,
80,108,103,132,
102,135,115,145)
Agora demos criar os nomes dos tratamentos na ordem correspondente como segue:
trat<-as.factor(rep(paste("tr",1:4,sep= ""),5))

95
Agora é só fazer o procedimento de ANOVA utilizando a função aov().
resultado<-aov(dados~trat)
Exibindo o resultado da ANOVA:
anova(resultado)
ou
summary(resultado)
Analysis of Variance Table
Response: dados
Df Sum Sq Mean Sq F value Pr(>F)
trat 3 5498.5 1832.8 3.4074 0.0433 *

Residuals 16 8606.4 537.9
---
Signif. codes:
0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
Alguns gráficos informativos da análise podem ser assim obtidos:
par(mfrow=c(2,2)) # divide a janela gráfica em quatro subjanelas
plot(resultado) # plota os gráficos para análise do resíduo

96
OBS: Em todos os tipos de análise de variância, para todas as variáveis qualitativas, devem ser
criados fatores e não vetores, ou seja, o objeto que contêm os nomes(ou números) dos tratamentos,
dos blocos, entre outros, devem ser fatores e não vetores. Para criar fatores e para conversão de
um vetor em um fator podemos usar as funções factor() ou as.factor().
19.3. Regressão
A análise de regressão consiste em uma análise estatística com o objetivo de verificar a
existência de uma relação funcional entre uma variável dependente com uma ou mais variáveis
independentes. Em outras palavras, consiste na obtenção de uma equação que tenta explicar a
variação da variável dependente pela variação dos níveis das variáveis independentes. Aqui apenas

97
falaremos sobre a regressão linear simples. Caso tenha vontade de saber mais sobre o assunto
sugerimos o curso de “Regressões no R” fornecido pela Experimental Analytics Corporation.
Quando o diagrama de dispersão apresenta os pontos agrupados em torno de uma reta
imaginária, provavelmente existe uma relação de linearidade entre as variáveis envolvidas. A essa
relação dá-se o nome de regressão linear simples.
Exemplo:
Um engenheiro civil coleta dados em um laboratório estudando a dilatação de um pilar de
concreto segundo a temperatura ambiente no local onde está o pilar. Os dados estão descritos na
tabela abaixo.
T (ºC) 18 16 25 22 20 21 23 19 17
Dilatação linear (mm) 5 3 10 8 6 7 9 6 5
Posso realizar um estudo de regressão nestes dados? Qual modelo usar? Como montar a
equação que relaciona a temperatura com a dilatação neste estudo? A temperatura realmente exerce
influência na dilatação do pilar? Posso quantificar essa relação?
Essas são as perguntas que podemos fazer ao nos depararmos com os dados acima
apresentados. Suas respostas podem ser encontradas fazendo uma análise de regressão.
Primeiro entraremos com os dados da tabela no R, criando dois objetos: um que conterá os
valores de temperatura e outro da dilatação, na ordem em que foram apresentados. Veja:
temp<-c(18,16,25,22,20,21,23,19,17)
dilat<-c(5,3,10,8,6,7,9,6,5)
Inicialmente o estudo de regressão pode ser feito com a definição do modelo. Para auxiliar
na escolha deste, visualizaremos os pontos em um diagrama de dispersão:

98
plot(temp,dilat) # variável independente deve vir primeiro
O diagrama sugere uma tendência linear dos dados. Montaremos, portanto, um modelo de
regressão linear simples (simples pois existe apenas uma variável independente “temp”
relacionada a variação da variável dependente “dilat”. Assim, o modelo pode ser montado da
seguinte forma:
reglin<-lm(dilat~temp)
reglin
Call:
lm(formula = dilat ~ temp)
Coefficients:
(Intercept) temp
-8.1710 0.7323

99
Com base neste modelo, teremos duas informações: o valor do intercepto (valor onde a reta
da regressão intercepta o eixo das ordenadas, que muitas vezes, não tem interpretação prática,
como seria o caso neste exemplo) e o valor que representa um coeficiente de relação entre a
dilatação e a temperatura, ou seja, quanto a dilatação irá variar para cada variação unitária da
temperatura. Esses valores são comumente representados pelos estatísticos como β0 e β1
respectivamente.
Logo, podemos concluir que o modelo de regressão ajustado seria:
𝑦̂ = 𝛽̂0 + 𝛽̂1 . 𝑋
Assim:
̂ = −8.1710 + 0.7323. 𝑡𝑒𝑚𝑝

𝑑𝑖𝑙𝑎𝑡
Em que a temperatura é dada em ºC e a dilatação em mm. Podemos obter os valores
estimados (preditos) pelos valores tabelados de “temp” da função com o comando:
predict(reglin)
1 2 3 4 5 6 7 8 9
5.009677 3.545161 10.135484 7.938710 6.474194 7.206452 8.670968 5.741935 4.277419
O primeiro valor, ou seja, 5,009677, representa o valor predito para a dilatação quando a
temperatura é 18ºC (primeiro valor do objeto “temp”, e assim sucessivamente até o último valor
de “temp”, gerando nove valores.
Assim vamos plotar novamente os dados e acrescentar a função encontrada no diagrama:
plot(temp,dilat) # diagrama de dispersão
abline(reglin) # reta da regressão ajustada

100
É possível acessar uma série de objetos gerados pela função lm(), como coeficientes, resíduos,
valores preditos (dentro do conjunto de estimação), etc.
ls(reglin)
reglin$coefficients
Podemos também realizar análise de variância da regressão da seguinte forma:
anova(reglin)
Analysis of Variance Table
Response: dilat
Df Sum Sq Mean Sq F value Pr(>F)
temp 1 36.938 36.938 201.4 2.048e-06 ***
Residuals 7 1.284 0.183
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

101
Com base nesta análise podemos verificar que o coeficiente β1 é significativo (a
temperatura influencia significativamente a dilatação, uma vez que o p-value encontrado foi na
ordem de 10-6, ou seja, muito pequeno. Adicionalmente, podemos obter muitas outras informações:
summary(reglin)
Call:
lm(formula = dilat ~ temp)
Residuals:
Min 1Q Median 3Q Max
-0.54516 -0.20645 -0.00968 0.25806 0.72258
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) -8.1710 1.0475 -7.801 0.000107 ***
temp 0.7323 0.0516 14.191 2.05e-06 ***
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
Residual standard error: 0.4283 on 7 degrees of freedom
Multiple R-squared: 0.9664, Adjusted R-squared: 0.9616
F-statistic: 201.4 on 1 and 7 DF, p-value: 2.048e-06
Veja o valor do coeficiente de determinação (R2) destacado (Multiple R-Squared: 0.9664).
Ele representa o quanto da variação da dilatação linear pode ser explicada pela variação da
temperatura neste experimento. Uma vez que o valor encontrado foi quase 97% há indicação de
que o modelo escolhido (linear) foi bem ajustado.

102
19.4. Teste de média
Existe vários testes de comparação múltipla disponíveis na literatura. Muitos deles se
encontram também no R. Nest apostila nós vamos falar apenas sobre o teste de Tukey. Quem
quiser saber mais sobre os demais métodos sugerimos fazer o nosso curso de “Estatística
experimental”.
Há duas formas de se usar o teste de Tukey; a primeira é empregando-se a função já
existente no R, chamada TukeyHSD(), e a segunda, fazendo-se os cálculos necessários com o R
(criando um algoritmo/função para tal). Aqui explicaremos apenas o uso da função TukeyHSD()
do R, pois a parte de criação de funções é explicado apenas no curso “Programação em R”.
Exemplo:
dados<-
c(30,25,46,35,28,19,40,38,33,28,49,45,35,30,48,42,35,20,42,37)
trat<-factor(rep(paste("tr",1:4,sep=""),5))
tabela<-data.frame(trat=trat,dados=dados)
ANOVA<-aov(dados~trat, tabela)
install.packages("agricolae")
library(agricolae)
result<-HSD.test(ANOVA,"trat", group=TRUE,console=TRUE)
Study: ANOVA ~ "trat"
HSD Test for dados

103
Mean Square Error: 16.075

trat, means
dados std r Min Max

tr1 32.2 3.114482 5 28 35
tr2 24.4 4.827007 5 19 30
tr3 45.0 3.872983 5 40 49

tr4 39.4 4.037326 5 35 45
Alpha: 0.05 ; DF Error: 16

Critical Value of Studentized Range: 4.046093
Minimun Significant Difference: 7.254815
Treatments with the same letter are not significantly different.
dados groups
tr3 45.0 a
tr4 39.4 ab
tr1 32.2 b
tr2 24.4 c
Você também pode verificar os resultados graficamente através de:
bar.group(result$groups,ylim=c(0,(max(dados)*1.25)),
density=4,border="blue")
text((nrow(result$groups[2]))/2,max(dados)*1.20,"Teste de Media
para o Fator A")

104
O nível de confiança padrão do R para este comando é de 0.95 (95%) e pode ser alterado
com o parâmetro alpha=.
result<-HSD.test(ANOVA,"trat", group=TRUE, console=TRUE,
alpha=0.01)
Study: ANOVA ~ "trat"
HSD Test for dados
Mean Square Error: 16.075
trat, means
dados std r Min Max

tr1 32.2 3.114482 5 28 35
tr2 24.4 4.827007 5 19 30
tr3 45.0 3.872983 5 40 49
tr4 39.4 4.037326 5 35 45

105
Alpha: 0.01 ; DF Error: 16
Critical Value of Studentized Range: 5.191898
Minimun Significant Difference: 9.309292
Treatments with the same letter are not significantly different.
dados groups
tr3 45.0 a
tr4 39.4 ab
tr1 32.2 bc
tr2 24.4 c
bar.group(result$groups,ylim=c(0,(max(dados)*1.25)),
density=4,border="blue")
text((nrow(result$groups[2]))/2,max(dados)*1.20,"Teste de Media
para o Fator A")

106
plot(result, main="Teste de Média")

107
20. Noções de Programação
Nesta seção nós daremos uma introdução sobre programação no R na qual nós
falaremos um pouco sobre algumas das principais funções (condições) utilizadas em
programação. Para usuários que queiram saber mais sobre programação sugerimos fazer
o curso “Programação em R” fornecido pela Experimental Analytics Corporation.
20.1. if() sozinho
A estrutura básica do if() é a seguinte:
if (condição) {
# comandos que
# serão rodados
# caso condição = TRUE
O início do código se dá com o comando if seguido de parênteses e chaves;
Dentro dos parênteses temos uma condição lógica, que deverá ter como resultado
ou TRUE ou FALSE;
Dentro das chaves temos o bloco de código que será executado se – e somente se – a
condição dos parênteses for TRUE.
Vejamos um exemplo muito simples. Temos dois blocos de código que criam as
variáveis x e y, mas eles só serão executados se as variáveis cria_x e cria_y forem TRUE,
respectivamente. Veja:
# vetores de condição lógica
cria_x <- TRUE

108
cria_y <- FALSE
# só executa se cria_x = TRUE
if (cria_x) {
x <- 1
# só executa se cria_y = TRUE
if (cria_y) {
y <- 1
# note que x foi criado
exists("x")
## [1] TRUE
# note que y não foi criado
exists("y")
## [1] FALSE
Note que somente a variável x foi criada. Vamos agora rodar o mesmo bloco, mas
com TRUE e FALSE diferentes.
# remove x que foi criado
rm(x)
# vetores de condição lógica
cria_x <- FALSE
cria_y <- TRUE
# só executa se cria_x = TRUE

109
if (cria_x) {
x <- 1
# só executa se cria_y = TRUE
if (cria_y) {
y <- 1
# note que x não foi criado
exists("x")
## [1] FALSE
# note que y foi criado
exists("y")
## [1] TRUE
Note que agora apenas o y foi criado.
20.2. if() com o else
Outra forma de executar códigos de maneira condicional é acrescentar ao if() o opcional else.
A estrutura básica do if() else é a seguinte:
if (condicao) {
# comandos que
# serão rodados
# caso condicão = TRUE
} else {
# comandos que

110
# serão rodados
# caso condição = FALSE
O início do código se dá com o comando if seguido de parênteses e chaves;
Dentro dos parênteses temos uma condição lógica, que deverá ter como resultado
ou TRUE ou FALSE;
Dentro das chaves do if() temos um bloco de código que será executado se – e somente
se – a condição do parênteses for TRUE.
Logo em seguida temos o else seguido de chaves;
Dentro das chaves do else temos um bloco de código que será executado se – e somente
se – a condição dos parênteses for FALSE.
Como no caso anterior, vejamos primeiramente um exemplo bastante simples.
numero <- 1
if (numero == 1) {
cat("o numero é igual a 1")
} else {
cat("o numero não é igual a 1")
## o número é igual a 1
É possível encadear diversos if() else em sequência:
numero <- 10
if (numero == 1) {

111
} else if (numero == 2) {
} else {
cat("o numero não é igual nem a 1 nem a 2")
## o número não é igual nem a 1 nem a 2
Para fins de ilustração, vamos criar uma função que nos diga se um número é par ou ímpar.
Nela vamos utilizar tanto o if() sozinho quanto o if() else.
Vale relembrar que um número (inteiro) é par se for divisível por 2 e que podemos verificar
isso se o resto da divisão (operador %% no R) deste número por 2 for igual a zero.
Vamos testar nossa função:
par_ou_impar <- function(x){
# verifica se o número é um decimal comparando o tamanho da diferença de x e round(x)
# se for decimal retorna NA (pois par e ímpar não fazem sentido para decimais)
if (abs(x - round(x)) > 1e-7) {
return(NA)
# se o número for divisível por 2 (resto da divisão zero) retorna "par"
# caso contrário, retorna "ímpar"
if (x %% 2 == 0) {
return("par")
} else {

112
return("impar")
par_ou_impar(4)
## [1] "par"
par_ou_impar(5)
## [1] "impar"
par_ou_impar(2.1)
## [1] NA
Parece que está funcionando bem… só tem um pequeno problema. Se quisermos aplicar
nossa função a um vetor de números, olhe o que ocorrerá:
x <- 1:5
par_ou_impar(x)
## Warning in if (abs(x - round(x)) > 1e-07) {: a condição tem comprimento > 1 e somente o primeiro
## elemento será usado
## Warning in if (x%%2 == 0) {: a condição tem comprimento > 1 e somente o primeiro elemento será
usado
## [1] "ímpar"
Provavelmente não era isso o que esperávamos. O que está ocorrendo aqui?

113
20.3. ifelse()
Os comandos if() e if() else não são vetorizados. Uma alternativa para casos
como esses é utilizar a função ifelse().
A função ifelse() tem a seguinte estrutura básica:
ifelse(vetor_de_condicoes, valor_se_TRUE, valor_se_FALSE)
O primeiro argumento é um vetor (ou uma expressão que retorna um vetor) com
vários TRUE e FALSE;
O segundo argumento é o valor que será retornado quando o elemento
do vetor_de_condicoes for TRUE;
O terceiro argumento é o valor que será retornado quando o elemento
do vetor_de_condicoes for FALSE.
Primeiramente, vejamos um caso trivial, para entender melhor como funciona o ifelse():
ifelse(c(TRUE, FALSE, FALSE, TRUE), 1, -1)
## [1] 1 -1 -1 1
Note que passamos um vetor de condições com TRUE, FALSE, FALSE e TRUE. O
valor para o caso TRUE é 1 e o valor para o caso FALSE é -1. Logo, o resultado é 1, -1, -1 e 1.
Façamos agora um exemplo um pouco mais elaborado. Vamos criar uma versão
com ifelse da nossa função que nos diz se um número é par ou ímpar.
Testemos a função com vetores. Perceba que agora funciona sem problemas!
par_ou_impar_ifelse <- function(x){
# se x for decimal, retorna NA, se não for, retorna ele mesmo (x)
x <- ifelse(abs(x - round(x)) > 1e-7, NA, x)

114
# se x for divisível por 2, retorna 'par', se não for, retorna ímpar
ifelse(x %% 2 == 0, "par", "impar")
par_ou_impar_ifelse(x)
## [1] "impar" "par" "impar" "par" "impar"
par_ou_impar_ifelse(c(x, 1.1))
## [1] "ímpar" "par" "ímpar" "par" "ímpar" NA
20.4. Vetorização e ifelse()
Um tema constante neste livro é fazer com que você comece a pensar em explorar a
vetorização do R. Este caso não é diferente, note que poderíamos ter feito a função utilizando
apenas comparações vetorizadas:
par_ou_impar_vec <- function(x){
# transforma decimais em NA
decimais <- abs(x - round(x)) > 1e-7
x[decimais] <- NA
# Cria vetor para armazenar resultados
res <- character(length(x))
# verificar quem é divisível por dois
ind <- (x %% 2) == 0
# quem for é par
res[ind] <- "par"
# quem não for é ímpar
res[!ind] <- "impar"

115
# retorna resultado
return(res)
Na prática, o que a função ifelse() faz é mais ou menos isso o que fizemos acima –
comparações e substituições de forma vetorizada. Note que, neste caso, nossa implementação ficou
inclusive um pouco mais rápida do que a solução anterior com ifelse():
library(microbenchmark)
microbenchmark(par_ou_impar_vec(1:1e3),
par_ou_impar_ifelse(1:1e3))

Apostila Introdução Ao R

Enviado por

Dados do documento

Descrição original:

Título original

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

Apostila Introdução Ao R

Enviado por

Direitos autorais:

Formatos disponíveis

2021

2. Como instalar o R ................................................................................................................... 5

2.2. Rstudio no Windows ...................................................................................................... 13

2.3. OS X ou Linux ............................................................................................................... 18

4. Noções gerais sobre o R ........................................................................................................ 21

6.1. Instalação de pacotes ...................................................................................................... 25

6.2. Uso dos pacotes .............................................................................................................. 29

6.3. Como citar um pacote no R ............................................................................................ 29

8. Uso inicial do R .................................................................................................................... 32

8.1. Operações e operadores aritméticos ............................................................................... 32

8.2. Operadores lógicos ......................................................................................................... 32

8.3. Objetos (Variáveis) do R ................................................................................................ 33

8.3.1. Vetores .................................................................................................................... 35

Experimental Analytics Corporation – leoazevedop@gmail.com - +55 31 99502 4915

8.3.3. Data frame ............................................................................................................... 37

8.3.4. Listas ....................................................................................................................... 39

8.3.5. Funções ................................................................................................................... 40

8.4. Conversão de tipos de varáveis ...................................................................................... 40

9.1. Indexação de vetores ...................................................................................................... 41

9.2. Indexação de matrizes .................................................................................................... 42

9.3. Indexação de data frame ................................................................................................. 44

9.4. Indexação de listas ......................................................................................................... 46

10. Gerar sequências ................................................................................................................ 47

11. Gerar repetições ................................................................................................................. 47

12. Listar e remover objetos salvos.......................................................................................... 48

13. Gerar dados aleatórios........................................................................................................ 49

14. Fazer amostras aleatórias ................................................................................................... 50

15. Arredondamento ................................................................................................................ 52

16. Ordenar e atribuir postos e ranks ....................................................................................... 53

17. Manipulação dos dados ...................................................................................................... 54

17.1. Definir o local de trabalho (ou dados) ........................................................................ 54

17.2. Importar conjunto de dados para o R.......................................................................... 55

Experimental Analytics Corporation – leoazevedop@gmail.com - +55 31 99502 4915

17.3. Comando head() e tail() ................................................................................... 57

17.4. Operações com vetores e matrizes.............................................................................. 58

17.5. Salvando arquivos no R .............................................................................................. 61

18. Gráficos básicos no R ........................................................................................................ 61

18.1. Atributos dos gráficos ................................................................................................. 61

18.2. Gráficos de barras ....................................................................................................... 75

18.3. Gráficos de pizza ........................................................................................................ 76

18.4. Gráficos de dispersão.................................................................................................. 77

18.4.1. Gráficos com variáveis numéricas ...................................................................... 77

18.4.2. Gráficos com variáveis explanatórias que são categóricas ................................. 78

18.5. Histogramas ................................................................................................................ 84

19. Estatística ........................................................................................................................... 87

19.1. Estatística descritiva ................................................................................................... 87

19.1.2. Mediana ............................................................................................................... 88

19.1.4. Variância ............................................................................................................. 90

19.1.5. Desvio padrão ...................................................................................................... 90

19.1.6. Amplitude total.................................................................................................... 91

19.1.7. Erro padrão da média .......................................................................................... 91

Experimental Analytics Corporation – leoazevedop@gmail.com - +55 31 99502 4915

19.1.8. Coeficiente de variação ....................................................................................... 91

19.1.9. Covariância e correlação ..................................................................................... 92

19.2. ANOVA ...................................................................................................................... 93

19.3. Regressão .................................................................................................................... 96

19.4. Teste de média .......................................................................................................... 102

20. Noções de Programação ................................................................................................... 107

20.1. if() sozinho ........................................................................................................... 107

20.2. if() com o else ................................................................................................... 109

20.3. ifelse() ............................................................................................................... 113

20.4. Vetorização e ifelse() ................................................................................................ 114