Computação em R

Introdução

Eric Gorgens
Esse livro está à venda em http://leanpub.com/comprintroducao

Essa versão foi publicada em 2016-01-23

ISBN 978-85-920621-0-1

This is a Leanpub book. Leanpub empowers authors and publishers with the Lean Publishing
process. Lean Publishing is the act of publishing an in-progress ebook using lightweight tools and
many iterations to get reader feedback, pivot until you have the right book and build traction once
you do.

© 2016 Eric Gorgens

Dedico este livro aos alunos e colegas que buscaram no R a solução dos seus problemas e
encontraram em mim o apoio para solucioná-los. Ao ensinar, aprendi em dobro.
Conteúdo

Sobre o livro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Sobre o R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

Estrutura de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Operadores matemáticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

Adicionando pacotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

RStudio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Espaço de trabalho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

Importando dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

Dataframe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

Pacote gráfico básico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

Gráfico de dispersão. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Boxplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Histograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

Looping WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

Looping FOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

Família APPLY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

Próximos passos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

Agradecimentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Sobre o livro
Bem vindo ao mundo do R. O R não é só um software, nem se resume a uma linguagem. O R é um
estilo de pesquisar, estudar e ensinar. Através de seus códigos e scripts você entrará num mundo
sem limites, aberto à experimentação e à troca de experiência. Um mundo em que não existe apenas
uma forma de se chegar à resposta correta, mas sim uma gama de alternativas!
Você deve estar se perguntando: porque começar a trabalhar com o R? A resposta passa por algumas
perspectivas interessantes.

O R é moderno, o R é flexível, o R é uma poderosa linguagem, o R é versátil e o R é grátis.

No R, você trabalha com linhas de comando e scripts; e não clicando em botões na tela. Não se assuste.
Pode parecer difícil, mas na verdade, a linguagem R é simples de aprender e bastante lógica quando
pensamos em análise de dados. Aprender uma linguagem de computação tem muitas semelhanças
com o aprendizado de uma língua estrangeira. A principal delas é: você aprende praticando, por isso,
pratique muito! Com o R você não está limitado por uma sequência pré-definida de rotinas.
O R quebra a dependência do usuário em clicar botões, fazendo com que cada análise seja realmente
fruto de uma reflexão sobre as estatísticas e os dados. Este processo de reflexão e criação da
análise fica documentado, passo a passo no histórico (ou script), podendo ser executado a qualquer
momento, por qualquer pessoa.
O usuário tem disponível um conjunto poderoso e versátil de ferramentas para explorar graficamente
os resultados. Aproveite! Antes de começar uma análise estatística, explore seus dados! Só assim você
irá de fato conhecer o que você tem em mãos.
As ferramentas disponíveis, passam pelo acesso a vários tipos de dados, até recursos para manipu-
lação de bases, passando pelos modelos estatísticos tradicionais e modernos. Os mais influentes
acadêmicos e pesquisadores do mundo utilizam o R para desenvolver suas pesquisas. Assim as
novidades nas áreas de estatística, máquinas de aprendizado e modelagem estarão primeiramente
disponíveis aqui. Atualmente são mais de 2000 pacotes que potencializam o seu R disponíveis para
download.
Com uma imensa comunidade que continua crescendo, se você tiver uma dúvida, a chance de alguém
já ter esbarrado com este problema é muito grande. O tempo médio que uma pergunta leva para ser
respondida no StackOverflow (maior comunidade de programadores do mundo) é de 0,0147 dias, o
que equivale a 21 minutos.
E o melhor de tudo, o R é gratuito. Por se tratar de um projeto de código aberto, você pode usar
o R sem nenhum custo adicional; ou seja sem necessidade de pagar por inscrições, assinaturas ou
licenças.

1
Sobre o livro 2

Este livro nasceu da experiência de ensinar o R para alunos de graduação e pós-graduação. Alunos
que têm sede em botar a mão na massa e aprender fazendo. Com este propósito, todos os capítulos
deste livro podem ser acompanhados na prática. Os exemplos podem ser testados, adaptados e
modificados.

Acompanhe atualizações, faça download das base de dados utilizadas ao longo do livro e
conheça os outros livros da série em: http://gorgens.wix.com/compr

Aqui, você irá aprender o essencial. Não temos a pretensão de ensinar tudo sobre o R. Nosso objetivo
é fazer com que você entenda e sinta-se confortável com o ambiente R. Para isto, usamos uma
linguagem simples e direta, com exemplos e explicações sobre o que estamos digitando e executando
no R.
Da sua parte, espero que seja proativo. Não digite os exercícios. Faça e entenda os exercícios! Faça
modificações e veja o que acontece com o resultado. Seja curioso!
Bom aprendizado.
 Sobre o R
O R é um programa baseado em linhas de comando. Isto é, o usuário cria uma linha de código
através de uma sequência de palavras e números. Ao digitar a linha no console, o R interpreta e
executa a ação codificada na linha. Também é possível informar para R, um conjunto de linhas de
uma única vez, que conhecemos como script. Ao processar o script no console, o R irá ler a primeira
linha, interpretar e executar. Só depois que o processamento da primeira linha terminar, é que a
segunda linha será lida, interpretada e executada. Esta sequência segue, até que todo o script tenha
sido processado.
Para que o R compreenda as linhas de comando criadas, é fundamental que o usuário conheça os
comandos, seus parâmetros e a sintaxe da linguagem de interpretação. No caso de uma grafia errada,
ou um parâmetro faltante o programa será capaz de interpretar, podendo até mesmo interpretar de
forma equivocada.
No caso do R, a linguagem utilizada recebe o mesmo nome: linguagem R. A linguagem R possui
regras próprias, que chamamos de sintaxe. Estas regras precisam ser seguidas para assegurar que o
programa interprete e processe as linhas com sucesso.
Não se preocupe agora com os termos console e script. Na próxima seção teremos uma discussão
detalhada do ambiente do R. Lá discutiremos onde encontrar e como funciona cada um destes
elementos. Não se preocupe também em rodar os códigos que veremos a seguir, eles serão usados
apenas para mentalizarmos alguns aspectos importantes!
Ao abrir o R pela primeira vez, a janela chamada Console estará aberta e disponível. É nesta janela
que os comandos serão interpretados e processados. No console, teremos algo parecido com o quadro
abaixo:

1 R version 3.0.2 (2013-09-25) -- "Frisbee Sailing"

2 Copyright (C) 2013 The R Foundation for Statistical Computing
3 Platform: x86_64-w64-mingw32/x64 (64-bit)
4
5 R is free software and comes with ABSOLUTELY NO WARRANTY.
6 You are welcome to redistribute it under certain conditions.
7 Type 'license()' or 'licence()' for distribution details.
8
9 Natural language support but running in an English locale
10
11 R is a collaborative project with many contributors.
12 Type 'contributors()' for more information and
13 'citation()' on how to cite R or R packages in publications.

3
 Sobre o R 4

14
15 Type 'demo()' for some demos, 'help()' for on-line help, or
16 'help.start()' for an HTML browser interface to help.
17 Type 'q()' to quit R.
18
19 >

Veja no final do quadro a presença do sinal > que indica que o console está esperando uma nova
linha de comando. Assim, se digitarmos:
2+3
O console poderá ser visto da seguinte forma:

1 > 2 + 3

Quando a tecla enter for pressionada, o R irá interpretar a linha de comando digitada, processar e
então retornar o resultado:

1 [1] 5
2 >

O que o R acabou de fazer? Ele pegou o valor 2 e adicionou o valor 3, retornando um vetor de um
único elemento ([1]) contendo o valor 5. Como ele terminou o processamento da linha que digitamos,
o sinal > aparece no final da janela, avisando que o console está pronto para executar uma nova linha.
Outro sinal que pode aparecer com frequência quando você estiver digitando linhas de comando
no console é o +. Ele aparece uma linha é digitada de forma incompleta. Assim, o sinal + aparece
indicado ao usuário que o R continua aguardando que a linha de comando seja encerrada. Imagine
que desejo realizar a soma de 2 + 5. Veja o exemplo de uma adição digitada de forma incompleta:

1 > 2 +

Ao apertamos enter, o console tentará processar a soma. No entanto após o sinal +, o R espera que
venha outro termo quer deveria ser somado a 2. Por isto, o R exibe um + na linha abaixo do comando
digitado para informar ao usuário que algo ainda falta para que o comando possa ser interpretado.

1 > 2 +
2 +

Ao digitarmos 5, o termo faltante e pressionar enter, o consegue interpretar e executar a soma

solicitada:
 Sobre o R 5

1 > 2 +
2 + 5
3 [1] 7
4 >

No dia a dia, dificilmente conseguiremos resolver um problema em apenas uma linha. É aí que entra
em jogo o script! O R possui um editor de texto para a criação de script. Quando solicitado, uma
segunda janela chamada R Editor se abre e nesta janela podemos construir uma sequência de linhas
para ser no futuro apresentado ao console.
Assim, é possível abrirmos uma segunda janela: o editor de script. No script é possível digitarmos
uma sequência de linhas que posteriormente serão apresentados ao console. Note que o você escreve
no R Editor não é processado de imediato. O processamento ocorre quando uma linha do script é
levada ao console. Apenas o console consegue interpretar e processar linhas de comando.
Vamos para um exemplo. Imagine que desejamos processar o script abaixo:

1 x = 2
2 print(x)
3 x = x + 3
4 print(x)

O próximo passo é processar linhas por linha do script. Como dissemos anteriormente, as linhas
precisam ser processadas uma a uma. Se processarmos no console a primeira linha:

1 > x = 2

Digitando e pressionando a tecla enter, nada acontecerá na tela. Um novo símbolo > aparecerá abaixo
da linha anterior:

1 > x = 2
2 >

Não se preocupe, deu certo! O R criou na memória uma variável e assinalou a ela o valor 2. O sinal
> indica que o R está pronto para receber a próxima linha de comando!
Nossa próxima linha, seguindo o script, seria:

1 > print(x)

Agora sim, ao pressionarmos a tecla enter, o console exibirá:

 Sobre o R 6

1 > x = 2
2 > print(x)
3 [1] 2
4 >

O console imprimiu na tela o valor 2, que está armazenado num vetor de um elemento salvo com o
nome de x. Fácil não? Digitando a terceira linha do script, pressionando enter. Digitando a quarta
linha e pressionando enter em seguida, o resultado será:

1 > x = 2
2 > print(x)
3 [1] 2
4 > x = x + 3
5 > print(x)
6 [1] 5

Você consegue descrever o que console acabou de fazer ao rodar todas as linhas do script? Fácil!
Somou 2 + 3 retornando o valor 5. Vamos destrinchar o script?

• Primeiro criamos uma variável x que armazena num vetor de único elemento o valor 2.
• Em seguida pedimos para exibir a variável x.
• Depois pegamos o valor atual de x, adicionamos 3 e salvamos novamente em x.
• Finalizamos pedindo para exibir o valor atual da variável x.

Agora que entendemos melhor como o R funciona, vamos conhecer o nosso ambiente de trabalho
nos próximos capítulos. Quando você abrir o R pela primeira vez, uma janela de abrirá. A janela
externa, maior, é o programa R propriamente dito! A janela interna, menor, é o console.
Sobre o R 7

Janela do R

Como já mencionamos anteriormente, podemos também trabalhar com uma segunda janela interna
chamada de R Editor. É nesta janela que construímos os scripts. Clique em File -> New Script. Seu
ambiente de trabalho será:
Sobre o R 8

Ambiente do R

Veja que quando o console está ativado, a barra de ferramentas é igual a:

Barra de tarefas com console ativado

Por outro lado, quando o R Editor está ativado, a barra de ferramentas muda:

Barra de tarefas com o editor ativado

Não perderemos tempo agora, explicando cada botão das barras de ferramentas. No entanto, vale a
pena aproveitarmos para conhecer o botão Run line, or selection:

Run line, or selection

Este botão pode ser usado quando queremos pegar uma linha do script e processar no console. Basta
selecionar a linha no script em questão, e clicar no botão Run line, or selection. Automaticamente a
linha selecionada será enviada ao console e processada.
Veja o exemplo abaixo, no qual selecionamos a primeira linha do script e clicamos no botão Run
line, or selection. O comando foi processado da mesma forma de quando digitamos diretamente no
Sobre o R 9

console.

Comando run line

Utilizando a mesma idéia de seleção e botão Run line, or selection, podemos enviar ao console mais
uma linha de comando. Veja o exemplo abaixo:

Outro comando run line

O R trabalha com padrão internacional de separação decimal e separação de colunas. A

separação decimal é ‘.’ (ponto). E a separação de coluna é ‘,’ (vírgula).
Sobre o R 10

Agora sim convido você para colocar a mão na massa. Assim chegou a hora de instalar o R. Existem
vários tutoriais na internet, bem como vídeo-tutoriais excelentes. O R roda em todos os sistemas
operacionais: Mac, Windows e Linux.

Uma vez instalado, você poderá acompanhar todos os exercícios do livro realizando-os
diretamente em seu computador. É fundamental que você realmente coloque a mão na
massa. É a única forma de errar e aprender!

A partir de agora não utilizaremos mais a notação de linha ativa >.

 Estrutura de dados
Uma variável pode assumir diferentes estruturas. As estruturas possuem propriedades que irão
influenciar o que você pode ou não pode fazer com os seus dados. Uma variável que for criada
como matriz, não possui as mesmas propriedades de uma variável estruturada como lista. Assim,
não é possível aplicar o operador de soma a estas duas variáveis.
Estas estruturas são criadas para armazenar dados. Estes dados geralmente podem ser definidos
como numéricos (inteiros ou decimais), caracteres (string) ou lógicos. Algumas estruturas permitem
que diferentes tipos de dados sejam armazenados ao mesmo tempo. Em outras estruturas, apenas
um tipo de dado pode ser simultaneamente armazenado.
Na linguagem R, não é necessário declarar uma variável antes dela ser criada. O programa já tenta
determinar a melhor classe com base na primeira vez que algo for atribuído à variável. Vamos rodar
a seguinte linha:

1 x = 2

O sinal = é a representação do termo atribuição, e pode ser substituído pelo sinal <-. Portanto, o
comando abaixo equivale ao comando anterior:

1 x <- 2

Os comandos acima são equivalentes e podem ser interpretados como: atribua o valor 2 à variável
x. Ao criar a variável x, o R irá definir x como numérico e armazenar numa estrutura de vetor, pois
o 2 é claramente um número.
Vetor é a estrutura mais simples que uma variável pode assumir, e somente pode assumir um mesmo
tipo de dados. No exemplo:

1 a <- 2

A variável a será automaticamente definida pelo R como um vetor numérico.

O principal atributo de uma estrutura do tipo vetor é o comprimento. O vetor a, por exemplo, é um
vetor de comprimento um, ou seja, contém apenas um elemento. Isto pode ser comprovado através
do seguinte comando:

11
 Estrutura de dados 12

1 length(a)
2 [1] 1

Vamos criar um script com 4 linhas de comando que criam quatro diferentes variáveis. Pegue cada
uma das linhas do script abaixo e processe no console:

1 a <- 2
2 b <- c(1, 2, 3)
3 idade <- c(2, 4, 3)
4 experiencia <- c(1, 5, 7)

Note, que quando você quer criar um vetor com mais de um elemento, é necessário utilizar a função
c(). A letra c vem de components, assim, ao utilizar a função c() você está informando ao R que
construa um vetor com os componentes listados dentro da função.
Após rodar cada linha do script acima, você não vê, mas agora existe na memória as variáveis:
a, b, idade e experiencia. Utilizando o comando length() você descobrirá que o vetor a possui
comprimento igual a 1, e logo é composto por apenas um elemento. Já os vetores b, idade e
experiencia possuem comprimento 3 e portanto são compostos por 3 elementos.

1 Length(a)
2 [1] 1

1 length(b)
2 [1] 3

1 length(idade)
2 [1] 3

1 length(experiencia)
2 [1] 3

Todos os quatro vetores são vetores numéricos, e por só armazenarem números, podem participar
de operações matemáticas que não seriam possíveis em vetores de caracteres. Mas não vamos nos
preocupar agora com as operações matemáticas. Logo logo voltaremos neste assunto.
Agora imagine que você pegue dois vetores com três elementos cada um, e combine lado a lado estes
dois vetores. O que acontece? Você acaba de criar uma matriz de duas colunas e três linhas. E se
você combinar estes dois vetores de três elementos um acima do outro? Você cria uma matriz com
duas linhas e três colunas. Esta “combinação” de vetores só funciona quando os elementos possuem
o mesmo formato, ou seja, somente números ou somente caracteres!
Matrizes nada mais são que combinações de vetores com o mesmo comprimento e tipo de dado.
As variáveis estruturadas como matriz possuem portanto uma característica que o vetor não tem:
dimensão. A dimensão é uma característica que indica quantas linhas e quantas colunas a matriz
possui. Vamos criar uma matriz e armazená-la na variável m1:
 Estrutura de dados 13

1 m1 = matrix(c(2, 4, 3, 1, 5, 7), nrow = 2, ncol = 3, byrow = TRUE)

O comando dim() retorna a dimensão de uma matriz. Antes de rodar esse comando para a matriz
recém criada m1, qual a dimensão desta matriz? Se você respondeu 2 x 3, acertou! Agora rode o
comando abaixo e tire a prova:

1 dim(m1)
2 [1] 2 3

A resposta é uma matriz de dois elementos. O primeiro elemento, de valor 2, indica o número de
linhas. O segundo elemento, de valor 3, indica o número de colunas. Vamos exibir o vetor para
verificar visualmente o número de linhas e de colunas? Digite o comando abaixo:

1 m1
2 [,1] [,2] [,3]
3 [1,] 2 4 3
4 [2,] 1 5 7

Agora podemos conferir visualmente que nossa matriz m1 realmente possui duas linhas e três
colunas. Perceba também, que os três primeiros elementos (2, 4, 3) do vetor informado durante a
criação da matriz foram organizados ao longo da primeira linha, e os três últimos elementos (1, 5,
7) foram organizados ao longo da segunda linha. Isto aconteceu porque pedimos que o parâmetro
byrow da função matrix() fosse verdadeiro (= TRUE).
E se criarmos uma nova matriz m2 com o mesmo comando da m1, alterando o parâmetro byrow
para falso (= FALSE)?

1 m2 = matrix(c(2, 4, 3, 1, 5, 7), nrow = 2, ncol = 3, byrow = FALSE)

1 m2
2 [,1] [,2] [,3]
3 [1,] 2 3 5
4 [2,] 4 1 7

O acesso a elementos, linhas e colunas de uma matriz pode ser feito utilizando a notação de [ ] logo
após o nome da matriz que se deseja manipular. Execute as linhas do script abaixo no seu console.
Todas as linhas foram construídas sobre a matriz m1 que criamos há pouco.
 Estrutura de dados 14

1 m1[1,1]
2 m1[1,]
3 m1[,2]
4 m1[2, 1:2]

Na linha 1 do script pedimos para exibir o elemento da linha 1 e coluna 1. Na segunda linha,
solicitamos que sejam exibidos todos os elementos da linha 1. Na terceira linha do script solicitamos
que sejam exibidos todos os elementos da segunda coluna. Na última linha do script, solicitamos
que sejam exibidos os elementos da linha 2 e colunas 1 até 2.
Assim, vejamos cada comando com seu respectivo resultado:

1 m1[1,1]
2 [1] 2

1 m1[1,]
2 [1] 2 4 3

1 m1[,2]
2 [1] 4 5

1 m1[2, 1:2]
2 [1] 1 5

Dataframe é uma condição especial de combinação lado a lado de vetores. Ao contrário das matrizes,
o dataframe não exige que os vetores tenham os mesmos tipos de dados. Assim, por exemplo, a
primeira coluna do dataframe pode ser numérica, e a segunda coluna pode ser de texto e a terceira
coluna com data. O R possui alguns dataframes que vem automaticamente quando o software é
instalado. Estes dataframes são geralmente usados como exemplos nos tutoriais e arquivos de ajuda.
Uma dessas bases é o mtcars.
Para carregarmos esta base de dados basta digitar:

1 data(mtcars)

Após digitar o comando acima em seu console, você terá criado uma variável na memória chamada
mtcars contendo os dados em questão. Como exemplo, vamos usar o comando head() para visualizar
as colunas deste dataframe e as 6 primeiras linhas:
 Estrutura de dados 15

1 head(mtcars)
2 mpg cyl disp hp drat wt qsec vs am gear carb
3 Mazda RX4 21.0 6 160 110 3.90 2.620 16.46 0 1 4 4
4 Mazda RX4 Wag 21.0 6 160 110 3.90 2.875 17.02 0 1 4 4
5 Datsun 710 22.8 4 108 93 3.85 2.320 18.61 1 1 4 1
6 Hornet 4 Drive 21.4 6 258 110 3.08 3.215 19.44 1 0 3 1
7 Hornet Sportabout 18.7 8 360 175 3.15 3.440 17.02 0 0 3 2
8 Valiant 18.1 6 225 105 2.76 3.460 20.22 1 0 3 1

Visualizando apenas as 6 primeiras linhas do dataframe mtcars podemos perceber que este é a
estrutura de dados que se assemelha às planilhas eletrônicas como Excel. Assim, podemos entender
o dataframe como sequência de observações (linhas) de determinadas variáveis (colunas).
Assim como as matrizes, os dataframes também possuem dimensão, e podemos verificar a dimensão
através do comando dim():

1 dim(mtcars)
2 [1] 32 11

No script abaixo, seguem outros comandos úteis para serem usados com os dataframes:

1 # retorna o nome das colunas do dataframe

2 names(mtcars)

1 # retorna um resumo estatístico das colunas do dataframe

2 summary(mtcars)

1 # retorna as 6 últimas linhas do dataframe

2 tail(mtcars)

No script acima aproveitamos para apresentar a sinalização de comentário. Toda linha no R iniciada
com o # não é interpretada pelo console. Assim, o símbolo # é usado para incluirmos comentários
em nosso código. Veja que no script, cada linha iniciada pelo sinal # explica o comando seguinte.
Podemos acessar qualquer registro dentro do dataframe utilizando a mesma notação de matrizes:
 Estrutura de dados 16

1 mtcars[,3]
2 [1] 160.0 160.0 108.0 258.0 360.0 225.0 360.0 146.7 140.8 167.6 167.6 275.8
3 [13] 275.8 275.8 472.0 460.0 440.0 78.7 75.7 71.1 120.1 318.0 304.0 350.0
4 [25] 400.0 79.0 120.3 95.1 351.0 145.0 301.0 121.0

1 mtcars[3, 5]
2 [1] 3.85

1 mtcars[1,]
2 mpg cyl disp hp drat wt qsec vs am gear carb
3 Mazda RX4 21 6 160 110 3.9 2.62 16.46 0 1 4 4

1 mtcars[1:3,]
2 mpg cyl disp hp drat wt qsec vs am gear carb
3 Mazda RX4 21.0 6 160 110 3.90 2.620 16.46 0 1 4 4
4 Mazda RX4 Wag 21.0 6 160 110 3.90 2.875 17.02 0 1 4 4
5 Datsun 710 22.8 4 108 93 3.85 2.320 18.61 1 1 4 1

Outro recurso poderoso do R são os filtros. Você pode tanto usar a notação de [ ] ou então a função
subset(). Vamos ver alguns exemplos de filtros. No exemplo 1, imagine que queremos separar as
linhas que possuem o valor 4 na variável cyl. Podemos usar a função subset() ou a notação [ ]:

1 subset(mtcars, mtcars$cyl == 4)
2 mpg cyl disp hp drat wt qsec vs am gear carb
3 Datsun 710 22.8 4 108.0 93 3.85 2.320 18.61 1 1 4 1
4 Merc 240D 24.4 4 146.7 62 3.69 3.190 20.00 1 0 4 2
5 Merc 230 22.8 4 140.8 95 3.92 3.150 22.90 1 0 4 2
6 Fiat 128 32.4 4 78.7 66 4.08 2.200 19.47 1 1 4 1
7 Honda Civic 30.4 4 75.7 52 4.93 1.615 18.52 1 1 4 2
8 Toyota Corolla 33.9 4 71.1 65 4.22 1.835 19.90 1 1 4 1
9 Toyota Corona 21.5 4 120.1 97 3.70 2.465 20.01 1 0 3 1
10 Fiat X1-9 27.3 4 79.0 66 4.08 1.935 18.90 1 1 4 1
11 Porsche 914-2 26.0 4 120.3 91 4.43 2.140 16.70 0 1 5 2
12 Lotus Europa 30.4 4 95.1 113 3.77 1.513 16.90 1 1 5 2
13 Volvo 142E 21.4 4 121.0 109 4.11 2.780 18.60 1 1 4 2
 Estrutura de dados 17

1 mtcars[mtcars$cyl == 4,]
2 mpg cyl disp hp drat wt qsec vs am gear carb
3 Datsun 710 22.8 4 108.0 93 3.85 2.320 18.61 1 1 4 1
4 Merc 240D 24.4 4 146.7 62 3.69 3.190 20.00 1 0 4 2
5 Merc 230 22.8 4 140.8 95 3.92 3.150 22.90 1 0 4 2
6 Fiat 128 32.4 4 78.7 66 4.08 2.200 19.47 1 1 4 1
7 Honda Civic 30.4 4 75.7 52 4.93 1.615 18.52 1 1 4 2
8 Toyota Corolla 33.9 4 71.1 65 4.22 1.835 19.90 1 1 4 1
9 Toyota Corona 21.5 4 120.1 97 3.70 2.465 20.01 1 0 3 1
10 Fiat X1-9 27.3 4 79.0 66 4.08 1.935 18.90 1 1 4 1
11 Porsche 914-2 26.0 4 120.3 91 4.43 2.140 16.70 0 1 5 2
12 Lotus Europa 30.4 4 95.1 113 3.77 1.513 16.90 1 1 5 2
13 Volvo 142E 21.4 4 121.0 109 4.11 2.780 18.60 1 1 4 2

Agora, imagine que queremos as variáveis mpg e hp das observações que possuem o valor 4 na
variável cyl:

1 subset(mtcars, mtcars$cyl == 4, select = c("mpg", "hp"))

2 mpg hp
3 Datsun 710 22.8 93
4 Merc 240D 24.4 62
5 Merc 230 22.8 95
6 Fiat 128 32.4 66
7 Honda Civic 30.4 52
8 Toyota Corolla 33.9 65
9 Toyota Corona 21.5 97
10 Fiat X1-9 27.3 66
11 Porsche 914-2 26.0 91
12 Lotus Europa 30.4 113
13 Volvo 142E 21.4 109

1 mtcars[mtcars$cyl == 4, c(1, 4)]

2 mpg hp
3 Datsun 710 22.8 93
4 Merc 240D 24.4 62
5 Merc 230 22.8 95
6 Fiat 128 32.4 66
7 Honda Civic 30.4 52
8 Toyota Corolla 33.9 65
9 Toyota Corona 21.5 97
10 Fiat X1-9 27.3 66
 Estrutura de dados 18

11 Porsche 914-2 26.0 91

12 Lotus Europa 30.4 113
13 Volvo 142E 21.4 109

Agora é só usar a imaginação e filtrar os dados como melhor lhe convier!

A última estrutura de dados que iremos ver são as listas. Listas funcionam como um varal. Num
varal podemos pendurar vários tipos de coisas. Você pode pendurar roupas, quadros, cadeira, fotos
e várias outras coisas que você nem imagina. No R, a lista funciona da mesma forma. Você pode
incluir numa lista diferentes dados e estruturas.
Lembra-se das variáveis a e idade que criamos anteriormente? Pois bem, vamos adicioná-las
juntamente com o dataframe mtcars a uma lista chamada dados.

1 dados = list(mtcars, a, idade)

Agora, a lista dados possui na sua posição 1 o dataframe mtcars, na sua posição 2 o vetor numérico
de um elemento a e na posição 3 o vetor idade. Para recuperar o objeto de uma lista, podemos usar
a notação [[ ]]. Veja o exemplo para recuperar o objeto salvo na posição 3:

1 dados[[3]]

Ao longo deste capítulo, criamos na memória do nosso computador várias variáveis. Você consegue
se lembrar de todas elas? Não se preocupe. Existe uma função que faz isto para você:

1 ls()
2 [1] "a" "b" "dados" "experiencia" "idade"
3 [6] "m1" "m2" "mtcars" "x"

E se não quisermos mais a variável x? Sem problemas, podemos deletar através do comando rm():

1 rm(x)

Se quiser excluir todas as variáveis que você criou na memória, basta usar o comando:

1 rm(list = ls(all=TRUE))

Como este livro é para ensinar os primeiros passos, o que você viu até aqui são as estruturas e tipos
de dados mais utilizados. Mas existem outras estruturas que com o passar do tempo, você terá a
oportunidade de aprender!
 Operadores matemáticos
Agora que você já está se acostumando ao R, chegou a hora de aprender a notação dos principais
operadores matemáticos. Existem algumas exceções, mas para facilitar o aprendizado, como estamos
falando de operadores matemáticos, assumiremos que nossas variáveis são numéricas.
Para os exemplos abaixo, crie as seguintes variáveis:

1 a = 2
2 b = 100
3 c = c(1, 2, 3, 4, 5)

Vamos agora utilizar as variáveis acima e ver diversos exemplos de cada um dos operadores
matemáticos abaixo:

• Soma

1 a + 10
2 [1] 12

1 a + b
2 [1] 102

1 a + b + 102
2 [1] 204

1 c + 10
2 [1] 11 12 13 14 15

• Subtração

19
 Operadores matemáticos 20

1 a - 10
2 [1] -8

1 a - b
2 [1] -98

1 a + b – 102
2 [1] 0

1 c - 10
2 [1] -9 -8 -7 -6 -5

• Divisão

1 b / 10
2 [1] 10

1 a / b
2 [1] 0.02

1 a + b / 10
2 [1] 12

1 (a + b) / 10
2 [1] 10.2

A divisão e multiplicação têm preferência sobre a adição e subtração. Para estabelecer prioridades,
utilize ().

• Multiplicação
 Operadores matemáticos 21

1 b * 10
2 [1] 1000

1 a * b
2 [1] 200

1 a + b * 10
2 [1] 1002

1 (a + b) * 10
2 [1] 1020

• Exponenciação

1 a^2
2 [1] 4

1 a^b
2 [1] 1.267651e+30

1 a^-1
2 [1] 0.5

1 c^2
2 [1] 1 4 9 16 25

Quando o número é muito alto ou muito pequeno, o R apresenta o valor em notação científica,
utilizando o termo e+. Isto indica que o número apresentado deve ser multiplicado por 10 tantas
vezes quanto o número que acompanha e+. Assim 1.267651e+30 equivale a 1.267651(103 0)

• Resto da divisão (reminder)

A maioria das pessoas não está acostumada a usar o resto da divisão. No inglês, chamamos este
operador de reminder. Imagine um número qualquer x. Se a divisão de x por 2 tiver resto zero, x é
par. Se o resto da divisão for diferente de zero, x é impar. Este é um exemplo do uso do operador
reminder para verificar se um número é par ou ímpar. Veja alguns exemplos de como obter o resto
de uma divisão:
 Operadores matemáticos 22

1 10 %% 2
2 [1] 0

1 11 %% 2
2 [1] 1

1 11 %% 3
2 [1] 2

• Raiz quadrada

A raiz quadrada pode ser obtida por duas formas. A primeira é através da operação de exponenciação,
lembrado que a raiz quadrada de x, por exemplo, é equivalente à x elevado a meio. Outra alternativa
é uma função sqrt().

1 sqrt(4)
2 [1] 2

1 4^(1/2)
2 [1] 2

Prefira a forma de exponenciação, pois assim fica fácil realizar a raiz de outros números. Por exemplo,
a raiz cúbica de 9:

1 9^(1/2)
2 [1] 3

• Logaritmo

O logaritmo também é uma operação que o R realiza através de funções, que no caso é a função
log(). Esta função possui um parâmetro opcional que é a base. Quando nada é informado, a base é
automaticamente definida como número de euller, retornando portanto o logaritmo natural.

1 log(10) #base neperiana

2 [1] 2.302585
 Operadores matemáticos 23

1 log(10, 10) #notação para logaritmo de 10 na base 10

2 [1] 1

1 log(8, 2) #notação para logaritmo de 8 na base 2

2 [1] 3

Veja que passamos pelos principais operadores matemáticos. É claro que os exemplos aqui descritos
são simples e servem para você aprender a como chamá-los no R.

Agora você é capaz de combiná-los e formar cálculos imensos e complexos! Qual o resultado
de: 10%%339 - 100 + 1250/23 * 78 + (10 * 12/33 )
 Operadores lógicos
Os operadores lógicos são utilizados para verificar se uma relação é verdadeira ou falsa. Assim em
função da condição estabelecida, o R retorna TRUE (verdadeiro) ou FALSE (Falso). O uso isolado dos
operadores lógicos não faz muito sentido e geralmente são estruturas utilizadas para a construção
de filtros para matriz e dataframes e para construção da estrutura if.
A estrutura if é usada para definir uma ação em função do resultado do operador lógico. Por
exemplo, se a idade de uma árvore for maior que 2 metros, calcula-se o volume da mesma, caso
a altura da árvore seja inferior a 2, atribui-se o valor 0 para volume. Veremos a estrutura if com
mais profundidade ao final deste capítulo, mas a título de ilustração, vamos ver como ficaria o script
do exemplo acima:

1 if(altura > 2){

2 volume = diametro * altura * fatorForma} else {
3 volume = 0}

Voltando aos operadores lógicos, vamos ver como é a sintaxe das seguintes relações:

• Igualdade

1 a = 10
2 b = 14
3 c = 10

1 a == b
2 [1] FALSE

1 a == c
2 [1] TRUE

• Diferente

24
 Operadores lógicos 25

1 d = c(1, 4, 2, 6)
2 e = 14
3 f = 4

1 length(d) != e
2 [1] TRUE

1 length(d) != f
2 [1] FALSE

• Maior

1 g = c(1, 1, 1, 1)
2 h = 14
3 i = c(8, 3, 1, 2)

1 length(g) > h
2 [1] FALSE

1 h > length(i)
2 [1] TRUE

1 length(g) > length(i)

2 [1] FALSE

• Maior ou igual

1 g = c(1, 1, 1, 1)
2 h = 14
3 i = c(8, 3, 1, 2)
 Operadores lógicos 26

1 length(g) >= h
2 [1] FALSE

1 h >= length(i)
2 [1] TRUE

1 length(g) >= length(i)

2 [1] TRUE

• Menor

1 a = 1/2
2 b = 14
3 c = 0.5

1 a < b
2 [1] TRUE

1 b < c
2 [1] FALSE

1 a < c
2 [1] FALSE

• Menor ou igual

1 a = 1/2
2 b = 14
3 c = 0.5
 Operadores lógicos 27

1 a <= b
2 [1] TRUE

1 b <= c
2 [1] FALSE

1 a <= c
2 [1] TRUE

O operador lógico muito útil é o operador “estar contido”. Por exemplo, você pode querer verificar
se um determinado número está contido num determinado vetor. Vejamos um exemplo:

1 vetor = c(4, 10, 56, 78, 91)

2 numero = 10
3 numero %in% vetor
4 [1] TRUE

As condições podem ser conferidas combinando duas ou mais operações lógicas. O conector E, cujo
símbolo é &, verifica se as duas condições são atendidas simultaneamente:

1 a = 10
2 b = 20
3 c = 100
4 a == c/10 & b == a/2
5 [1] FALSE
6 a == c/10 & a == b/2
7 [1] TRUE

O conector OU, cujo símbolo é |, verifica se pelo menos uma das condições é atendida:

1 a = 10
2 b = 20
3 c = 100

1 a == c/10 | b == a/2
2 [1] TRUE
 Operadores lógicos 28

1 a == c/10 | a == b/2
2 [1] TRUE

Agora, que entendemos melhor como funcionam os operadores lógicos, podemos avançar nas
construções de condicionantes (função if ). A função if é muito utilizada quando dentro do código
precisamos analisar uma condição e tomar uma decisão de acordo com o resultado desta condição.
Veja o exemplo apresentado no início deste capítulo. Qual o volume se a nossa árvore possui altura
de 10 metros, com diâmetro de 0.2 metros (20 centímetros) e um fator de forma de 0.5? Troque as
variáveis pelos valores apresentados:

1 altura = 10
2 diametro = 0.2
3 fatorForma = 0.5
4 if(altura > 2){
5 volume = (pi() * (diametro^2) / 40000) * altura * fatorForma} else {
6 volume = 0}
7 volume
8 [1] 0.6283185

Agora vamos aproveitar, e incluir mais uma condição. Imagine agora que árvores com mais de 15
metros tenham um fator de forma de 0.75 e árvores entre 2 e 15 metros tenham fator de forma de
0.5. A nossa condicionante passa a ser:

1 if(altura >= 15){

2 volume = (pi * (diametro^2) / 40000) * altura * 0.75} else if ( altura > 2 & al\
3 tura < 15){
4 volume = (pi * (diametro^2) / 40000) * altura * 0.5} else {
5 volume = 0}
 Adicionando pacotes
Os usuários podem criar soluções e salvá-las em forma de pacotes, que por sua vez podem ser
distribuídos e adicionados por outros usuários. Os pacotes podem ser construídos integrando outras
linguagens como por exemplo o JAVA, o C e o Fortran.
Para que um pacote seja distribuído pelo repositório oficial do R, é necessário que ele siga um
padrão mínimo de documentação. Uma vez listado no repositório oficial, o pacote fica disponível
para download através dos espelhos do servidor do CRAN (The Comprehensive R Archive Network).
A instalação de um pacote pode ser feita através de um comando específico ou através do menu
de opções do R. O ggplot2, por exemplo, é um pacote gráfico que pode ser adicionado ao R via
isntalação de pacotes. Assim, para instalarmos este pacote através de linha de comando, devemos
digitar no console a linha:

1 install.packages("ggplot2")

Não esqueça que no comando install.packages() o nome do pacote tem que vir entre aspas.

Na primeira vez que este comando for utilizado, o R irá perguntar de qual espelho o download de
pacotes deverá ser feito.

Recomendo que escolha um espelho próximo de onde você mora, para que o download seja
mais rápido.

No entanto, mesmo que um pacote esteja instalado, ele não fica automaticamente carregado. Para
que sua funcionalidade torne-se disponível é necessário carregar o pacote sempre que se inicia o R.
Se desejarmos carregar o pacote ggplot2 instalado há pouco, devemos digitar no console o comando:

1 require(ggplot2)

Diferentemente da função install.packages(), a função require() não requer que o nome do

pacote seja apresentado entre aspas.

Outra opção é utilizar o menu de opções do R, clicando na opção Packages e depois Install
packages(s):

29
Adicionando pacotes 30

Menu Install Packages

Na primeira vez que você for instalar um pacote, o R irá mostrar uma lista dos servidores do
CRAN disponíveis. Escolha uma das opções apresentadas e clique Ok. Dê preferência por servidores
próximos de você.
Adicionando pacotes 31

Escolhendo servidores disponíveis

Após escolher o servidor, aparecerá uma nova lista contendo os pacotes disponíveis para instalação.
Escolha um ou mais e clique Ok.
Adicionando pacotes 32

Escolhendo o pacote a ser instalado

RStudio
O RStudio é um ambiente de desenvolvimento integrado para tornar a vida do usuário do R mais
poderosa e produtiva. Ele é gratuito, código aberto e trabalha nas plataformas Windows, Mac e
Linux.
A instalação do RStudio é muito simples. Ao acessar a página http://www.rstudio.com/products/RStudio/#Desk,
escolha a opção que melhor se ajusta ao seu sistema operacional. Baixe o instalador e siga as
orientações do assistente de instalação.

Vale lembrar que primeiro você precisa instalar o R. E em seguida instale o RStudio.

Pode ser necessário possuir a licença de administrador para que o R consiga associar corretamente
sua extensão na configuração interna do seu sistema operacional. Quando se trabalha no RStudio,
não é necessário abrir o R, pois o RStudio já comunica automaticamente com ele.
Tudo que você faz no RStudio, você é capaz de fazer diretamente no R. Assim, você deve estar
se perguntando: por que então utilizar o RStudio? A resposta é: porque a interface gráfica é mais
amigável e organizada, facilitando o seu dia-a-dia. De qualquer maneira, gosto não se discute. Utilize
aquele que lhe proporcionar mais conforto.

Logo RStudio

Vamos conhecer então, um pouco mais do ambiente do RStudio. Ao abrir o RStudio pela primeira vez,
clicando no ícone semelhante à figura acima, você estará utilizando uma interface gráfica composta
de 3 janelas:

33
 RStudio 34

Interface RStudio com 3 janelas

Na janela da esquerda você está vendo o console, que possui a mesma função do console do R.
Ou seja, é nele onde os comandos são processados. O console do RStudio apresenta a versão do R
instalada em seu computador.

1 R version 3.0.1 (2013-05-16) -- "Good Sport"

2 Copyright (C) 2013 The R Foundation for Statistical Computing
3 Platform: x86_64-w64-mingw32/x64 (64-bit)
4
5 R is free software and comes with ABSOLUTELY NO WARRANTY.
6 You are welcome to redistribute it under certain conditions.
7 Type 'license()' or 'licence()' for distribution details.
8
9 R is a collaborative project with many contributors.
10 Type 'contributors()' for more information and
11 'citation()' on how to cite R or R packages in publications.
12
13 Type 'demo()' for some demos, 'help()' for on-line help, or
14 'help.start()' for an HTML browser interface to help.
15 Type 'q()' to quit R.
16
17 >
RStudio 35

Na janela superior direita, você encontra duas abas: o Environment (Ambiente) o History (histórico).
A aba Environment mostra todas as variáveis que estão criadas e armazenadas na memória flutuante
do seu computador. Esta memória flutuante é também conhecida como memória RAM. Assim, o seu
computador pode apresentar lentidão, ou até mesmo travar se suas variáveis ocuparem um espaço
superior à memória RAM disponível.
A aba History armazena todas as linhas que foram processadas no seu console. Assim, você pode
facilmente recuperar uma linha ou comando processado anteriormente.
Na janela inferior direita você encontra cinco abas: Files (arquivos), Plots (gráficos), Packages
(Pacotes), Help (Ajuda) e Viewer (Visualizador). Por hora, precisamos saber que o Files irá mostrar
todos os arquivos e pastas presentes no meu Workspace (Espaço de trabalho – veremos mais sobre
ele no próximo capítulo). As abas Plots e Viewer servem para visualizarmos os resultados gráficos
das nossas análises. Ao longo deste livro, utilizaremos apenas a aba Plots. Na aba Packages podemos
gerenciar os pacotes disponíveis para o R, instalando, ativando e removendo pacotes. Por fim, a aba
Help permite acessar a documentação dos pacotes e funções, para consultar a sintaxe, explicações e
exemplos de uso.
Também é muito comum utilizarmos a interface do RStudio com 4 janelas. Neste caso, o console
passa a ocupar a janela inferior esquerda, e o script passa a ocupar a janela superior esquerda.

Interface RStudio com 4 janelas

O uso do script e console dento do RStudio é idêntico ao que vimos no capítulo Sobre o R. Assim,
se ficou alguma dúvida, faça uma releitura do capítulo, só que agora realizando os exemplos no
RStudio.
RStudio 36

De agora em diante, os exemplos serão conduzidos no RStudio, mas nada impede que você
realize suas análises diretamente no R.
Espaço de trabalho
Neste momento, você já teve um primeiro contato com a linguagem R e deve estar ansioso para
utilizá-la no dia-a-dia. Nos próximos capítulos, colocaremos a mão na massa para conduzir uma
sequência de análises gráficas e exploratórias.
Ao abrir o RStudio pela primeira vez, note que no canto superior esquerdo haverá ícone informando
que não há um espaço de trabalho aberto (Project: None):

Espaço de trabalho não definido

Assim, acostume-se a sempre realizar uma das duas alternativas abaixo: * Ou abrir um espaço de
trabalho já existente (Open Project) * Ou criar um novo espaço de trabalho (New Project)

Novo projeto

A regra geral é: opte por criar um novo espaço de trabalho, sempre que você for iniciar uma análise.
Opte por abrir um espaço de trabalho já existente quando você quiser continuar ou modificar uma
análise anteriormente realizada. Para entender melhor as opções relacionadas ao espaço de trabalho,
vamos nos basear em três cenários diferentes.
Cenário 1. Imagine que queremos fazer a análise estatística de um experimento no R. Os dados
coletados deste experimento estão digitados dentro de um arquivo Excel, salvo numa pasta chamada
Experimento 1 (diretório: C:Users\egorgensDocumentsAnalisesExperimento 1):

37
Espaço de trabalho 38

Árvore de arquivos

Neste exemplo já temos um diretório criado no computador contendo o arquivo que queremos
analisar. Desta forma, ao abrir o RStudio, basta avisarmos para o programa que nosso espaço de
trabalho é o diretório no qual os dados estão salvos. Os passos seriam:

1. Clique na lista suspensa ao lado do Project: (None).

2. Clique em New Project.

Novo projeto

1. Clique em Existing Directory.

Espaço de trabalho 39

Diretório existente

1. Através do botão Browse, selecione o diretório do Experimento 1 e clique em Create Project.

Criar projeto

Perceba agora, que o espaço de trabalho está definido e amarrado ao diretório do Experimento 1.
Espaço de trabalho 40

Espaço de trabalho Experimento 1

Cenário 2. Imagine agora que queremos fazer a análise estatística de um segundo experimento no
R. Os dados coletados deste experimento acabaram de chegar por email e ainda não estão salvos
numa pasta de trabalho. Assim, desejamos criar uma pasta para o Experimento 2 e ao mesmo tempo
amarrar o espaço de trabalho a esta pasta criada. Os passos seriam:

1. Clique na lista suspensa ao lado do Project: (None).

2. Clique em New Project.

Novo projeto

1. Clique em New Directory.

Espaço de trabalho 41

Novo diretório

1. Clique em projeto vazio (Empty Project).

Projeto vazio

1. Dê o nome do diretório a ser criado e o local do seu computador onde este diretório ficará
salvo. Finalize a criação clicando em Create Project.
Espaço de trabalho 42

Criar projeto

Perceba agora, que o espaço de trabalho está definido e amarrado ao diretório do Experimento 2.

Espaço de trabalho Experimento 2

Toda vez que o RStudio for iniciado, será exibido o último espaço de trabalho salvo.

Cenário 3. Agora, suponha que você deseja continuar a análise do Experimento 1. Mas o espaço de
trabalho ativo é o experimento 2. Neste caso, basta:

1. Clique na lista suspensa ao lado do Experimento 1, no canto superior direito.

2. Clique em Open Project.
Espaço de trabalho 43

Abrir projeto existente

1. Escolha um projeto salvo anteriormente.

Você conseguirá utilizar o RStudio mesmo sem definir o espaço de trabalho. No entanto, existem
alguns benefícios quando quando definimos o espaço de trabalho:

• Toda análise (tabelas e gráficos) quando exportada é salva automaticamente na pasta vincu-
lada ao espaço de trabalho.
• O RStudio enxerga automaticamente os arquivos existentes dentro da pasta sem a necessidade
de informar o endereço completo quando realizar uma manipulação de arquivo (ex: importar
uma planilha).
• Tem a opção de salvar o histórico (History) e as variáveis armazenadas na memória (Environ-
ment).
 Importando dados
Grande parte dos dados que utilizaremos em nossas análises estarão salvos em planilhas eletrônicas
como Excel, LibreOffice e outros. Embora seja possível importar arquivos com extensão xls e xlsx,
recomendo que seja utilizado sempre a extensão genérica csv (comma-separeted value). Todo arquivo
do tipo csv possui dois elementos básicos que podem influenciar na importação:

• o separador decimal
• a tabulação (ou separador de colunas)

No formato regional brasileiro, o separador decimal é a vírgula (,) e o separador de coluna é o ponto
e vírgula (;). Já no formato americano, utiliza-se o ponto (.) como separador decimal e a vírgula (,)
como separador de colunas.
Durante a importação de uma planilha eletrônica, pode ser necessário informar qual o separador
decimal e qual o separador de colunas utilizados no arquivo, para que a leitura dos dados pelo R
ocorra sem problemas.
Dois comandos podem ser utilizados para importar os dados:

1 read.csv(arquivo, sep=..., dec=...)

2 read.table(arquivo, sep=..., dec=...)

Ambos comandos possuem os parâmetros que definem o separador de colunas e o separador decimal:
sep para separador de colunas e dec para separador decimal.

Faça o download do arquivo csv que iremos importar em:

http://gorgens.wix.com/compr#!blank/tz1v5

Vamos importar o arquivo? Se o separador de colunas e o separador decimal do seu arquivo estiver de
acordo com as configurações regionais de seu computador e o arquivo a ser importado salvo dentro
do diretório vinculado ao espaço de trabalho (workspace), é possível utilizar a versão simplificada
dos importadores:

1 df = read.csv("flowering.csv")

No caso dos separadores estarem de acordo com as configurações regionais, mas o arquivo a ser
importado não estiver dentro do diretório vinculado ao workspace é necessário informar o caminho
completo antes do nome do arquivo:

44
 Importando dados 45

1 df = read.csv("C:/Users/Gorgens/Documents/Analises/Experimento 1/flowering.csv")

Se você não tem certeza quanto aos separadores utilizados na planilha a ser importada,
defina os parâmetros!

Por exemplo, o arquivo exemplo possui separador de colunas ;, assim construímos o comando de
importação como:

1 df = read.csv("flowering.csv", sep = ";")

O nome df é um nome arbitrário para a variável que irá armazenar os dados que estamos
importando.

Antes de iniciar as análises com os dados importados, sempre desconfie!

Inspecione o objeto que recebeu os dados importados para garantir que não houve problemas com
o separador decimal, nem com o separador de colunas. Diversos comandos podem ser usados para
investigar os dados. Veja alguns exemplos:

• Veja se o número de linhas e colunas correspondem à planilha eletrônica importada:

1 dim(df)

• Confira se as primeiras linhas dos dados importados correspondem às primeiras linhas do

arquivo original:

1 head(df)

• Você também pode conferir as últimas linhas dos dados importados através do comando:

1 tail(df)

• Veja o sumário estatísticos dos dados e veja se as colunas de números e textos foram
corretamente importados:
 Importando dados 46

1 summary(df)
 Dataframe
Dataframe é o objeto do R usado para armazenar dados dispostos em forma de tabela. Na prática, o
dataframe é um conjunto de vetores combinados lado a lado nas colunas. Ao contrário das matrizes,
as colunas de um dataframe podem ser de tipos diferentes.
Vamos importar um dataframe utilizando o comando que aprendemos no capítulo anterior. No
entanto, vamos utilizar um separador decimal sabidamente errado para ilustrarmos a importância
de avaliarmos a qualidade da importação

1 df = read.csv("flowering.csv", sep = ",", dec = ".")

Agora, veja os resultados dos comandos dim() e head(). O que você acha que deu errado?

1 df = read.csv("flowering.csv", sep=",", dec=".")

1 dim(df)
2 [1] 3124 1

1 head(df)
2 Nome.Origem.MesFlorescimento.Fases
3 1 Abies alba Mill.;nativa;2;0
4 2 Acer campestre L.;nativa;2;0
5 3 Acer monspessulanum L.;nativa;2;0
6 4 Acer opalus Mill.;nativa;2;0
7 5 Acer platanoides L.;nativa;2;0
8 6 Acer pseudoplatanus L.;nativa;1;0

Esta é fácil. O separador de colunas “,” não funcionou. Veja que a dimensão do dataframe importado
é de 3124 linhas e 1 coluna. Mas nosso arquivo original possui 4 colunas. O comando head() nos dá a
pista do separador correto. Veja que entre nossas colunas originais apareceu um “;”. Veja a diferença
se utilizarmos o separador de colunas correto:

1 df = read.csv("flowering.csv", sep = ";", dec = ".")

Agora sim, nossa planilha foi importada de forma correta:

47
 Dataframe 48

1 df = read.csv("flowering.csv", sep=";", dec=".")

1 dim(df)
2 [1] 3114 4

1 head(df)
2 Nome Origem MesFlorescimento Fases
3 1 Abies alba Mill. nativa 2 0
4 2 Acer campestre L. nativa 2 0
5 3 Acer monspessulanum L. nativa 2 0
6 4 Acer opalus Mill. nativa 2 0
7 5 Acer platanoides L. nativa 2 0
8 6 Acer pseudoplatanus L. nativa 1 0

No script abaixo estão listadas e comentadas as principais funções para trabalhar com dataframes:

1 names(df) # Retorna o nome das colunas

1 dim(df) # Retorna o número de linhas seguido do número de colunas

1 head(df) # Retorna as 6 primeiras linhas

1 tail(df) # Retorna as 6 últimas linhas

1 nrow(df) # Retorna o número de linhas

1 ncol(df) # Retorna o número de colunas

O acesso a elementos, linhas e colunas de um dataframe pode ser realizado da mesma maneira que
as matrizes utilizando a notação de [ ] logo após o nome do dataframe que se deseja manipular.

Execute as linhas do script abaixo no seu console. Todas as linhas foram construídas
considerando o dataframe df que criamos a pouco: df[1,1] df[1,] df[,2] df[100:200, 3]

Além da notação de [ ] existem uma notação alternativa para selecionar colunas de um dataframe:
a notação de $. Assim, a seleção da coluna 2 pode ser feita de duas maneiras:
 Dataframe 49

1 # notação de [ ]
2 df[,2]

1 # notação de $
2 df$Origem

Na notação de $, o nome da coluna a ser selecionada vem precedido do nome do dataframe

separado pelo $.

Imagine que desejamos transformar os dados da coluna MesFlorescimento tirando a raiz quadrada
dos valores e salvar numa nova coluna chamada FlorTrans. Podemos fácil realizar esta operação
através do comando:

1 df$FlorTrans = sqrt(df$MesFlorescimento)

Se visualizarmos os nomes das colunas do dataframe df, veremos que agora temos 5 colunas e uma
delas chama-se FlorTrans:

1 names(df)
2 [1] "Nome" “Origem" "MesFlorescimento"
3 [4] "Fases" "FlorTrans"

Através da função summary(), podemos obter um resumo estatístico das colunas do dataframe:

1 summary(df)
2 Nome Origem MesFlorescimento
3 Abies alba Mill. : 1 nativa:2487 Min. : 1.000
4 Acer campestre L. : 1 exotica: 627 1st Qu.: 2.000
5 Acer monspessulanum L.: 1 Median : 3.000
6 Acer negundo L. : 1 Mean : 2.811
7 Acer opalus Mill. : 1 3rd Qu.: 3.000
8 Acer platanoides L. : 1 Max. :12.000
9 (Other) :3108
10 Fases FlorTrans
11 Min. :0.000000 Min. :1.000
12 1st Qu.:0.000000 1st Qu.:1.414
13 Median :0.000000 Median :1.732
14 Mean :0.007065 Mean :1.648
15 3rd Qu.:0.000000 3rd Qu.:1.732
16 Max. :2.000000 Max. :3.464
 Dataframe 50

Interpretando a saída acima, vemos que a primeira coluna é formada por nomes de espécies
diferentes, pois o resumo apresentou quantas vezes os 6 primeiros nomes apareceram e todos eles
apareceram uma única vez.
A segunda coluna também é texto, e indica se as espécies levantadas são nativas (nativa) ou exóticas
(exotica). No nosso dataframe temos 2487 observações nativas e 627 observações exóticas.
As colunas três, quatro e cinco são numéricas e por isto as principais estatísticas descritivas de
posição são apresentadas.
Suponha agora, que desejamos dividir o dataframe em dois. Um contendo apenas as observações
exóticas (627) e outro contendo apenas as observações nativas (2487). Uma alternativa é utilizarmos
a notação já aprendida de [ ]:

1 ex = df[df$Origem == “exotica”,]

Interpretando o comando acima literalmente, solicitamos que se crie um novo dataframe chamado
ex com as linhas do dataframe df que contenham na coluna Origem o valor exotica.
Outra opção para realizar a mesma tarefa é a função subset(). E o comando ficaria assim:

1 ex = subset(df, Origem == “exotica”)

Ambos os comandos retornam um dataframe contendo apenas as observações exóticas dos nossos
dados.

Você consegue criar o comando para agora criar um dataframe apenas com os dados das
observações de nativas?

A resposta correta seria:

1 in = df[df$Origem == “nativa”,]

Ou:

1 in = subset(df, Origem == “nativa”)

 Pacote gráfico básico
Para explorarmos os gráficos, vamos criar um dataframe fictício contendo 12 árvores, 6 pertencentes
a um grupo denominado de pequena e outras 6 pertencentes a um grupo denominado de grande. A
criação de dataframes por meio da digitação direta pode ser feita pela função data.frame() conforme
nosso script abaixo:

1 arvores <- data.frame(altura = c(15,18,22,24,25,30,31,34,37,39,41,45),

2 dap = c(2,4.5,6,10,30,34,50,56,60,77.5,80,85), categoria = rep(c("pequena", "gra\
3 nde"), each=6))

Vamos explorar agora as funções gráficas básicas relacionados à função plot() e seus derivados como
boxplot() e histogram(). Estas funções são nativas do R, isto é, não necessitam de instalação nem de
ativação. Já estão prontamente disponíveis desde a instalação.

Gráfico de dispersão.
Os gráficos de dispersão são representações de duas ou mais variáveis em um gráfico de pontos, no
qual uma variável está disposta em função da outra. Ele é muito utilizado para correlacionar dados e
estudar o efeito de uma variável (X) sobre a outra (Y). Os gráficos de dispersão podem ser facilmente
criados pela função plot() utilizando duas sintaxes diferentes. Numas das sintaxes iremos informar
quem será a variável X seguido de quem será a variável Y:

1 plot(arvores$dap, arvores$altura)

Traduzindo literalmente o comando acima, solicitamos que seja construído um gráfico de dispersão
em que o eixo X represente o dap e o eixo Y represente a altura. Após processar o comando, o gráfico
irá aparecer na aba Plots (lateral inferior direita) do RStudio:

51
 Pacote gráfico básico 52

Gráfico de dispersão

O mesmo gráfico será criado, se utilizarmos a notação de função. Imagine um comando que crie um
gráfico de dispersão da altura em função do dap (diâmetro a altura do peito). Esta sentença pode ser
escrita pelo comando:

1 plot(altura ~ dap, data = arvores)

O resultado é o mesmo, com uma pequena diferença nos rótulos dos eixos:
 Pacote gráfico básico 53

Gráfico de dispersão com eixos customizados

Diversos parâmetros podem ser usados para customizar o nosso gráfico, como por exemplo:

Parâmetro Ação
xlab Altera o rótulo do eixo X
ylab Altera o rótulo do eixo Y
xlim Define os limites do eixo X
ylim Define os limites do eixo Y
main Define o título do gráfico
pch Altera forma do marcador

Inúmeros outros parâmetros podem ser utilizados. Os que estão apresentados na tabela são os mais
utilizados. Vejamos um script contendo um exemplo da função plot() com todos os parâmetros
mencionados acima:

1 plot(altura~dap, data = arvores,

2 xlab="dap (cm)", ylab="Altura (m)",
3 xlim=c(0,90), ylim=c(0,90),
4 main="Altura = f(dap)", pch = 20)

O gráfico que criamos com todos estes parâmetros opcionais é:

 Pacote gráfico básico 54

Gráfico de dispersão com marcadores diferentes

Curvas de regressão, também conhecidas como linhas de tendência podem ser adicionadas aos
gráficos de dispersão para melhor representação da relação entre as duas variáveis. A função abline()
é capaz de incluir num gráfico de dispersão qualquer linha de tendência linear. Veja o exemplo:

1 plot(altura ~ dap, data = arvores)

2 abline(lm(altura ~ dap, data = arvores))

Note que primeiro precisamos criar o gráfico de dispersão e depois adicionamos a linha de tendência
baseada numa regressão linear (função lm()). O resultado é:
 Pacote gráfico básico 55

Gráfico de dispersão com linha de tendência

Boxplot
O boxplot ou diagrama de caixa é uma representação para explorar um conjunto de dados
organizados em fatores. Assim o eixo X é categórico e representa os fatores e o eixo Y representa
a variável dependente dos fatores. Este gráfico mostra a variação de uma variável dentro de cada
fator através das seguintes estatísticas: mediana, 1º e 2º quartil, máximo e mínimo. Crie o boxplot:

1 boxplot(altura~categoria, data = arvores)

Veja que com o comando acima, solicitamos que um boxplot seja criado, avaliando a variável altura
dentro de cada fator presente na variável categoria. O resultado do comando acima é:
 Pacote gráfico básico 56

Gráfico de caixas, também conhecido como boxplot

A função boxplot() está sujeita aos mesmos parâmetros da função plot() vistos anteriormente.
Outros parâmetros também podem ser utilizados de acordo com a conveniência do usuário. Mais
informações no help da função que pode ser acesso via console digitando:

1 ?boxplot.

Histograma
O histograma representa a distribuição de frequências ao longo da amplitude de ocorrência das
observações. Os dados são agrupados em classes e a altura da coluna da respectiva classe representa
a frequência com que esta classe está presente nos dados. O histograma da altura pode ser criado
pelo comando:

1 hist(arvores$altura)

Como resultado do comando acima, obtivemos um histograma 6 classes e a respectiva frequência

das observações:
 Pacote gráfico básico 57

Histograma

Vários parâmetros podem ser usados na função hist(). Um exemplo é o parâmetro freq=FALSE que
pode ser usado quando desejamos que ao invés da frequência seja apresentada a densidade de cada
classe.

1 hist(arvores$altura, freq=FALSE)

Outro parâmetro interessante é o breaks, que define a quantidade de quebras que serão considerados
durante a criação do histograma.

1 hist(arvores$altura, breaks=3)

O resultado assim, é um menor número de colunas, já que os dados serão separados apenas por três
quebras:
Pacote gráfico básico 58

Histograma com número de quebras redefinidas

Para maiores informações sobre os parâmetros, recorra ao help da função, que pode ser acessado
pelo console através do comando ?hist.
Existem outras opções de gráficos básicos. Seguem algumas sugestões de leitura:

• http://www.statmethods.net/graphs/creating.html
• http://ecologia.ib.usp.br/bie5782/doku.php?id=bie5782:03_apostila:05a-graficos
 Looping WHILE
Estrutura de repetição while é uma estrutura de desvio do fluxo presente em linguagens de
programação que repete um determinado algoritmo enquanto uma condição se mantiver verdadeira.

Fluxograma do looping WHILE

Estão associados à estrutura de repetição while uma condição e um bloco de código. Após o final
da execução do bloco, a condição é verificada, e caso ela ainda seja verdadeira, o bloco de código é
executado novamente. O objetivo do looping while é repetir uma determinada tarefa até que uma
condição não seja mais atendida.
O looping while é construído a partir da sentença genérica:

1 while (condição) {
2
3 Bloco de código
4
5 }

A sentença acima diz ao R que irá começar um looping while, executando um bloco de código até
que a condição deixe de ser atendida.
Vamos criar um looping while a partir da mesma base de dados do capítulo anterior:

1 arvores <- data.frame(altura =

2 c(15,18,22,24,25,30,31,34,37,39,41,45),
3 dap = c(2,4.5,6,10,30,34,50,56,60,77.5,80,85),
4 categoria = rep(c("pequena", "grande"), each=6))

Nosso objetivo será calcular a área basal das árvores rotuladas como pequena. Lembrando que a
área basal será a soma das áreas seccionais.
Embora o looping while não seja a melhor solução para este problema, vamos implementá-lo para
praticar:

59
 Looping WHILE 60

1 AB = 0
2 arvore = 1
3 rotulo = arvores$categoria[arvore]
4 while (rotulo == "pequena"){
5 AB = AB + ((arvores[arvore, 2]^2 * pi)/40000)
6 arvore = arvore + 1
7 rotulo = arvores$categoria[arvore]
8 }

A condição é que a árvore que estiver sendo analisada contenha rótulo pequena, ou seja

1 rotulo == "pequena"

Enquanto esta condição for verdadeira, o R executará o bloco de código que está escrito entre as {}:

1 AB = AB + ((arvores[arvore, 2]^2 * pi)/40000)

2 arvore = arvore + 1
3 rotulo = arvores$categoria[arvore]

O bloco de código começa calculando a área seccional da arvore 1 e acrescenta o valor calculado
na variável AB. Em seguida o atualiza o índice da árvore em 1, passando para a árvore seguinte
do dataframe. Finalmente a terceira linha do bloco de código atualiza a variável rótulo para
corresponder à nova árvore.
Como o R chegou ao final do bloco de código, ele volta a testar a condição. Se a condição continuar
verdadeira, o R permanece no looping. Caso contrário, o R sai do looping e termina o código.

Vale destacar que esta solução não é facilmente aplicada às árvores rotuladas como grande.
Você consegue perceber porque?

Aqui vale um alerta. O looping while não é muito simples de se construir e um erro pode facilmente
levar a um looping perpétuo. Isto é, a condição é sempre verdadeira e portanto, o looping while nunca
irá terminar. Esta é a razão de se preferir o looping for.
 Looping FOR
Estrutura de repetição for é uma estrutura de desvio do fluxo presente em linguagens de programação
que repete um determinado algoritmo para os elementos de um conjunto determinado pela condição.

Fluxograma do looping FOR

Estão associados à estrutura de repetição for uma condição e um bloco de código. Mas ao contrário
do looping while, a condição aqui serve para definir os elementos de um conjunto sobre os quais o
bloco de código será executado.
Após o final da execução do bloco, se ainda houver elementos no conjunto o bloco de código é
executado novamente. O objetivo do looping for é repetir uma determinada tarefa até que todos os
elementos definidos pela condição tenham sido processados.
O looping for é construído a partir da sentença genérica:

1 for (condição) {
2 Bloco de código
3 }

Vamos criar um looping for a partir da mesma base de dados que estamos utilizando nos últimos
capítulos:

1 arvores <- data.frame(altura =

2 c(15,18,22,24,25,30,31,34,37,39,41,45),
3 dap = c(2,4.5,6,10,30,34,50,56,60,77.5,80,85),
4 categoria = rep(c("pequena", "grande"), each=6))

Nosso objetivo será calcular o volume das árvores grandes. Para isto, vamos filtrar no dataframe as
linhas rotuladas como grande. Sobre cada linha filtrada, iremos realizar o cálculo do volume. Vamos
construir o script utilizando o looping for?

61
 Looping FOR 62

1 arv.filtrada = arvores[arvores$categoria == "grande", ]

2
3 for (i in seq(1, length(arv.filtrada$categoria), 1)) {
4 arv.filtrada$volume[i] = arv.filtrada$altura[i] * (arv.filtrada$dap[i]/100) / 1\
5 .5
6 }

O resultado do código acima é uma nova coluna no dataframe arv.filtrada, contendo o volume de
cada árvore rotulada como grande.

Saida resultado do looping FOR

Vamos discutir o que acabamos de fazer? Nosso script começa com:

1 arv.filtrada = arvores[arvores$categoria == "grande", ]

Esta linha de comando filtra as observações do dataframe original arvores que contem a string
grande nas linhas da coluna categoria. Estas observações são então salvas num novo dataframe
chamado arv.filtrada.
Veja a segunda linha:

1 for (i in seq(1, length(arv.filtrada$categoria), 1)) {

Vamos analisar a segunda linha de forma bem cuidadosa. Com a palavra for, informamos ao R que
um looping irá começar. Perceba que nosso dataframe arv.filtrada, possui 6 linhas. Esta informação
vem de: length(arv.filtrada$categoria).
Assim, o pedaço de código seq(1, length(arv.filtrada$categoria), 1) define um vetor sequêncial de
um 1 até 6, com incrementos de 1.
A segunda linha pede portanto, que execute um bloco de código com i variando de 1 a 6, ou seja, o
bloco de código irá ocorrer sobre cada uma das linhas do dataframe arv.filtrada.
O bloco de código é bastante simples. Ele pega a altura da árvore armazenada na linha i, múltipla
pelo respectiva área seccional em metros quadrados e aplica um fator de forma de 1.5. O resultado
é então armazenado na mesma linha i, só que em uma nova coluna chamada volume.

Você seria capaz de adaptar o código para calcular o volume das árvores pequenas?
 Família APPLY
No R, por usar uma linguagem vetorial, os loopings tradicionais, quando possível, devem ser
substituídos pelas funções da família apply.
Além da função apply() propriamente dita, estão disponíveis as funções: sapply(), tapply() e lapply()
para implementar cálculos de forma mais eficiente.
Na base de dados que estamos trabalhando nos últimos capítulos temos duas colunas interessantes,
a altura e o dap (diâmetro a altura do peito). Desejamos calcular a média dessas colunas. Assim,
usaremos a função apply para aplicar função mean() (função para o calculo da média) sobre as
colunas do dataframe:

1 apply(arvores[,1:2], 2, mean)

A função apply() pede três elementos. O primeiro termo: arvores[, 1:2] indica que estaremos
utilizando as colunas 1 e 2 do dataframe, que corresponde às colunas altura e dap respectivamente.
O segundo termo: 2 indica que desejamos aplicar a função sobre as colunas. Se utilizarmos o valor
1, a função seria aplicada sobre as linhas do dataframe.
O terceiro termo, mean(), indica que a função a ser aplicada em cada coluna é a média.
Prontamente o R é capaz de calcular a média das colunas altura e dap, apresentando o resultado no
console:

1 apply(arvores[,1:2], 2, mean)
2 altura dap
3 30.08333 41.25000

Lembre-se que sempre podemos salvar os resultados de uma função em uma variável.

1 medias = apply(arvores[,1:2], 2, mean)

O resultado desta linha é uma variável denominada medias contendo as médias das colunas altura
e dap.
As funções da família apply, em resumo, executam um looping sobre as linhas ou sobre as colunas.
As funções sapply() e lapply() são variantes.
A sapply() executa uma determinada função sobre um vetor de elementos.

63
 Família APPLY 64

1 sapply(1:3, sqrt)
2 [1] 1.000000 1.414214 1.732051

A lapply() realiza operação similar ao sapply() só que a saída é estruturada como lista:

1 lapply(1:3, sqrt)
2 [[1]]
3 [1] 1
4
5 [[2]]
6 [1] 1.414214
7
8 [[3]]
9 [1] 1.732051

Sempre que possível, utilize as funções da família apply. Elas são otimizadas para o R, o que a tornam
bem mais eficientes que a estrutura convencional for e while.
 Funções
Criar uma função significa encapsular um pedaço de código e atribuir um nome para que este pedaço
de código possa ser reutilizado a qualquer momento.
Uma função pode contar com parâmetros que modificam sua forma de atuação de acordo com o valor
que ele assume. As funções uma vez criadas podem ser requisitadas pelo programador a qualquer
momento dentro do código, ou até mesmo dentro de outra função.
Os pacotes nada mais são que uma série de funções que após instalados e ativados passam a fazer
parte do seu ambiente de trabalho.
Para calcular uma raiz quadrada, por exemplo, utilizamos uma função denominada de sqrt(). Esta
função possui um bloco de código que será chamado toda vez que digitarmos sqrt().

1 sqrt(9)
2 [1] 3

A função sqrt() exige um parâmetro obrigatório, denominado x, que deve ser sempre um vetor
numérico. A função com seus parâmetros chamamos de sintaxe. Assim, a sintaxe completa dda
função sqrt() é sqrt(x).
Ao longo do livro, aprendemos a utilizar uma série de funções. Algumas já prontamente disponível
no R e outras adicionadas via pacotes. Também é possível criar uma função.
Vamos criar uma função que calcule o diâmetro (em centímetro) de uma árvore a partir de uma
idade conhecida (em anos).
A melhor forma para se criar uma função é digitar sua estrutura num script e processá-lo para
deixar a função disponível no ambiente de trabalho. Vejamos o script da nossa função para calcular
o diâmetro:

1 estimarDiametro <- function(x, a , b, c) {

2 return((a*(1-exp(-b*x))^c))
3 }

Nossa função se chamará estimarDiametro() e terá quatro parâmetros, todos obrigatórios: o número
ou vetor numérico x e os parâmetros da função sigmoidal de Richard a, b e c. Dentro dos {} temos
o bloco de código que será aplicado toda vez que chamarmos a função estimarDiametro(). No caso,
o bloco de código será a função de Richard com parâmetros a, b e c, aplicado a uma variável
independente x.

65
 Funções 66

Depois de rodar o script acima, nossa função passa a fazer parte do espaço de trabalho (veja no canto
superior direito, na janela environment).
Uma vez no espaço de trabalho, nossa função está disponível para ser chamada no console ou em
novos scripts. Vamos fazer o teste? Calcule o diâmetro de uma árvore aos 10 anos de idade, e cujos
parâmetros do modelo de Richard são: a = 15.18, b = 0.33 e c = 0.98.

1 estimarDiametro(10, 15.18, 0.33, 0.98)

2 [1] 14.63111

Isto mesmo, nossa árvore possui 14.63111 centímetros de diâmetro.

Agora um desafio. Crie uma função chamada volume para calcular o volume de uma árvore
a partir do diâmetro, altura e fator de forma. Observação, o diâmetro será informado em
centímetros e a altura em metros.

Sua função deve ter três parâmetros obrigatórios e deve ter sido construída assim:

1 volume = function(dap, altura, fator){

2 return((((dap^2) * pi / 40000) * altura) / fator)
3 }

Rode o script para criar a função volume em seu ambiente de trabalho. Confira se implementou
corretamente a função, calculando o volume de uma árvore com 50 cm de diâmetro, 42 metros de
altura e um fator de forma 1.5. Seu resultado deve ser igual a 5.497787 m³.

Suponha que você não tem o diâmetro da árvore, mas sabe que a árvore possui 6 anos e
22 metros de altura. Você também sabe que os coeficientes do modelo de Richard para o
crescimento do diâmetro desta espécie são: a = 15.18, b = 0.33 e c = 0.98. Como você poderia
utilizar as duas funções criadas aqui neste capítulo?

Veja uma sugestão:

1 volume(est_diametro(6, 15.18, 0.33, 0.98), 22, 1.5)

2 [1] 0.1983767

Aqui aplicamos uma função dentro da outra. E a resposta foi 0.1984 m³!
Próximos passos
Ao longo deste livro você aprendeu uma série de comandos que irão ajudá-lo a utilizar o R no
dia a dia de suas análises. Esse livro não é uma receita. Ele tem a pretensão de ajudar você a se
tornar independente no uso do R. Isto não significa que você não precisa mais procurar ajuda,
ou conversar com um colega programador mais experiente. A independência significa que você
consegue se expressar e pensar na nova língua que você acabou de aprender: a linguagem R. Espero
que você seja capaz de decidir por exemplo, quando utilizar um looping; a diferenciar entre situações
de looping while e looping for; a detectar quando uma importação de csv deu errado e no que você
errou ao importar os dados, e por aí vai…
Quando você começar a trabalhar com o R, muitas dificuldades irão surgir. A primeira análise que
você for implantar no R, você irá demorar um dia todo! Mas não se assuste. A demora vem da falta de
fluência. Na segunda vez que você implantar uma análise no R, já notará uma sensível melhora no
seu desempenho. E assim sucessivamente até que se sinta absolutamente seguro no desenvolvimento
de códigos para o R.
Quando você esbarrar numa dificuldade, não se desespere nem desanime. Você tem duas saídas:
pergunte a um amigo que já usa o R, ou pergunte ao Google. Isto mesmo! Digite sua dúvida no
portal de pesquisas na internet. Por exemplo:
Como salvar um dataframe no r?
Como remover uma coluna do dataframe no r?
Depois de algumas perguntas, você verá que grande parte das respostas sempre vem dos mesmos
sites… vou deixar uma lista de sites especialmente interessantes, ok?

• http://stackoverflow.com/
• http://pt.stackoverflow.com/
• http://www.statmethods.net
• http://ridiculas.wordpress.com

Também tenho disponível um curso online do R, totalmente gratuito:

• http://udemy.com/computacao_r/

Espero que você se torne um entusiasta do R, assim como eu! Não desanime com as dificuldades
iniciais e se lembre que o limite a partir de agora é você!

67
Agradecimentos
Agradeço ao amigo Professor Márcio Romarco de Oliveira pelo primeiro convite para que eu
ministrasse um curso sobre o R.
Agradeço à amiga Danitiele Cristina França Laranja pela paciência em testar os comandos e
exemplos apresentados ao longo do livro.
Agradeço ao amigo André Gracioso Peres da Silva pela parceria de sucesso nas construções de
inúmeras soluções baseadas em R.
Agradeço ao amigo e orientador Luiz Carlos Estraviz Rodriguez pelo convite para fazer doutorado,
que resultou no tempo e ambiente necessário para novos aprendizados.
Um agradecimento especial para Jacy (minha mãe) e para Roberto (meu sogro) por lerem e testarem
a compreensão do livro.
Agradeço à minha família pelo apoio: Jacy, Robert, Diana, Ellie, Roberto e Tânia.
Agradeço ao meu anjo: Pollyanna.

68