JOZEMAR PEREIRA DOS SANTOS DE/CCEN/UFPB

Novembro/2006

2

Índices 1 Preâmbulo 3 2 Alguns conceitos antes de começar 4

2.1 Como R trabalha 5 2.2 Criando, listando e deletando os objetos na memória 7 2.3 A ajuda on-line 10

3 Dados com R 13

3.1 Objetos 13 3.2 Lendo dados num arquivo 16 3.3 Salvando dados 20 3.4 Gerando dados 21

3.4.1 Seqüências regulares 21 3.4.2 Seqüências aleatórias 24

3.5 Manipulando objetos 25 3.5.1 Criando objetos 26 3.5.2 Convertendo-se objetos 34 3.5.3 Operadores 35 3.5.4 Acessando os valores de um objeto: o sistema de indexação 36 3.5.5 Acessando os valores de um objeto com nomes 38 3.5.6 O editor de dados 38 3.5.7 Aritméticas e funções simples 39 3.5.8 Escrevendo funções do R 40 3.5.9 Computações de matrizes 41

4 Gráficos com R 44

4.1 Manipulando gráficos 44 4.1.1 Abrindo diversos dispositivos gráficos 47 4.1.2 Particionando um gráfico 48

4.2 Funções gráficas 49 4.3 Comandos de plots de baixo nível 51 4.4 Parâmetros gráficos 53 4.5 Um exemplo prático 54 4.6 Os pacotes grid e lattice 58 4.7 Exemplo de modelos lineares com R 61

5 Referências 65

3

1. Preâmbulo

Esta introdução ao pacote de software estatístico livremente disponível R é pretendida

preliminarmente para pessoas já familiares com os conceitos estatísticos comuns. Assim os

métodos estatísticos usados para ilustrar o pacote não são explicados em detalhe. Estas notas

não são significam ser um manual de referência, mas um manuseio de introdução para os

estatísticos que não são familiares com o R. A intenção é oferecer apenas bastante material de

início, motivando novatos ilustrando o poder e a flexibilidade do R, e mostrar como

simplesmente permite o usuário de realizar computações estatísticas sofisticadas e de produzir

as exposições gráficas de alta qualidade. R tem muitas funções para análises estatísticas e

gráficos; os últimos são visualizados imediatamente em sua própria janela e podem ser salvos

em vários formatos (jpg, png, bmp, ps, pdf, emf, pictex, xfig; os formatos disponíveis podem

depender do sistema operacional). Os resultados de uma análise estatística são indicados na tela,

alguns resultados intermediários resultam (P-valores, coeficientes da regressão, resíduos,... )

pode ser salvo, escrito em um arquivo, ou ser usado em análises subseqüentes. As notas

compreendem a construção de quatro seções, que devem ser lidas sequencialmente. A primeira

seção (uma introdução ao R) introduz a maioria de conceitos básicos. Ocasionalmente os

estudos são simplificados e restringidos ao mínimo evitando obscurecer as idéias principais

oferecendo detalhe em demasia. A segunda e terceira seção (Modelos lineares e Análise de

séries temporais) ilustra alguns comandos padrão de R que são comuns a estes dois tópicos

estatísticos. A quarta seção (Gráficos avançados) cobre algumas das potencialidades gráficas

excelentes do pacote. Durante todo texto a fonte courier new é usada para anotar funções de

R e opções. As funções de R são dadas com suportes, por exemplo plot() onde as opções são

escritas na fonte courier new e itálico, por exemplo xlab="label de x". Comandos de R

que são entrados pelo usuário são impressos em vermelho e a saída de R é impressa em azul. As

séries de dados usadas estão disponíveis no diretório onde se encontra instalado o sistema R.

Uma maneira eficiente (e agradável) de começo para dominar R é usá-lo ativamente,

experimentar com suas funções e opções e escrever suas próprias funções. Não é necessário

estudar manuais longos a fim iniciar os estudos; pode começar com um trabalho útil feito quase

imediatamente. Assim, o objetivo principal desta introdução é motivar o leitor para explorar

ativamente o R. Boa sorte!

4

2. Antes de iniciar o R

2.1 Downloading e instalando R

R é um ambiente extensamente usado para a análise estatística. A diferença impressionante

entre R e a maioria outros de pacotes estatísticos é que é software livre e que está mantido por

cientistas para cientistas. Desde sua introdução em 1996 por R. Ihaka e R. Gentleman, o projeto-

R ganhou muitos usuários e contribuintes que estendem continuamente as potencialidades de R

liberando add-ons (pacotes) novas funções e métodos dessa oferta, ou melhora existentes. Uma

desvantagem ou vantagem, dependendo do ponto da vista, é que R é usado com uma interface

de linha de comando, que impõe uma curva de aprendizagem ligeiramente mais íngreme do que

outros softwares. Mas, uma vez que este obstáculo tenha sido superado, R oferece

possibilidades quase ilimitadas para a análise de dados estatísticos.

R é distribuído por “Compreensive R Archive Network” (CRAN) - ele está disponível do

URL: http://cran.r-project.org. A versão atual de R (2.4.0 até à data de Outubro de 2006, aprox.

28 MB) para Windows pode ser feito o downloaded selecionando “R binaries” → “windows”

→ “base” e downloading (baixando ou salvando) o arquivo “rw2.4.0.exe” do web-site CRAN.

O software R pode ser instalado pela execução do arquivo salvo. O procedimento de instalação

é direto; geralmente se tem só que especificar o nome do diretório alvo em que o R deve ser

instalado. Após a instalação, R pode ser iniciado como qualquer outra aplicação para Windows,

dando um duplo-clique no ícone correspondente.

2.2 Alguns conceitos antes de começar

Uma vez que R é instalado em seu computador, o software é acessado carregando o

correspondente arquivo executável. O prompt ou “alerta”, por padrão ‘>', indica que R está

aguardando seus comandos. Sob Windows, alguns comandos (acessando o ajuda on-line,

abrindo arquivos,... ) pode ser executado através dos menus pull-down. Neste estágio, um

usuário novo é provável querer saber “o que devo fazer agora?” É certamente muito útil ter

algumas idéias de como R trabalha quando é usado para a primeira vez, e isto é o que veremos

agora. Nós devemos primeiramente ver resumidamente como R trabalha. Então, eu descreverei

o operador “atributo” que permite criar objetos, como basicamente gerenciar objetos na

5

memória, e finalmente como usar a ajuda on-line que, pelo contraste a muitos softwares, é muito

útil em um uso atual.

2.3 Como R trabalha

Figura 1. Uma visão esquemática de como o R trabalha.

R é uma linguagem orientada-a-objetos: isto é completamente um palavreado complexo que

oculta a simplicidade e a flexibilidade do R. O fato de que R é uma linguagem pode deter alguns

usuários pensando “eu não posso programar”. Este não deve ser o argumento por duas razões.

Primeiro, R é uma linguagem interpretada, não compilada, significando que todos os comandos

escritos no teclado são executados diretamente sem requerer a construção de um programa

completo comum à maioria de linguagens de computador (C, Fortran, Pascal,... ).

Segundo, a sintaxe do R é muito simples e intuitiva. Por exemplo, uma regressão linear

pode ser feita com o comando lm (y ˜ x). Em R, na ordem para ser executado, uma função

sempre necessita ser escrita com parênteses, mesmo se não houver nada dentro deles (por

exemplo, ls()). Se o nome de uma função for escrito sem parênteses, R deve indicar os

conteúdos da função. Neste texto, os nomes das funções estão escritos geralmente com

parênteses a fim distingui-los de outros objetos, a menos que o texto indicar claramente assim.

Orientado-a-objetos significa que as variáveis, dados, funções, resultados, etc., são

armazenados na memória ativa do computador na forma de objetos que têm um nome. O

usuário pode fazer ações nestes objetos com operadores (aritmético, lógico, e comparação) e

funções (que são eles mesmos objetos). O uso dos operadores é relativamente intuitivo, nós

veremos detalhes mais adiante. Uma função de R pode ser esboçada como segue:

6

Os argumentos podem ser objetos (“dados”, fórmulas, expressões.), alguns dos quais

poderia ser definido por padrão (by default) na função; estes valores padrão podem ser

modificados pelo usuário com as opções. Uma função de R pode não requerer nenhum

argumento: ou todos os argumentos são definidos padrão (e pelos seus valores pode ser

modificado com as opções), ou nenhum argumento foi definido na função. Veremos mais tarde

em mais detalhes como usar e construir as funções. A descrição atual é suficiente para que o

momento compreenda como R trabalha. Todas as ações de R são feitas nos objetos armazenados

na memória ativa do computador: arquivo temporário não é usado (Figura 1). As leituras e

escritas dos arquivos são usadas para a entrada e a saída dos dados e dos resultados (gráficos).

O usuário executa as funções através de alguns comandos. Os resultados são indicados

diretamente na tela, armazenados em um objeto, ou escritos no disco (particularmente para

gráficos). Desde que os resultados são eles mesmos objetos, podem ser considerados como

dados e ser analisados como tais. Os arquivos de dados podem ser lidos no disco local ou em

um servidor remoto através da internet.

As funções disponíveis ao usuário são armazenadas em uma biblioteca localizada no disco

em um diretório chamado R_HOME/library (R_HOME é o diretório onde R é instalado). Este

diretório contém pacotes das funções, que elas mesmas são estruturadas nos diretórios. O pacote

nomeado base é de alguma maneira o núcleo de R e contem as funções básicas da linguagem

para a leitura e manipulação de dados, algumas funções gráficas, e algumas funções estatísticas

(regressão linear e análise de variância). Cada pacote tem um diretório chamado R com um

arquivo nomeado como o pacote (por exemplo, para o pacote base, este é arquivo

R_HOME/library/base/R/base). Este arquivo está no formato ASCII e contém todas as funções

do pacote. O comando mais simples é escrever o nome de um objeto para indicar seu conteúdo.

Por exemplo, se um objeto n contém o valor 10:

> n

[1] 10

7

O dígito 1 dentro dos colchetes indica que a exposição começa pelo primeiro elemento de

n. Este comando é um uso implícito da função print e o exemplo acima é similar imprimir (n)

(em algumas situações, a função print deve ser usado explicitamente, como dentro de uma

função ou um loop).

2.4 Criando, listando e suprimindo os objetos na memória.

Desde que R é uma linguagem baseada em linhas de comando, todos os comandos são

incorporados diretamente no console. Um ponto inicial é usar R como um substituto para uma

calculadora de bolso. Escrevendo no “prompt” do console

> 2 + 3 # Soma (adiciona 3 a 2 e indica o resultado)

[1] 5

Outros operadores simples incluem

> 2–3 #Subtração

> 2*3 #Multiplicação

> 2/3 #Divisão

> sqrt(3) #Raiz quadrada

> log(3) #Logaritmo (na base e)

Os operadores podem também ser aninhados, por exemplo.

> (2-3)*3 # subtrai primeiramente 3 de 2 e multiplica então o resultado com 3

[1] -3

Frequentemente pode ser útil armazenar resultados das operações para um uso mais

adiante. Isto pode ser feito usando de o operador “atribuição” que é escrito como uma seta com

um sinal menos ( <- ); este símbolo pode ser orientado da direita-para-esquerda e vice-versa,

por exemplo: <<<<----

> test <- 2*3

8

executa a operação no lado direito (2*3) e armazena então o resultado como um objeto nomeado

test (podendo também usar = ou para nivelar -> para atribuições.), mais operações adicionais

podem ser realizadas em objetos, por exemplo.

> 2*test

multiplica o valor armazenado em test com 2. Note que os objetos sobrescrevem sem

observação. O comando de saída ls() a lista de objetos atualmente definidos. ls ( )

> n <- 15 # atribui o valor 15 ao objeto n

> n

[1] 15

> 5 -> n # atribui ao objeto n o valor 5

> n

[1] 5

> x <- 1 # atribui o valor 1 ao objeto x

> X <- 10 # atribui o valor 10 ao objeto X

> x # lê o valor de x

[1] 1

> X # lê o valor de X

[1] 10

Se o objeto já existe, seu valor prévio é apagado (as modificações afetam somente os

objetos na memória ativa, não os dados no disco). O valor atribuído desta maneira pode ser o

resultado de uma operação e/ou uma função:

> n <- 10 + 2

> n

[1] 12

> n <- 3 + rnormn(1)

> n

[1] 2.208807

9

A função rnorm(1) gera o valor de uma variável aleatória normal com média zero e

variância unitária. Note que você pode simplesmente escrever uma expressão sem associar este

valor para um objeto, o resultado é assim mostrado na tela e não é armazenado na memória.

> (10 + 2) * 5

[1] 60

A atribuição deve ser omitida no exemplo se não necessária para entendimento.

A função ls() lista simplesmente os objetos na memória: somente os nomes dos objetos

são mostrados. O comando fornece a lista de objetos atualmente definidos. ls ( )

> name <- “Carmen”; n1 <- 10; n2 <- 100; m <- 0.5

> ls()

[1] “m” “n1” “n2” “name”

Note o uso do ponto e vírgula para separar comandos distintos na mesma linha. Se nós

desejarmos listar somente os objetos que contém um dado caractere no seu nome, a opção

pattern (que pode ser abreviado com pat) pode ser usada:

> ls(pat = “m”)

[1] “m” “name”

Para restringir a lista de objetos cujos nomes começam com esse caractere:

> ls(pat = “^m”)

[1] “m”

A função ls.tr() mostra alguns detalhes sobre os objetos na memória:

> ls.str()

m : num 0.5

n1 : mum 10

n2 : num 100

name : chr “Carmen”

10

A opção pattern pode ser usada da mesma maneira como ls(). Outra opção usual de

ls.str() é max.level que especifica o nível de detalhe a mostra de composição dos

objetos. Por default (isto é, padrão), ls.str()mostra os detalhes de todos os objetos na

memória, incluindo as colunas de data-frames, matrizes e listas, que pode resultar em uma longa

mostra. Nós podemos omitir a visualização de todos esses detalhes com a opção max.level

= - 1.

> M <- data.frame(n1, n2, m)

> ls.str(pat = "M")

M : ‘data.frame’: 1 obs. of 3 variables:

$ n1: num 10

$ n2: num 100

$ m : num 0.5

> ls.str(pat = "M", max.level=-1)

M : ‘data.frame’: 1 obs. of 3 variables:

Para suprimir objetos na memória, usamos a função rm(): rm(x)deleta o objeto x,

rm(x,y) deleta ambos os objetos x e y, rm(list=ls()) deleta todos os objetos na

memória; a mesma opção mencionada para a função ls()pode ser usada para suprimir

seletivamente alguns objetos: rm(list=ls(pat=“^m”))

Cartão de Referência: Para operar o R é necessário conhecer e digitar comandos. Isto pode trazer alguma dificuldade

no inicio até que o usuário se familiarize com os comandos mais comuns. Uma boa forma de

aprender e memorizar os comandos básicos é utilizar o Cartão de Referência que contém os

comandos mais frequentemente utilizados.

2.5. A Ajuda on-line

A ajuda on-line de R dá informação muito útil de como usar as funções. A ajuda está disponível

diretamente para uma função dada, por exemplo:

>? lm

11

indicará, dentro de R, a ajuda para a função lm() (modelo linear). O comando ajuda (lm) ou a

ajuda (“lm”) tem o mesmo efeito. Esta última função deve ser usada para acessar a ajuda com

caracteres não-convencionais:

> ?*

Error: syntax error

> help (“*”)

Arithmetic package: base R Documentation

Arithmetics Operators

. . .

A chamada de ajuda abre uma página (esta depende do sistema operacional) com

informação geral na primeira linha tal como o nome do pacote onde estão as funções ou os

operadores documentados. Vem então um título seguido pelas seções que trazem a informação

exata.

Description: descrição breve.

Usage: para uma função, dá o nome com todos seus argumentos e os valores de defeito

possíveis (opções); para um operador dá o uso típico.

Arguments: para uma função, detalhes cada um de seus argumentos.

Details: descrição detalhada.

Value: se aplicável, o tipo de objeto retornou pela função ou pelo operador.

See also: outras páginas da ajuda fecham-se ou similar à atual.

Examples: alguns exemplos que podem geralmente ser executados sem abrir a ajuda com

a função examples().

Para novatos, é bom olhar para a seção Examples:. Geralmente, é útil ler com cuidado a

seção Arguments:. Outras seções podem ser encontradas, como Nota:, References ou

Authors:.

Por padrão, a função help somente pesquisa nos pacotes que são carregados na memória.

A opção try.all.packages, cujo padrão é FALSE (falso), permite procurar em todos os

pacotes se seu valor é TRUE (verdade):

> help("bs")

12

Error in help("bs") : No documentation for ‘bs’ in specified packages and libraries:

you could try ‘help.search("bs")’

> help("bs", try.all.packages=TRUE)

topic ‘bs’ is not in any loaded package but can be found in package ‘splines’ in library ‘D:/rw1041/library’

A ajuda no formato do HTML (lido, por exemplo, com Netscape) é chamada escrevendo:

> help.start()

Uma pesquisa com palavras-chaves é possível com esta ajuda em HTML. A seção See

Also: tem aqui links de hypertext a outras páginas da função help. A busca com palavras-

chaves é também possível com a função help.search.

A função apropos encontra todas as funções que o nome contendo cadeia de caracteres

dados como argumento; somente os pacotes carregados na memória são procurados:

> apropos(help)

[1] "help" "help.search" "help.start"

[4] "link.html.help"

13

3. Dados com R

3.1 Objetos

Nós vimos que R trabalha com objetos que, naturalmente, são caracterizados por seus nomes e

por seu conteúdo, mas também pelos atributos que especificam o tipo dos dados representados

por um objeto. A fim de compreender a utilidade destes atributos, considere uma variável que

tome os valores 1, 2, ou 3: tal variável poderia ser uma variável inteira (por exemplo, o número

dos ovos em um ninho), ou o código de uma variável categórica (por exemplo, sexo em algumas

populações dos crustáceos: macho, fêmea, ou hermafrodita).

É claro que a análise estatística desta variável não será a mesma em ambos os casos: com

R, os atributos do objeto dão a informação necessária. Mais tecnicamente, e mais geralmente, a

ação de uma função em um objeto depende dos atributos do último.

Tipos de dados: Como em outras linguagens de programação, existem diferentes tipos de dados

disponíveis em R, a saber, “numeric”, “character”, “complex” e “logical”. Como o nome indica,

“numeric” é usado para valores numéricos (precisão dupla). O tipo “character” é usado para

caracteres e geralmente incorporado usando a citação entre-aspas:

> myname <- "what"

> myname

Assim sendo, não é possível (nem significativo) aplicar operadores aritméticos em tipos de

dados caracteres. O tipo de dados “logical” é usado para variáveis booleanas: (TRUE ou T, e

FALSE ou F). O tipo de dados “complex” é usado no estudo de variáveis complexas (estudo

mais avançado, e aqui não abordado).

Tipos do objeto: Dependendo da estrutura dos dados, R reconhece 4 tipos padrão de objeto:

“vetores”, “matrizes”, os “data-frames” e “listas”. Os vetores são arranjos unidimensionais dos

dados; as matrizes são disposições bidimensionais dos dados. Os data-frames e as listas de

dados são umas generalizações mais adicionais e serão cobertas em uma seção posterior.

14

O nome de um objeto deve começar com uma letra (A-Z e a-z) e pode incluir letras, dígitos (0-

9), e pontos (.). R discrimina para os nomes dos objetos as letras maiúsculas das minúsculas, de

modo que x e X possam nomear dois objetos distintos (mesmo sob Windows).

Todos os objetos têm dois atributos intrínsecos: modo e comprimento. O modo é o tipo

básico dos elementos do objeto; há quatro modos principais: numeric, character, complex, e

logical (FALSE ou TRUE). Outros modos existem mais não representam dados, por exemplo,

uma função ou expressão. O comprimento é o número dos elementos do objeto. Para indicar

o modo e o comprimento de um objeto, podemos usar as funções mode e length,

respectivamente:

> x <- 1

> mode(x)

[1] "numeric"

> length(x)

[1] 1

> A <- "Gomphotherium"; compar <- TRUE; z <- 1i

> mode(A); mode(compar); mode(z)

[1] "character"

[1] "logical"

[1] "complex"

Qualquer que seja o modo, dados faltantes (missing data) são representados pelo NA (não

disponível). Um valor numérico muito grande pode ser especificado com uma notação

exponencial:

> N <- 2.1e23

> N

[1] 2.1e+23

R representa corretamente valores numéricos não-finitos, tais como ± ∝ com Inf e

- Inf, ou valores quais não são números com NaN (não um número).

> x <- 5/0

> x

[1] Inf

> exp(x)

15

[1] Inf

> exp(-x)

[1] 0

> x - x

[1] NaN

Um valor no modo character é entrado dupla-aspas “ ”. É possível incluir este último

caractere no valor se seguir uma barra \ . Os dois caracteres juntos \” devem especificar o

caminho para algumas funções como cat que mostrar na tela, ou write.table para

escrever no disco (p. 19, a opção qmethod desta função).

> cit <- "Eu disse: \"Dupla-aspas pode ser incluído em cadeias de caracteres no R.\""

> cit

[1] "Eu disse: \"Dupla-aspas pode ser incluído em cadeias de caracteres no R.\""

> cat(cit)

Eu disse: "Dupla-aspas pode ser incluído em cadeias de caracteres no R.""

A tabela 1, a seguir, dá uma vista geral do tipo de objetos representando dados.

16

Tabela 1 – Tipos de objetos representando dados

Objeto Modos Diversos modos possíveis

em um mesmo objeto?

vetor numérico, carácter, complexo ou lógico Não factor numérico ou carácter Não array numérico, carácter, complexo ou lógico Não matrix numérico, carácter, complexo ou lógico Não data.frame numérico, carácter, complexo ou lógico Sim ts numérico, carácter, complexo ou lógico Sim list numérico, carácter, complexo ou lógico Sim

Um vetor é uma variável no significado geralmente admitido. Um fator é uma variável

categórica. Um array é uma tabela com k-dimensões, uma matriz é um caso particular do array

com k=2. Note que os elementos de um array ou de uma matriz são todos de mesmo modo. Um

data-frame é uma tabela composta com uns ou diversos vetores e/ou fatores todos de mesmo

comprimento, mas possivelmente de modalidades diferentes. As ts são conjunto de dados de

séries temporais e contêm atributos suplementares tais como freqüências e datas. Finalmente,

uma lista pode conter qualquer tipo de objeto, incluindo listas!

Para um vetor, seu modo e comprimento são suficientes para descrever os dados. Para

outros objetos, outras informações são necessárias e eles são dados por atributos não-

intrínsecos. Entre estes atributos, nós podemos citar dim que corresponde às dimensões de um

objeto. Por exemplo, uma matriz com 2 linhas e 2 colunas tem para dimensão(dim) o par

dos valores [2, 2], mas seu comprimento é 4.

3.2 Lendo dados em um arquivo

Para ler e escrever em arquivos, R usa o diretório de trabalho. Para saber o que é este diretório,

o comando getwd () (iniciar diretório de trabalho) pode ser usado, e ele pode ser mudado com,

por exemplo, o setwd (“C:/data”) ou setwd (”/home/paradis/R"). É necessário dar o caminho

para um arquivo se não estiver no diretório de trabalho.

17

R pode ler dados armazenados em arquivo de texto (ASCII) com as seguintes funções:

read.table (que tem diversas variantes, ver abaixo), scan e read.fwf. R pode também

ler arquivos em outros formatos (Excel, SAS, SPSS.), e acessar database do tipo-SQL, mas as

funções necessitadas para isto não estão no pacote base (leitura de dados avançada no R, com

o uso do comando de função Rcmdr). Estas funcionalidades são muito úteis para um uso mais

avançado de R, mas nós restringiremos aqui à leitura dos arquivos no formato do ASCII.

A função read.table tem por efeito criar um data-frame, é assim a maneira principal

para ler aos dados no formulário tabular. Por exemplo, se tiver um arquivo nomeado

dados.dat, o comando:

> mydata <- read.table("dados.dat")

criará um data-frame chamado mydata, e cada uma variável será nomeada, por padrão ou

default, V1, V2,... e pode ser acessado individualmente por mydata$V1, mydata$V2,...,

ou pelo mydata[“V1”], mydata[“V2”],... , ou, ainda uma outra solução, pelo

mydata[,1], mydata[, 2],... Existem diversas opções que os valores padrão (isto é,

aqueles usados por R se forem omitidos pelo usuário) são detalhados no quadro 1:

read.table(file, header = FALSE, sep = "", quote = "\"’", dec = ".",

row.names, col.names, as.is = FALSE, na.strings = "NA",

colClasses = NA, nrows = -1,

skip = 0, check.names = TRUE, fill = !blank.lines.skip,

strip.white = FALSE, blank.lines.skip = TRUE,

comment.char = "#")

Quadro 1 – Argumentos e as opções do comando read.table

18

As variantes de read.table são úteis desde que têm valores de defeito diferentes:

read.csv(file, header = TRUE, sep = ",", quote="\"", dec=".",

fill = TRUE, ...)

read.csv2(file, header = TRUE, sep = ";", quote="\"", dec=",",

fill = TRUE, ...)

read.delim(file, header = TRUE, sep = "\t", quote="\"", dec=".",

fill = TRUE, ...)

read.delim2(file, header = TRUE, sep = "\t", quote="\"", dec=",",

fill = TRUE, ...)

A função scan é mais flexível do que read.table. Uma diferença é que é possível

especificar o modo das variáveis, por exemplo:

> mydata <- scan("data.dat", what = list("", 0, 0))

lê no arquivo três variáveis, a primeira de modo character e os duas seguintes são de modo

numeric. Uma outra distinção importante é que scan() pode ser usada para criar objetos

diferentes, vetores, matrizes, data-frames, listas. mydata é uma lista de três vetores. Por

padrão, isto é se what está omitido, scan() cria um vetor numérico. Se os dados lidos não

19

corresponderem aos modos esperados (por padrão, ou especificado what), uma mensagem de

erro retornará. As opções são as seguintes,

scan(file = "", what = double(0), nmax = -1, n = -1, sep = "",

quote = if (sep=="\n") "" else "’\"", dec = ".",

skip = 0, nlines = 0, na.strings = "NA",

flush = FALSE, fill = FALSE, strip.white = FALSE, quiet = FALSE,

blank.lines.skip = TRUE, multi.line = TRUE, comment.char = "#")

Quadro 2 – Argumentos e as opções do comando scan()

A função read.fwf pode ser usada para ler num arquivo alguns dados no formato de

tamanho fixo:

read.fwf(file, widths, sep="\t", as.is = FALSE,

skip = 0, row.names, col.names, n = -1)

As opções são as mesmas que para read.table() exceto widths que especifica a

largura dos campos. Por exemplo, se um arquivo nomeado data.txt tiver os dados indicados

como abaixo na direita, vamos ler os dados com o seguinte comando:

20

> mydata <- read.fwf("data.txt", widths=c(1, 4, 3))

> mydata

V1 V2 V3

1 A 1.50 1.2

2 A 1.55 1.3

3 B 1.60 1.4

4 B 1.65 1.5

5 C 1.70 1.6

6 C 1.75 1.7

3.3 Salvando dados

A função write.table escreve em um arquivo um objeto, tipicamente um data-frame mas

isto poderia ser um outro tipo do objeto (vetor, matriz,...). Os argumentos e as opções são:

write.table(x, file = "", append = FALSE, quote = TRUE, sep = " ",

eol = "\n", na = "NA", dec = ".", row.names = TRUE,

col.names = TRUE, qmethod = c("escape", "double"))

Quadro 3 – Argumentos e as opções do comando write.table

Para escrever em uma maneira mais simples um objeto em um arquivo, o comando

write(x, file= " data.txt ") pode ser usado, onde x é o nome do objeto (que pode

ser um vetor, uma matriz, ou um array). Há duas opções: nc (ou ncol) que define o número

de colunas no arquivo (por padrão nc=1 se x for do modo character, nc=5 para os outros

21

modos), e append (um logical) para adicionar os dados sem suprimir aqueles possivelmente já

no arquivo (TRUE) ou suprimi-los se o arquivo já existir (FALSE, por padrão).

Para gravar um grupo dos objetos de qualquer tipo, nós podemos usar o comando save

(x, y, z, file= “xyz.RData”). Para facilitar a transferência dos dados entre

diferentes máquinas, a opção ascii = TRUE pode ser usada. Os dados (que são chamados

agora um espaço de trabalho no jargão do R) podem ser carregados mais tarde na memória com

load (“xyz.RData”). A função save.image() é um atalho para save (list=ls

(all=TRUE), file= ".RData ").

3.4 Gerando dados

3.4.1 Sequências regulares

Uma seqüência regular de inteiros, por exemplo, de 1 a 30, pode ser gerada com:

> x <- 1:30

O vetor resultante x tem 30 elementos. O operador ‘: ’ tem a prioridade nos operadores

aritméticos dentro de uma expressão:

> 1:10-1

[1] 0 1 2 3 4 5 6 7 8 9

> 1:(10-1)

[1] 1 2 3 4 5 6 7 8 9

A função seq() pode gerar seqüências de números reais como segue:

> seq(1, 5, 0.5) seq()

[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0

onde o primeiro número indica o início da seqüência, o segundo o fim, e o terceiro um

incremento usado para gerar a seqüência. Podendo usar também:

> seq(length=9, from=1, to=5)

[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0

Podendo também escrever diretamente os valores usando a função c: c()

> c(1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5)

22

[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0

É também possível, se um quiser incorporar alguns dados no teclado, usar simplesmente a

função scan() com as opções padrão: scan( )

> z <- scan()

1: 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0

10:

Lendo 9 itens

> z

[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0

A função rep() cria um vetor com todos seus elementos idênticos

> rep(1, 20) rep()

[1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

A função sequence cria uma série de seqüências de inteiros cada uma terminando pelos números dados como argumentos: sequence()

> sequence(4:5)

[1] 1 2 3 4 1 2 3 4 5

> sequence(c(10,5))

[1] 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5

Ao função gl (gerar níveis) é muito útil porque gera uma série regular dos fatores. O uso

desta função é o gl(k, n) onde k é o número dos níveis (ou das classes), e n é o número das

replicações em cada nível. Duas opções podem ser usadas: length (comprimento) para

especificar o número dos dados produzidos, e labels (rótulos) para especificar os nomes dos

níveis do fator. Exemplos: gl(k, n)

> gl(3, 4)

[1] 1 1 1 1 2 2 2 2 3 3 3 3

Levels: 1 2 3

> gl(3, 4, length=24)

[1] 1 1 1 1 2 2 2 2 3 3 3 3 1 1 1 1 2 2 2 2 3 3 3 3

23

Levels: 1 2 3

> gl(2, 6, label=c("Male", "Female"))

[1] Male Male Male Male Male Male

[7] Female Female Female Female Female Female

Levels: Male Female

> gl(2, 10)

[1] 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2

Levels: 1 2

> gl(2, 1, length=20)

[1] 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2

Levels: 1 2

> gl(2, 2, length=20)

[1] 1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2

Levels: 1 2

Finalmente, expand.grid()cria um data-frame com todas as combinações de vetores

ou fatores dados como argumentos:

> expand.grid(h=c(60,80), w=c(100, 300), sex=c("Male", "Female"))

h w sex

1 60 100 Male

2 80 100 Male

3 60 300 Male

4 80 300 Male

5 60 100 Female

6 80 100 Female

7 60 300 Female

8 80 300 Female

24

3.4.2 Seqüências aleatórias

Tabela 2. – Funções densidade de probabilidade, geração de nos aleatórios.

R é útil nas estatísticas para gerar dados aleatórios, e pode fazê-lo para um grande número

funções densidade de probabilidade. Estas funções são da forma rfunc (n, p1, p2,…), onde

func indica a lei da probabilidade, n o número de dados gerados, e p1, p2,... são os valores dos

parâmetros da lei. A tabela 2 acima dá os detalhes para cada lei, e os possíveis valores padrão

(se nenhum valor padrão for indicado, isto significa que o parâmetro deve ser especificado pelo

usuário). Todas estas funções podem ser usadas substituindo a letra r com o d, o p ou o q para

iniciar, respectivamente, a densidade da probabilidade (dfunc (x,…)), a densidade da

probabilidade cumulativa (pfunc (x,…)), e o valor do quantil (qfunc (p,…)), com 0 < p < 1.

Os nomes das funções de R para distribuições compreendem duas partes. A primeira parte

(a primeira letra) indica da “o grupo função”, e a segunda parte (o restante do nome da função)

indica a distribuição.

25

O seguinte “grupo de funções” estão disponíveis:

• função de densidade da probabilidade (d)

• função de distribuição cumulativa (p)

• função do quantil (q)

• geração do número aleatório (r)

Distribuições comuns têm suas correspondentes “abreviações”-R:

Distribuição Nome-R Distribuição Nome-R Distribuição Nome-R

Normal norm t t χχχχ2 chisq

Exponencial exp F f Uniforme unif

Log-normal lnorm Beta beta Gama gamma

Logística logis Weibull weibull Cauchy cauchy

Geométrica geom Binomial binom Hipergeométrica hyper

Poisson pois Binomial

negativa

nbinom

Por exemplo os números aleatórios (r) da distribuição normal (norm) podem ser extraídos

usando a função do rnorm(); os quantis (q) da distribuição χ2 (chisq) são obtidos com

qchisq(). Os seguintes exemplos ilustram o uso das funções de R para as computações que

envolvem distribuições estatísticas:

> rnorm(10) #extrai 10 números aleatórios de uma distribuição normal padrão

> rnorm(10,5,2) #extrai 10 números aleatórios de uma distribuição N (µ = 5, σ = 2)

> pnorm(1) #retorna a probabilidade cumulativa de um normal padrão até um

valor de 1

> qnorm(0.975) #retorna o quantil 97.5% da distribuição normal padrão

3.5 Manipulando objetos

26

3.5.1 Criando objetos

Nós vimos maneiras previamente diferentes de criar objetos usando o operador da

atribuição (<-); o modo e o tipo de objetos assim criados são geralmente determinados

implicitamente. É possível criar um objeto e especificar seu modo, comprimento, tipo, etc. Esta

aproximação é interessante na perspectiva de manipular objetos. Pode, por exemplo, criar um

objeto “vazio” e então modificar seus elementos sucessivamente que é mais eficiente do que

colocar todos seus elementos junto com c(). O sistema indexado poderia ser usado aqui, mas

nós veremos mais tarde (p. 22).

Pode também ser muito conveniente criar objetos de outros. Por exemplo, se desejar

ajustar uma série dos modelos, é simples pôr as fórmulas em uma lista, e extrair então

sucessivamente os elementos para introduzi-los na função lm.

Neste estágio da nossa aprendizagem de R, o interesse em aprender as seguintes

funcionalidades é não somente prático mais também didático. A construção explícita de um

objeto dá uma compreensão melhor de sua estrutura, e permite que nós retomemos mais

algumas noções mencionadas previamente.

Vetor. A função vector, que tem dois argumentos modo e comprimento, cria um vetor que

têm como elementos um valor dependendo do modo especificado como argumento: 0 se

numérico, FALSO se lógico ou "" se caractere. As seguintes funções têm exatamente o

mesmo efeito e tem para o único argumento o comprimento do vetor: numerical (),

logical (), e character ().

Fator. Um fator inclui não somente os valores da variável categórica correspondente, mas

também os possíveis diferentes níveis dessa variável (mesmo se estão presentes nos

dados). A função factor cria um fator com as seguintes opções:

factor(x, levels = sort(unique(x), na.last = TRUE),

labels = levels, exclude = NA, ordered = is.ordered(x))

levels especifica os níveis possíveis do fator (por padrão os valores originais do vetor x),

labels define os nomes dos níveis, exclude os valores de x para excluir dos níveis, e

ordeded é um argumento lógico que especifica se os níveis do fator estão requisitados.

Relembre que x é de modo numeric ou character. Segue alguns exemplos.

27

factor(1:3)

[1] 1 2 3

Levels: 1 2 3

> factor(1:3, levels=1:5)

[1] 1 2 3

Levels: 1 2 3 4 5

> factor(1:3, labels=c("A", "B", "C"))

[1] A B C

Levels: A B C

> factor(1:5, exclude=4)

[1] 1 2 3 NA 5

Levels: 1 2 3 5

A função levels extraí os possíveis níveis de um fator:

> ff <- factor(c(2, 4), levels=2:5)

> ff

[1] 2 4

Levels: 2 3 4 5

> levels(ff)

[1] "2" "3" "4" "5"

Matriz. Uma matriz é realmente um vetor com um atributo adicional (dimensão) que é por si

próprio um vetor numérico com comprimento 2, e define os números das linhas e colunas da

matriz. Uma matriz pode ser criada com a função matrix:

matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE,

dimnames = NULL)

A opção byrow indica qualquer que seja os valores dos dados devem encher

sucessivamente as colunas (o padrão) ou as linhas (se VERDADEIRO). A opção dimnames

permite dar nomes às linhas e as colunas.

> matrix(data=5, nr=2, nc=2)

[,1] [,2]

28

[1,] 5 5

[2,] 5 5

> matrix(1:6, 2, 3)

[,1] [,2] [,3]

[1,] 1 3 5

[2,] 2 4 6

> matrix(1:6, 2, 3, byrow=TRUE)

[,1] [,2] [,3]

[1,] 1 2 3

[2,] 4 5 6

Outro modo de criar uma matrix é dar valores apropriados para o atributo dim (que é

inicialmente NULL):

> x <- 1:15

> x

[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

> dim(x)

NULL

> dim(x) <- c(5, 3)

> x

[,1] [,2] [,3]

[1,] 1 6 11

[2,] 2 7 12

[3,] 3 8 13

[4,] 4 9 14

[5,] 5 10 15

Uma outra maneira de criar uma matriz em R é converter um vetor do n.m do comprimento em

uma matriz do n x m:

> mynumbers <- 1:12

> matrix(mynumbers, nrow=4)

Note que a matriz são colunas criadas de forma sensata - para a construção prudente uma da

linha ou fila tem que usar a opção byrow=T:

> matrix(mynumbers, nrow=4, byrow=T)

29

Uma maneira alternativa para construir as matrizes é usar as funções cbind () e rbind ( ),

que combinam vetores (sabiamente linha ou coluna) a uma matriz:

> mynumbers1 <- 1:4

> mynumbers2 <- 11:14

> cbind(mynumbers1,mynumbers2) cbind( )

> rbind(mynumbers1,mynumbers2) rbind( )

Elementos de acesso dos vetores e das matrizes

Os elementos particulares de vetores e de matrizes de R podem ser acessados usando os

suportes quadrados [ ]. Suponha que criamos os seguintes objetos de R, vector1 e matrix1:

> vector1 <- seq(-3, 3, 0.5)

> matrix1 <- matrix(1:20, nrow=5)

Alguns exemplos de como acessar elementos particulares são dados abaixo:

> vetor1[5] # retorna o 5o. elemento de vetor1

> vetor1[1:3] # retorna os primeiros três elementos de vetor1

> vetor1[c(2,4,5)] # retorna o 2o., 4o. e 5o. elementos de vetor1

> vector1[-5] # retorna todos os elementos exceto o 5o. de vetor1

Os elementos das matrizes são acessados de uma maneira similar. matrix1[a, b] retorna o

valor da a-ésima fila e a b-ésima coluna de matrix1:

> matrix1[2,3] # retorna o valor da matriz1 na 2a. linha e 3a. coluna

> matrix1[1:2,3] # retorna o valor da matriz1 nas duas 1ª. linhas e 3a. coluna

> matrix1[2,] # retorna a 2a. linha da matriz1

> matrix1[,3] # retorna a 3a. coluna da matriz1

30

Data-frame. Nós vimos que um data-frame (planilha de dados) é criado implicitamente pela

função read.table; é também possível criar um data-frame com a função data.frame. Os

vetores incluídos assim no data-frame devem ser do mesmo tamanho ou comprimento, ou se um

deles for menor, ele é “reciclado” um número inteiro de vezes:

> x <- 1:4; n <- 10; M <- c(10, 35); y <- 2:4

> data.frame(x, n)

x n

1 1 10

2 2 10

3 3 10

4 4 10

> data.frame(x, M)

x M

1 1 10

2 2 35

3 3 10

4 4 35

> data.frame(x, y)

Error in data.frame(x, y) :

arguments imply differing number of rows: 4, 3

Se um fator for incluído em um data-frame, deve ser do mesmo comprimento que os vetores. É

possível mudar os nomes das colunas com data.frame (A1=x, A2=n). Pode também dar

nomes às linhas com a opção row.names que deve ser, naturalmente, um vetor de modo

character e de comprimento igual ao número de linhas do data-frame. Finalmente, note que os

data-frame têm um atributo dim (dimensão) similarmente às matrizes.

Lista. Uma lista é criada de uma maneira similar aos data-frames com a função list. Não há

nenhum constrangimento nos objetos que podem ser incluídos. Por contraste a

data.frame(), os nomes dos objetos não são tomados por padrão; tomemos os vetores x e y

do exemplo precedente:

> L1 <- list(x, y); L2 <- list(A=x, B=y)

> L1

31

[[1]]

[1] 1 2 3 4

[[2]]

[1] 2 3 4

> L2

$A

[1] 1 2 3 4

$B

[1] 2 3 4

> names(L1)

NULL

> names(L2)

[1] "A" "B"

Séries temporais. A função ts cria um objeto da classe “ts” de um vetor (série temporal

univariada) ou de uma matriz (série temporal multivariada), e algumas opções que caracterizam

a série. As opções, com os valores padrão, são:

ts(data = NA, start = 1, end = numeric(0), frequency = 1,

deltat = 1, ts.eps = getOption("ts.eps"), class, names)

data um vetor ou uma matriz

start tempo da 1ª. observ., um número, ou um vetor de dois inteiros (ver ex. abaixo)

end tempo da última observação especificada da mesma maneira que start

frequency número das observações por unidade de tempo

deltat fração do período de amostragem entre observações sucessivas (ex. 1/12 para

dados mensais); somente frequency ou deltat deve ser dado

ts.eps tolerância para a comparação de séries. As freqüências estão consideradas

iguais se sua diferença for menor do que ts.eps

class classe para dado objeto; o padrão é “ts” para uma única série, e c (“mts”,

“ts”) para séries multivariadas

32

names um vetor de modo character com os nomes da série individual no caso de séries

multivariadas; por padrão os nomes das colunas de dados, ou Série 1, Série 2,...

Alguns exemplos das séries temporais criadas com a função ts():

> ts(1:10, start = 1959)

Time Series:

Start = 1959

End = 1968

Frequency = 1

[1] 1 2 3 4 5 6 7 8 9 10

> ts(1:47, frequency = 12, start = c(1959, 2))

Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec

1959 1 2 3 4 5 6 7 8 9 10 11

1960 12 13 14 15 16 17 18 19 20 21 22 23

1961 24 25 26 27 28 29 30 31 32 33 34 35

1962 36 37 38 39 40 41 42 43 44 45 46 47

> ts(1:10, frequency = 4, start = c(1959, 2))

Qtr1 Qtr2 Qtr3 Qtr4

1959 1 2 3

1960 4 5 6 7

1961 8 9 10

> ts(matrix(rpois(36, 5), 12, 3), start=c(1961, 1),

frequency=12)

Series 1 Series 2 Series 3

Jan 1961 8 5 4

Feb 1961 6 6 9

Mar 1961 2 3 3

Apr 1961 8 5 4

May 1961 4 9 3

Jun 1961 4 6 13

Jul 1961 4 2 6

Aug 1961 11 6 4

Sep 1961 6 5 7

33

Oct 1961 6 5 7

Nov 1961 5 5 7

Dec 1961 8 5 2

Expressão. Os objetos de modo expressão têm um papel fundamental no R. Uma expressão é

uma série de caracteres que faz sentido para R. Todos os comandos válidos são expressões.

Quando um comando é escrito diretamente no teclado, então é avaliado por R e executado se for

válido. Em muitas circunstâncias, é útil construir uma expressão sem avaliá-la: isto é o que é

feito para a função expression. É, naturalmente, possível avaliar a expressão

subseqüentemente com a função eval().

> x <- 3; y <- 2.5; z <- 1

> exp1 <- expression(x / (y + exp(z)))

> exp1

expression(x/(y + exp(z)))

> eval(exp1)

[1] 0.5749019

As expressões podem ser usadas, entre outras coisas, para incluir equações nos gráficos (P.

32). Uma expressão pode ser criada de uma variável de modo character. Algumas funções

tomam expressões como argumentos, por exemplo D() que retorna derivadas parciais:

> D(exp1, "x")

1/(y + exp(z))

> D(exp1, "y")

-x/(y + exp(z))ˆ2

> D(exp1, "z")

-x * exp(z)/(y + exp(z))ˆ2

34

3.5.2 Convertendo objetos

O leitor certamente percebeu que as diferenças entre alguns tipos de objetos são pequenas;

isto é assim lógico para converter um objeto de um tipo a outro mudando alguns de seus

atributos. Tal conversão será feita com uma função do tipo as.something. R (versão 1.5.1)

tem, no pacote base, 77 de tais funções, só que nós não daremos detalhes mais profundos aqui.

O resultado de uma conversão depende obviamente dos atributos do objeto convertido.

Geralmente, conversão segue réguas intuitivas. Para a conversão dos modos, a seguinte tabela

sumariza a situação.

Tabela 3. Regras para conversão de funções.

Existem funções para converter os tipos de objetos (as.matrix, as.data.frame,

as.ts, as.expression,...). Estas funções devem afetar os atributos à exceção dos

modos durante a conversão. Os resultados são, outra vez, geralmente intuitivos. Uma situação

encontrada freqüentemente é a conversão de fatores em valores numéricos. Neste caso, R

faz a conversão com o código numérico dos níveis do fator:

> fac <- factor(c(1, 10))

> fac

[1] 1 10

Levels: 1 10

> as.numeric(fac)

[1] 1 2

35

Para converter um fator mas manter os níveis como eles foram originalmente

especificados, deve primeiro converter de caractere, então em numérico.

> as.numeric(as.character(fac))

[1] 1 10

Este procedimento é muito útil se em um arquivo uma variável numérica tiver também

valores não-numéricos. Nós vimos que read.table() em tal situação deve, por padrão, ler

esta coluna como um fator.

3.5.3 Operadores

Nós temos visto previamente que há três tipos de operadores no R. Está aqui a lista.

Tabela 4. Tipos de operadores no sistema R

Os operadores de aritmética e de comparação agem em dois elementos (x+y, a < b).

Os operadores aritméticos agem nas variáveis de modos numéricos ou complexos, mas também

nas lógicas; neste último caso, os valores lógicos coerced em numérico. Os operadores de

comparação podem ser aplicados em qualquer modo: retorna um ou diversos valores lógicos. Os

operadores lógicos são aplicados a um (!) ou dois objetos de modos lógicos, e retorna um (ou

diversos) valores lógicos. Os operadores “AND” e “OR” existem em duas formas: uma única

operação sobre cada elementos dos objetos e retornam tantos valores lógicos como as

comparações feitas; dupla operação sobre o primeiro elemento dos objetos.

É necessário para usar o operador “AND” especificar um desigualdade do tipo 0 < x < 1

que deve ser codificada com: 0 < x & x < 1. A expressão 0 , x , 1 é válida, mas não deve

36

retornar o resultado esperado: desde que ambos os operados são os mesmos, são executados

sucessivamente da esquerda para a direita. A comparação 0, x é a primeira feita e retorna um

valor lógico que é comparado a 1 (TRUE ou FALSE < 1): nesta situação, o valor lógico é

implicitamente coerced em numérico (1 ou 0 < 1).

Os operadores de comparação operam sobre cada elemento dos dois objetos que estão

sendo comparados (reciclando os valores do mais curto se necessário), e retorna assim um

objeto do mesmo tamanho. Para comparar completamente os dois objetos, é necessário usar a

função identical:

> x <- 1:3; y <- 1:3

> x == y

[1] TRUE TRUE TRUE

> identical(x, y)

[1] TRUE

3.5.4 Acessando valores de um objeto: o sistema indexado

Sistema de indexação é uma maneira eficiente e flexível para acessar seletivamente os

elementos de um objeto; pode ser numérico ou lógico. Para acessar, por exemplo, o terceiro

valor de um vetor x, nós escrevemos apenas x [3]. Se x for uma matriz ou um data-frame, o

valor da i-ésima linha e j-ésima coluna é acessado com x [i, j]. Para mudar todos os valores da

terceira coluna, nós podemos escrever:

> x[, 3] <- 10.2

Este sistema de indexação é generalizado fàcilmente para arrays, com tantos índices como

o número de dimensões do array (por exemplo, um array tridimensional: x [i, j, k], x [ , , 3],...

É útil manter-se na mente que a indexação é feita com suportes retos ([ e ]), visto que os

parênteses são usados para os argumentos de uma função:

> x(1)

Error: couldn’t find function "x"

A indexação pode ser usada para suprimir uma ou diversas linhas ou colunas. Por

exemplo, x [- 1, ] suprimirá a primeira linha, ou x [- c (1, 15), ] fará o mesmo para as 1as e

15as linhas. Para vetores, matrizes e arrays, é possível acessar os valores de um elemento com

uma expressão de comparação como o index:

37

> x <- 1:10

> x[x >= 5] <- 20

> x

[1] 1 2 3 4 20 20 20 20 20 20

> x[x == 1] <- 25

> x

[1] 25 2 3 4 20 20 20 20 20 20

Um uso prático da indexação lógica é, por exemplo, a possibilidade de selecionar os

elementos pares de uma variável integer (inteira):

> x <- rpois(40, lambda=5)

> x

[1] 5 9 4 7 7 6 4 5 11 3 5 7 1 5 3 9 2 2 5 2

[21] 4 6 6 5 4 5 3 4 3 3 3 7 7 3 8 1 4 2 1 4

> x[x %% 2 == 0]

[1] 4 6 4 2 2 2 4 6 6 4 4 8 4 2 4

Assim, este sistema de indexação usa os valores lógicos retornados, nos exemplos acima,

por operadores de comparação. Estes valores lógicos podem ser computados antes, eles então

devem ser reciclados se necessário:

> x <- 1:40

> s <- c(FALSE, TRUE)

> x[s]

[1] 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40

A indexação lógica pode ser usada também com data-frames, mas com a dificuldade que

as diferentes colunas diferentes do data-frame podem ser de modos diferentes.

Para listas, acessar os elementos diferentes (que podem ser qualquer tipo de objeto) é feito

com os suportes retos em dobro ([[ ]], por exemplo my.list [[3]] para acessar o terceiro

objeto da lista nomeado my.list. O resultado pode então em si próprio ser indexado como

visto previamente para vetores, matrizes, etc. Se este terceiro objeto for um vetor, seus valores

podem ser modificados com my.list [[3]] [i], se for um array tridimensional com

my.list [[3]] [i, j, k], e assim por diante.

3.5.5 Acessando os valores de um objeto com nomes

38

Nós vimos em diversas ocasiões o conceito de names. Os nomes são atributos, e há

diversos tipos dos nomes (nomes, colnames, rownames, dimnames). Limitar-nos-emos aqui às

noções muito simples sobre nomes, para alcançar particularmente os elementos de um objeto.

Se os elementos de um objeto tiverem nomes, podem ser extraídos usando-os como índices.

Fazendo a extração desta maneira, os atributos do objeto original são mantidos. Por exemplo, se

um data-frame DF de dados contiver as variáveis x, y, e z, o comando DF [“x”] extrairá um

data-frame com exatamente x; DF [c (“x”, “y”)] extrairá um data-frame com ambas as variáveis.

Como o leitor certamente verifica, o índice usado aqui é um vetor de modo character.

Como os vetores numéricos ou lógicos vistos acima, este vetor pode ser definido antes e então

ser usado para a extração.

Para extrair um vetor ou um fator de um data-frame, pode-se usar o símbolo $ (por

exemplo, DF$x). Este procedimento trabalha também com listas.

3.5.6 O editor de dados

É possível usar uma planilha gráfica - como o editor para editar um objeto de “dados”. Por

exemplo, se X for uma matriz, o comando data.entry(X) abrirá um editor gráfico e esse

pode modificar alguns valores instalando nas pilhas apropriadas, ou para adicionar colunas

novas ou linhas.

A função data.entry modifica diretamente o objeto dado como o argumento sem

necessitar atribuir seu resultado. De outra maneira, a função retorna uma lista com os objetos

dados como argumentos e possivelmente modificados. Este resultado é indicado na tela por

padrão, mas, quanto para a maioria de funções, pode ser atribuído a um objeto.

Os detalhes de usar o editor dos dados dependem do sistema operacional.

3.5.7 Aritméticas e funções simples

Existem numerosas funções em R para manipular dados. Nós temos visto já a mais

simples, c ( ) que concatena os objetos listados nos parênteses. Por exemplo:

> c(1:5, seq(10, 11, 0.2))

[1] 1.0 2.0 3.0 4.0 5.0 10.0 10.2 10.4 10.6 10.8 11.0

39

Vetores podem ser manipulados com expressões aritméticas clássicas:

> x <- 1:4

> y <- rep(1, 4)

> z <- x + y

> z

[1] 2 3 4 5

Os vetores de comprimentos diferentes podem ser adicionados; neste caso, o vetor mais

curto é reciclado. Exemplos:

> x <- 1:4

> y <- 1:2

> z <- x + y

> z

[1] 2 4 4 6

> x <- 1:3

> y <- 1:2

> z <- x + y

Warning message:

longer object length

is not a multiple of shorter object length in: x + y

> z

[1] 2 4 4

Note que R retornou uma mensagem de advertência e não uma mensagem de erro, assim a

operação foi feita. Se nós quisermos adicionar (ou multiplicar) o mesmo valor a todos os

elementos de um vetor:

> x <- 1:4

> a <- 10

> z <- a * x

> z

[1] 10 20 30 40

As funções disponíveis em R são muitas para ser listadas aqui. Podem-se encontrar todas

as funções matemáticas básicas (log, exp, log10, log2, sin, cos, tan,

asin, acos, atan, abs, sqrt,... ), funções especiais (gamma, digamma,

40

beta, besselI. ), bem como as diversas funções diversas úteis nas estatísticas. Algumas

destas funções são detalhadas na seguinte tabela.

Quadro 4. Algumas funções estatísticas básicas disponíveis no R

Estas funções retornam um único valor (assim um vetor do comprimento um), exceto

range () que retorna um vetor do comprimento dois, e var(), cov(), e cor() que

pode retornar uma matriz.

41

3.5.8 Escrevendo funções do R

Caso em que R não oferece uma função requerida, é possível elaborar a escrita de uma

função. Suponha que se deseja computar a média geométrica de uma amostra:

( )1

log1

1

i

i

n xnn

G i

i

x eµ=

∑= =∏

Desde que R não tem uma função para computar a média geométrica, poderíamos escrever

nossa própria função geo.mean ():

> fix (geo.mean) ( ) fix ( )

abre uma janela do editor onde possamos entrar nossa função:

> function (x) function (x)

> {

> gm <- exp (mean (log (x ) ) )

> return (gm)

> }

Note que R verifica a função após ter fechado e ter salvo a janela do editor. Em caso de

erros da sintaxe (a causa a mais comum para isto é a falta de um suporte), R os relata ao usuário.

A fim reparar os erros, tem-se que entrar

> geo.mean <- edit() edit ( )

desde que os resultados (errôneos) não são salvos. (Usar o reparo (geo.mean) resulta em perder

as últimas mudanças.)

42

3.5.9 Computação de matrizes

R tem facilidades para a computação e a manipulação de matriz. As funções rbind() e

cbind() ligam matrizes com respeito às linhas ou às colunas, respectivamente:

> m1 <- matrix(1, nr = 2, nc = 2)

> m2 <- matrix(2, nr = 2, nc = 2)

> rbind(m1, m2)

[,1] [,2]

[1,] 1 1

[2,] 1 1

[3,] 2 2

[4,] 2 2

> cbind(m1, m2)

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

[1,] 1 1 2 2

[2,] 1 1 2 2

O operador para o produto de duas matrizes é ‘%*%’. Por exemplo, considere as duas

matrizes m1 e m2 acima:

> rbind(m1, m2) %*% cbind(m1, m2)

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

[1,] 2 2 4 4

[2,] 2 2 4 4

[3,] 4 4 8 8

[4,] 4 4 8 8

> cbind(m1, m2) %*% rbind(m1, m2)

[,1] [,2]

[1,] 10 10

[2,] 10 10

A transposição de uma matriz é feito com a função t; esta função trabalha também com um

data-frame.

43

A função diag() pode ser usada para extrair ou modificar a diagonal de uma matriz, ou

construir uma matriz diagonal.

> diag(m1)

[1] 1 1

> diag(rbind(m1, m2) %*% cbind(m1, m2))

[1] 2 2 8 8

> diag(m1) <- 10

> m1

[,1] [,2]

[1,] 10 1

[2,] 1 10

> diag(3)

[,1] [,2] [,3]

[1,] 1 0 0

[2,] 0 1 0

[3,] 0 0 1

> v <- c(10, 20, 30)

> diag(v)

[,1] [,2] [,3]

[1,] 10 0 0

[2,] 0 20 0

[3,] 0 0 30

> diag(2.1, nr = 3, nc = 5)

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

[1,] 2.1 0.0 0.0 0 0

[2,] 0.0 2.1 0.0 0 0

[3,] 0.0 0.0 2.1 0 0

R tem também algumas funções especiais para a computação de matriz. Nós podemos citar aqui

solve() para inverter uma matriz, qr() para decomposição, eigen() para computar

autovalores e autovetores, e um svd() para decomposição de valor singular.

44

4. Gráficos com R

4.1 Manipulando gráficos

R oferece uma variedade notável dos gráficos. Para começar uma idéia, se pode escrever

demo(graphics). Não é possível detalhar aqui as possibilidades de R em termos de

gráficos, particularmente cada função gráfica tem um grande número opções fazendo a

produção dos gráficos muito flexíveis, e o uso de um pacote extraído quase inútil.

A maneira de trabalhar funções gráficas varia substancialmente do esquema esboçado no

começo deste original. Particularmente, o resultado de uma função gráfica não pode ser

atribuído a um objeto (há algumas exceções notáveis: hist() e do barplot() produzem resultados

numéricos também como listas ou matrizes.), mas é emitido a um dispositivo gráfico. Um dispositivo

gráfico é uma janela gráfica ou um arquivo.

Há dois tipos de funções gráficas: plot de funções alto-nível que cria um novo gráfico, e os

plots de funções de baixo-nível que adiciona elementos a um gráfico já existente. Os gráficos

são produzidos com respeito aos parâmetros gráficos que são definidos por padrão e podem ser

modificados com a função par().

Nós veremos num primeiro momento como controlar gráficos e dispositivos gráficos;

então detalharemos de algum modo as funções e os parâmetros gráficos. Nós veremos um

exemplo prático do uso destas funcionalidades na produção de gráficos. Finalmente, veremos os

pacotes grid e lattice cujo funcionamento é diferente das sumarizadas acima.

Exemplo: Traçando funções

Suponha que você devia traçar à mão uma função. Uma possibilidade de fazê-la é

1. Selecionar alguns valores-x da escala para ser traçado

2. Computar correspondentes valores de y = f (x)

3. Traçar x de encontro à y

4. Adicionar uma linha suave (mais ou menos) conectando os pontos (x, y)

Os gráficos das funções são criados essencialmente da mesma maneira em R, por exemplo

traçando a função f (x) = sin (x) na escala de -π a π pode ser feito como segue:

> x <- seq(-pi, pi, length=10) # define 10 valores de -π para π

45

> y <- sin(x) # computa o correspondente valor de y

> plot(x, y) # plota x conjuntamente com y plot( )

> lines(x, y) # adiciona a linha conectando ponto (x, y) lines( )

Figura 1.1 – Traçando sen(x) em R.

A saída é mostrada na parte esquerda da figura 1.1. Entretanto, o gráfico não se mostra muito

atraente desde que falta a lisura. Um “truque simples” para melhorar o gráfico é aumentar

simplesmente o número dos x-valores em que f (x) é avaliado, por exemplo, 1000:

> x <- seq(-pi, pi, length=1000)

> y <- sin(x)

> plot(x, y, type="l")

O resultado é mostrado na parte direita de figura 1.1. Note que o uso da opção type = “1”, faz

com que o gráfico seja extraído com linhas melhor conectadas que os pontos.

Exemplos para manuseio de distribuições

Suponha que desejamos gerar 50 números aleatórios de uma distribuição normal padrão e os

indicar como um histograma. Adicionalmente, queremos acrescentar a f.d.p. da distribuição

normal (“ajustada”) ao plot como mostrado na figura 1.2:

> mysample <- rnorm(50) # gera números aleatórios

> hist(mysample, prob=T) # extraí o histograma

> mu <- mean(mysample) # computa a média amostral

> sigma <- sd(mysample) #computa o desvio padrão amostral

46

> x <- seq(-4, 4, length=500) # define os valores-x para a f.d.p

> y <- dnorm(x, um, sigma) # computa valores da f.d.p normal

> lines(x, y) # adiciona a f.d.p como “linhas” para o plot

Figura 1.2 Histograma dos números aleatórios distribuídos normalmente

e densidade “ajustada”.

Um outro exemplo (figura 1.3) é a visualização da aproximação da distribuição binomial com a

distribuição normal para, por exemplo, n = 50 e π = 0.25:

> x <- 0:50 # define os valores de x

> y <- dbinom(x, 50, 0.25) # computa as probabilidades binomial

> plot(x, y, type=”h”) # plota probabilidades binomiais

> x2 <- seq(0,50,length=500) # define os valores-x (para a f.d.p normal)

> y2 <- dnorm(x2, 50*0.25,

sqrt(500.25*(1-0.75))) # computa a f.d.p. da normal

> lines(x2, y2, col=”red”) # extraí a f.d.p da normal

47

Figura 1.3: Comparando a distribuição binomial com n = 50 e π = 0.25 com uma

aproximação pela distribuição normal ( )( ), 1n nµ π σ π π= = −

4.1.1 Abrindo diversos dispositivos gráficos

Quando uma função gráfica é executada, se não tem dispositivo gráfico aberto, R abre

uma janela e mostra o gráfico. Um dispositivo gráfico pode ser aberto com uma função

apropriada. A lista de dispositivos gráficos disponíveis depende do sistema operacional. As

janelas gráficas são chamadas X11 sob o Unix / Linux e windows sob o sistema Windows. Em

todos os casos, pode abrir uma janela gráfica com o comando x11() que trabalha também sob

o Windows por causa de um pseudônimo com o comando windows(). Um dispositivo

gráfico que seja um arquivo deve ser aberto com uma função dependendo do formato:

postscript(), pdf(), png(), ...A lista de dispositivos gráficos disponíveis pode

ser encontrada com ?device.

O último dispositivo aberto transforma-se no dispositivo gráfico em que todos os gráficos

subseqüentes serão mostrados. A função dev.list() mostra a lista de dispositivos abertos:

> x11(); x11(); pdf()

> dev.list()

X11 X11 pdf

2 3 4

48

As figuras mostradas são os números dos dispositivos que são mais usados para mudar o

dispositivo ativo.

> dev.cur()

pdf

4

e muda para o dispositivo ativo:

> dev.set(3)

X11

3

A função dev.off() fecha um dispositivo: por padrão o dispositivo ativo é fechado, em

caso contrário isto é o número que é dado como o argumento para a função. R indica então o

número do novo dispositivo ativo:

> dev.off(2) X11 3 > dev.off() pdf 4

Duas características específicas da versão de R para Windows valem a pena mencionar:

um dispositivo Windows Metafile pode estar aberto com a função win.metafile, e um

menu “History” mostrada quando a janela gráfica é selecionada permitindo a gravação de todos

os gráficos extraídos durante uma sessão (por padrão, o sistema da gravação está desligado, o

usuário o liga clicando sob “Recording” neste menu).

4.1.2 Particionando um gráfico

A função split.screen particiona o dispositivo gráfico ativo. Por exemplo:

> split.screen(c(1, 2))

divide o dispositivo em duas partes que podem ser selecionadas com a tela (1) ou tela (2);

erase.screen() suprime o último gráfico extraído. Uma parte do dispositivo pode em si

próprio ser dividido com o split.screen() conduzindo à possibilidade para fazer arranjos

complexos. Estas funções são incompatíveis com outras (tais como layout() ou

coplot())e não deve ser usado com dispositivos gráficos múltiplos. Seu uso deve ser

limitado, por exemplo, à exploração gráfica dos dados.

49

A função layout divide a janela gráfica ativa em diversas partes onde os gráficos

deverão ser mostrados sucessivamente. Estas funções tem para argumento principal uma matriz

com números inteiros indicando os números das “sub-janelas”. Por exemplo, para dividir o

dispositivo em quatro partes iguais:

> layout(matrix(1:4, 2, 2))

É naturalmente possível criar esta matriz permitindo previamente visualizar melhor como

o dispositivo é dividido:

> mat <- matrix(1:4, 2, 2) > mat [,1] [,2] [1,] 1 3 [2,] 2 4 > layout(mat)

Para visualizar realmente a divisão criada, pode usar a função layout.sh com o número

das sub-janelas como o argumento (aqui 4). Neste exemplo, nós teremos:

> layout.show(4)

Os exemplos seguintes mostram algumas das possibilidades oferecidas por layout().

> layout(matrix(1:6, 3, 2)) > layout.show(6) > layout(matrix(1:6, 2, 3)) > layout.show(6) > m <- matrix(c(1:3, 3), 2, 2) > layout(m) > layout.show(3)

50

4.2 Funções gráficas

Quadro 5. Vista geral das funções gráficas no R.

Para cada função, as opções podem ser encontradas com a ajuda on-line no R. Algumas destas

opções são idênticas para diversas funções gráficas; estão aqui as principais (com seus possíveis

valores padrão):

51

add=FALSE se TRUE sobrepõe o traçado sob um precedente (se existe)

axes=TRUE se FALSE não extrai os eixos e o box

type= “p" especifica o tipo de traçado, “p”: pontos, “l”: linhas, “b”: pontos

conectados por linhas, “o”: idem, mas as linhas estão sobre os pontos,

“h”: linhas verticais, “s”: etapas, os dados são representados pelo alto das

linhas verticais, “S”: idem, mas os dados são representados pelo fundo

das linhas verticais

xlim=, ylim= especifica os limites inferiores e superiores dos eixos, por exemplo com

xlim=c (1, 10) ou xlim=range (x)

xlab=, ylab= anota os eixos, deve ser variáveis do modo character

main= título principal, deve ser uma variável do modo character

sub= sub-título (escrito em fonte menor)

4.3 Comandos de plots de baixo-nível

R tem um conjunto de funções gráficas que afetam um gráfico já existente: são chamados

comandos de traçados de baixo nível. Estão aqui os principais:

Quadro 6 – Comando de plots de baixo-níveis no sistema R.

52

Note a possibilidade de adicionar expressões matemáticas em um plot com texto(x, y,

expressão (...)), onde a função expressão transforma seu argumento em uma equação

matemática. Por exemplo,

> text(x, y, expression(p == over(1, 1+eˆ-(beta*x+alpha))))

Devendo mostrar, sobre o plot, a seguinte equação para os pontos de coordenadas (x, y):

Para incluir em uma expressão uma variável nós podemos usar as funções substitute e

as.expression; por exemplo para incluir um valor de R2 (previamente computado e

armazenado em um objeto nomeado Rsquared):

> text(x, y, as.expression(substitute(Rˆ2==r,

+ list(r=Rsquared))))

Deverá mostrar no plot para os pontos de coordenadas (x, y)

R2 = 0.9856298

Para indicar somente três decimais, nós podemos modificar o código como segue:

> text(x, y, as.expression(substitute(Rˆ2==r,

+ list(r=round(Rsquared, 3)))))

que ficará

R2 = 0.986

Finalmente, para escrever o coeficiente de determinação R2 em itálico:

> text(x, y, as.expression(substitute(italic(R)ˆ2==r,

+ list(r=round(Rsquared, 3)))))

R2 = 0.986

53

4.4 Parâmetros gráficos

Em adição aos comandos de traçados de baixo-nível, a apresentação dos gráficos pode ser

melhorada com parâmetros gráficos. Podem ser usados como opções de funções gráficas (mas

ele não trabalha para tudo), ou com a função par() mudar permanentemente os parâmetros

gráficos, isto é, os plots subseqüentes serão extraídos com respeito aos parâmetros especificados

pelo usuário. Por exemplo, o seguinte comando:

> par(bg="yellow")

resultará em todos os traçados subseqüentes extraídos com um fundo amarelo. Existe 68

parâmetros gráficos, alguns deles têm funções muito próximas. A lista exaustiva de parâmetros

gráficos pode ser lida com a ajuda?Par; Limitei a seguinte tabela às mais usuais.

Quadro sete. Parâmetros gráficos mais usuais na confecção de gráficos no R.

54

Figura 2: Os símbolos de traçar em R (pch=1: 25). As cores foram obtidas com as opções col= " azul " , bg= " amarelo ", a segunda opção têm um efeito somente para os símbolos 21-25. Qualquer o caráter pode ser usado (pch= "*", “? ”, “. ”,... ).

4.5 Um exemplo prático

A fim de ilustrar funcionalidades gráficas do R, deixe-nos considerar um exemplo simples de

um gráfico bivariado de 10 pares de variáveis aleatórias. Estes valores foram gerados com:

> x <- rnorm(10)

> y <- rnorm(10)

O gráfico desejado será obtido com plot(); devendo ser escrito o comando:

> plot(x, y)

e o gráfico será traçado no dispositivo gráfico ativo. O resultado é mostrado figura 3. Por

padrão, R faz gráficos de uma maneira “inteligente”: os espaços entre marcas sobre os eixos, a

colocação das etiquetas, etc., são calculados de modo que o gráfico resultante seja tão inteligível

como possível.

O usuário pode, não obstante, mudar a maneira que um gráfico é apresentado, por

exemplo, para conformar-se a um estilo editorial predefinido, ou para dar-lhe um toque pessoal

para uma apresentação. A maneira mais simples de mudar a apresentação de um gráfico é

adicionar as opções que modificarão os argumentos padrões. Em nosso exemplo, nós podemos

modificar significativamente a figura da seguinte maneira:

55

plot(x, y, xlab="Ten random values", ylab="Ten other values",

xlim=c(-2, 2), ylim=c(-2, 2), pch=22, col="red",

bg="yellow", bty="l", tcl=0.4,

main="How to customize a plot with R", las=1, cex=1.5)

O resultado é a figura 4. Deixe-nos detalhar cada uma das opções usadas. Primeiramente, o

xlab e ylab mudam as etiquetas dos eixos que, por padrão, eram os nomes das variáveis.

Então, xlim e ylim permitem que definamos os limites em ambos os eixos. O parâmetro

gráfico pch é usado aqui como uma opção: pch=22 especifica um quadrado cujas cores do

contorno e do fundo possam ser diferentes e sejam dadas, respectivamente por, col e bg. A

tabela de parâmetros gráficos dá o significado das modificações feito por bty, tcl, las e

cex. Finalmente, um título é adicionado com a opção main.

Figura 3. A função plot usada sem opções.

56

Figura 4. A função plot usada com opções.

Figura 5. As funções par, plot e title.

Os parâmetros gráficos e as funções plots de baixo-nível permitem irmos mais e mais na

apresentação de um gráfico. Como visto previamente, alguns parâmetros gráficos não podem ser

passados como argumentos para uma função como plot. Modificaremos agora alguns destes

parâmetros com par(), e se faz necessário escrevermos diversos comandos. Quando os

57

parâmetros gráficos são mudados, é útil salvar seus valores iniciais previamente restaurando-os

mais tarde. Estão aqui os comandos usados obter a figura 5.

opar <- par()

par(bg="lightyellow", col.axis="blue", mar=c(4, 4, 2.5, 0.25))

plot(x, y, xlab="Ten random values", ylab="Ten other values",

xlim=c(-2, 2), ylim=c(-2, 2), pch=22, col="red", bg="yellow",

bty="l", tcl=-.25, las=1, cex=1.5)

title("How to customize a plot with R (bis)", font.main=3,adj=1)

par(opar)

58

4.6 Os pacotes grid e lattice

Os pacotes grid e lattice representam a implementação em R dos gráficos Trellis do S-

PLUS. Trellis é uma aproximação para visualizar os dados multivariados que é particularmente

apropriado para a exploração das relações ou das interações entre várias variáveis.

A idéia principal por trás do lattice (e do Trellis também) é aquela de gráficos

múltiplos condicionais: um gráfico bivariado será dividido em diversos gráficos com respeito

aos valores de uma terceira variável. A função coplot usa uma aproximação similar, mas

grid oferece mais funcionalidades do que esta função.

Os gráficos produzidos por grid ou por lattice não podem ser combinados ou

misturados com os aqueles produzidos pelas funções vistas acima, porque estes pacotes usam

um novo modo gráfico. Esta nova modalidade tem seu próprio sistema dos parâmetros gráficos

que são distintos daqueles vistos acima. Entretanto, é possível usar ambas as modalidades

gráficas na mesma sessão no mesmo dispositivo gráfico.

De um ponto prático da vista, grid contem todas as funções necessárias para o modo

gráfico, visto que as funções gráficas mais provavelmente a ser usadas atualmente estão no

lattice. A maioria de funções no lattice tomam uma fórmula como seu argumento

principal, por exemplo y ~x. A fórmula y ~ x | z significa que o gráfico de y com respeito a x

estará traçado como diversos gráficos com respeito aos valores de z.

A seguinte tabela dá as funções principais no lattice. A fórmula dada como o

argumento é a fórmula necessária típica, mas todas estas funções aceitam uma fórmula

condicional (˜ y ~ x | z) como o argumento principal; no último caso, um gráfico múltiplo, com

respeito aos valores de z é traçado como será visto nos exemplos seguintes.

Quadro 8. Funções principais do pacote lattice

59

Algumas funções no lattice têm o mesmo nome do que algumas funções gráficas no

pacote base. As últimas “são mascaradas” quando o lattice é carregado na memória.

Veremos agora alguns exemplos a fim ilustrar alguns aspectos do lattice. O pacote deve ser

carregado na memória com o comando library(lattice) de modo que as funções possam

ser acessadas

Deixar-nos começar com os gráficos de funções de densidade. Tais gráficos podem ser

feitos simplesmente com densityplot (˜ x) que traçará uma curva da função empírica da

densidade com os pontos que correspondem às observações no eixo-x (similarmente ao

rug()). Nosso exemplo será complicado mais ligeiramente com a superposição, em cada plot,

das curvas da densidade empírica e daquelas preditas de uma lei normal. É necessário usar o

argumento panel()que define o que é extraído em cada plot. Os comandos são:

n <- seq(5, 45, 5)

x <- rnorm(sum(n))

y <- factor(rep(n, n), labels=paste("n =", n))

densityplot(˜ x | y),

panel = function(x, ...) {

panel.densityplot(x, col="DarkOliveGreen", ...)

panel.mathdensity(dmath=dnorm,

args=list(mean=mean(x), sd=sd(x)),

col="darkblue")

})

As primeiras três linhas de comando geram uma amostra aleatória de variáveis normais

independentes as quais são divididas em sub-amostras de tamanhos iguais a 5, 10, 15... , e 45.

Então é chamada a função densityplot() que produz um plot para cada sub-amostra. A

função panel toma para argumento uma outra função. Em nosso exemplo, definimos uma

função que chama duas funções predefinidas no lattice: panel.densityplot para

extrair a função empírica da densidade, e panel.mathdensity a extrair a função da

densidade predita de uma lei normal. A função panel.densityplot é chamada por padrão

se nenhum argumento for dado para panel: o comando densityplot (˜ x | y) deve resultar

no mesmo gráfico que a figura 7, mas sem as curvas azuis.

60

x

De

nsity

0.0

0.5

1.0

-4 -2 0 2 4

n = 5 n = 10

-4 -2 0 2 4

n = 15

n = 20 n = 25

0.0

0.5

1.0

n = 30

0.0

0.5

1.0

n = 35

-4 -2 0 2 4

n = 40 n = 45

Figura 6. A função densityplot.

61

4.7 Exemplo de modelos lineares com R

O software R auxilia pesquisadores a estudar regressão, de forma fácil e pratica obtendo

resultados confiáveis e de fácil interpretação. As funções que serão demonstradas aqui, através

de exemplos, para aplicação de regressão, são as seguintes:

lm() summary() anova() plot() abline() lines() text()

lm( ) – Função que determine os coeficientes estimados da regressão linear simples ou múltipla. summary() – Resume os valores dos coeficientes e das medidas de tendência central. anova() – Define analise de variância para regressão. plot() – Determina o gráfico da regressão abline() – gera a reta da regressão no gráfico. text() – constrói textos no gráfico.

Exemplo prático:

Um psicólogo esta investigando a relação entre o tempo que o individuo leva para reagir a certo

estimulo e algumas características (neste exemplo será estudada a relação tempo e idade). Os

resultados estão contidos no arquivo de estimulo.dat contendo 20 pares de valores de

X(idade do indivíduo) e Y (tempo de reação).

> data1 <- read.table(“C:/R_work/estimulo.dat”, header=T)

> data1

Devemos ajustar este modelo à reta: Y = a + b*X

> tempo_reaçao <- lm(data1$Y ~ data1$X)

> tempo_reaçao

Call:

lm(formula = data1$Y ~ data1$X)

Coefficients:

(Intercept) data1$X

80.5 0.9

62

Desta forma a equação que modela o tempo de reação em função da idade é definida

com sendo o modelo ajustado:

y = 80,5 +0,9*x

para uma dada idade x é obtido um tempo de reação y estimado. Com os coeficientes obtidos

podemos visualizar um resumo de dados da regressão através da função summary ().

>summary(tempo_reaçao)

Call:

lm(formula = Y ~ X)

Residuals:

Min 1Q Median 3Q Max

-7.500 -4.125 -0.750 2.625 10.500

Coefficients:

Estimate Std. Error t value Pr(>|t|)

Intercept (a) 80.5000 5.4510 14.768 1.67e-11

X (b) 0.9000 0.1769 5.089 7.66e-05

Residual standard error: 5.593 on 18 degrees of freedom

Multiple R-Squared: 0.5899, Adjusted R-squared: 0.5672

F-statistic: 25.9 on 1 and 18 DF, p-value: 7.662e-05

A função summary() fornece dentre outros o coeficiente de determinação múltiplo

ajustado é (R2 ajustado = 0,5672), ou seja, a variável Y é explicada 57% por X.

Teste da significância da regressão:

> anova(tempo_reaçao)

63

Analysis of Variance Table

Response: data1$Y

Df Sum Sq Mean Sq F value Pr(>F)

data1$X 1 810.00 810.00 25.897 7.662e-05 ***

Residuals 18 563.00 31.28

---

Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

>

Response: Y

Df Sum Sq Mean Sq F value Pr(>F)

X 1 810.00 810.00 25.897 7.662e-05

Residuals 18 563.00 31.28

P-valor = 7.662e-05 = 0,00007662 < 0,001 indica a significância da regressão a 0,1% ou

seja, o coeficiente angular b = 0,9 é significante.

Gerando gráfico de dispersão:

> plot(data1$X,data1$Y,ylim=c(0,200),xlim=c(10,50),xlab="Idade",ylab="Tempo de Reação")

> abline (tp_reac) # plota a reta estimada de regressão

>text(20,200,"y=80.5 + 0.9*X p<0,01") # intrdouz a expressão da reta estimada de regressão

Figura 7. Gráfico de dispersão entre X e Y

64

Referências:

1) Emmanuel Paradis, R for Beginners

2) Oleg Nenadi , Walter Zucchini, Statistical Analysis with R (a quick start) 3) W. N. Venables, D. M. Smith and the R Development Core Team,

An Introduction to R, (Notes on R: A Programming Environment for Data Analysis

and Graphics Version 2.1.0 (2005-04-18)