Introdução ao R: Recurso Computacional para Estatística

Prévia do material em texto

RECURSO COMPUTACIONAL PARA ESTATI´STICA
Uma breve introduc¸a˜o ao R Ba´sico
Prof. Edson Antonio Alves da Silva
24 de fevereiro de 2011
1 INTRODUC¸A˜O
O R e´ uma linguagem de programac¸a˜o que permite manipular dados, fazer ca´lculos e gra´ficos es-
tat´ısticos, dentre outras coisas. O programa esta´ dispon´ıvel gratuitamente e livremente em http:
//www.r-project.org/. Uma ativa lista de discussa˜o para troca de informac¸o˜es, perguntas e res-
postas sobre o uso da linguagem R (eh necessario se cadastrar no grupo) pode ser vista em http:
//br.groups.yahoo.com/group/R_STAT/. Refereˆncias e/ou apostilas (portugueˆs e ingleˆs) podem
ser obtidas em: http://cran.r-project.org/doc/contrib/. Material adicional esta´ dispon´ıvel em
http://sites.google.com/site/marcosfs2006/material_r.
O R abre em uma janela denominada Workspace (area de trabalho) semelhante a` Figura 1. As ac¸
oes ali executadas ficam armazenadas na memo´ria vola´til (RAM) do computador enquanto ele estiver
em funcionamento, podendo ser salvo juntamente com o programa ao encerra´-lo ou em arquivo externo
espec´ıfico.
Figura 1: Tela principal (workspace) do R
1.1 Funcionalidades
• Ha´ uma distinc¸a˜o generalizada entre minu´sculas e MAIU´SCULAS. Desta forma, uma varia´vel
denominada “Sexo” e´ diferente de outra, denominado “sexo”.
1
• Um histo´rico dos comandos digitados durante uma sessa˜o pode ser recuperado pressionando-se
a tecla da seta para cima ou para baixo. Isso e´ muito u´til para se verificar comandos digitados
anteriormente ou reedita´-los como novo comando.
• Comandos colocados entre pareˆnteses mostram o seu resultado na tela. Por exemplo, o comando
(C = A+B) atribui a` varia´vel C o resultado da soma da varia´vel A com a varia´vel B e mostra
o resultado da operac¸a˜o.
• O R usa um ponto (.) como separador decimal padra˜o. Ou seja, um valor decimal deve ser
expresso como, por exemplo 1.86 e na˜o 1,86. Ao se importar dados de arquivos externos que
usam virgulas como separadores decimais, lembre-se de troca´-las por pontos (.), usando comandos
de localizar e substituir diretamente no arquivo fonte ou nos paraˆmetros de conversa˜o no processo
de leitura do arquivo.
• O R oferece os seguintes comandos de ajuda:
(a) help.start(): inicia documentac¸a˜o na forma de arquivos html visualizados no seu browser
(em Ingleˆs).
(b) help(to´pico) ou ?(to´pico): inicia uma janela de ajuda sobre um particular to´pico.
(c) Para sair com seguranca do R (encerrar) use o comando q(). O dia´logo
Save workspace image?[y/n/c]
aparecera´ perguntando se voceˆ quer “salvar” o espac¸o de trabalho. Usualmente se utiliza
responder n (na˜o).
1.2 Palavras Reservadas
Segundo a enciclope´dia Wikipe´dia1, em programac¸a˜o de computadore uma palavra reservada e´ uma
palavra que na˜o pode ser utilizada como um identificador de uma varia´vel por ser reservada para uso
da grama´tica da linguagem. Por exemplo, na linguagem de programac¸a˜o R, na˜o se pode utilizar uma
varia´vel com o nome for pois ela e´ reservada para construc¸a˜o de loops ou lac¸os. Esta e´ uma “palavra
chave”, e por ser de uso restrito e espac´ıfico, e´ tambe´m uma “palavra reservada”.
As principais palavras reservadas sa˜o:
NA (represental valores faltantes)
NaN (representa um valor na˜o representa´vel por nu´mero)
Inf (representa um valor indeterminado)
c q s t C D F I T diff exp log mean pi range rank var
FALSE Inf NA NaN NULL TRUE break else for function
if in next repeat while
1.3 Objetos da workspace
Um objeto presente na workspace e´ um elemento ali presente que apresenta certas propriedades que
o definem em uma classe ou grupo. Um objeto pode ser um carcater, um nu´mero, uma varia´vel, uma
func¸a˜o, uma tabela etc. Pode-se designar valores a`s varia´veis utilizando a combinac¸a˜o do sinal de
menor com h´ıfem (< −), do sinal de maior com h´ıfem (− >) ou o sinal (=). Por exemplo:
A < − 2 A varia´vel A recebe o valor 2
3 − > B A varia´vel B recebe o valor 3
C = A + B A varia´vel C e´ igual a soma de varia´vel A com a varia´vel B
1pt.wikipedia.org
Ao se utilizar a workspace para va´rias operac¸o˜es com objetos, e´ natural que tenhamos a necessidade
de certo manejo. Os principais comandos sa˜o:
objects() : mostra os objetos atualmente presentes na WS
rm() : remove um objeto da WS
rm(list = ls()) : remove (sem confirmac¸a˜o) todos os objetos da WS
Os principais tipos de objetos sa˜o:
• vetores;
• fatores;
• matrizes e arrays;
• listas
• data-frames (tabelas)
• func¸o˜es
E´ poss´ıvel identificar o tipo de um objeto com va´rios comandos
a) Comando str
> str(1:3)
int [1:3] 1 2 3
> str(1:3/2)
num [1:3] 0.5 1 1.5
> str(c("PR", "PR", "SC", "RS"))
chr [1:4] "PR" "PR" "SC" "RS"
> str(factor(c("PR", "PR", "SC", "RS")))
Factor w/ 3 levels "PR","RS","SC": 1 1 3 2
> (ar <- array(1:24, dim = c(3, 4, 2), dimnames = list(c("baixo",
+ "medio", "alto"), paste("col", 1:4, sep = "\n"), c("Masc",
+ "Fem"))))
, , Masc
col\n1 col\n2 col\n3 col\n4
baixo 1 4 7 10
medio 2 5 8 11
alto 3 6 9 12
, , Fem
col\n1 col\n2 col\n3 col\n4
baixo 13 16 19 22
medio 14 17 20 23
alto 15 18 21 24
> str(ar)
int [1:3, 1:4, 1:2] 1 2 3 4 5 6 7 8 9 10 ...
- attr(*, "dimnames")=List of 3
..$ : chr [1:3] "baixo" "medio" "alto"
..$ : chr [1:4] "col\n1" "col\n2" "col\n3" "col\n4"
..$ : chr [1:2] "Masc" "Fem"
> str(data.frame(X = 1:10, Y = 21:30))
'data.frame': 10 obs. of 2 variables:
$ X: int 1 2 3 4 5 6 7 8 9 10
$ Y: int 21 22 23 24 25 26 27 28 29 30
b) Comando class
> class(0:10)
[1] "integer"
> class(3)
[1] "numeric"
> class(1:10)
[1] "integer"
> class((1:10)/2)
[1] "numeric"
> class(matrix(1:6, nc = 3))
[1] "matrix"
> class(data.frame(X = 1:10, Y = 21:30))
[1] "data.frame"
> class(list(c("a", "b", "c")))
[1] "list"
c) Comando is
> is.vector(1:10)
[1] TRUE
> is.vector(3)
[1] TRUE
> is.matrix(matrix(1:6, nc = 3))
[1] TRUE
> is.numeric(matrix(1:6, nc = 3))
[1] TRUE
> is.numeric(0:10)
[1] TRUE
> is.character(matrix(1:6, nc = 3))
[1] FALSE
1.4 Entrada de dados na workspace
c(x1, x2, · · · , xn) : concatena (junta) os dados (x1, x2, · · · , xn) em um ob-
jeto do tipo vetor.
read.csv2(arquivo) : leˆ arquivo CSV (Comma-Separated Values)2 para um
objeto do tipo tabela, na Workspace.
read.table(arquivo) : leˆ tabela de um arquivo texto externo (semelhante ao
read.csv2).
2 ARITME´TICA E LO´GICA
A aritme´tica, segundo a enciclope´dia Wikipe´dia1, e´ o ramo da matema´tica que lida com nu´meros e
com as operac¸o˜es poss´ıveis entre eles. As operac¸o˜es aritme´ticas tradicionais sa˜o a adic¸a˜o, a subtrac¸a˜o,
a multiplicac¸a˜o e a divisa˜o, embora operac¸o˜es mais avanc¸adas (tais como as manipulac¸o˜es de porcen-
tagens, raiz quadrada, exponenciac¸a˜o e func¸o˜es logar´ıtmicas) tambe´m sejam por vezes inclu´ıdas neste
ramo. A aritme´tica desenrola-se em obedieˆncia a uma ordem de operac¸o˜es. Abrange o estudo de
algoritmos (passos) para a realizac¸a˜o de operac¸o˜es com os nu´meros naturais, inteiros, racionais e reais
que podem ser realizadas manualmente ou com o uso de ferramentas como calculadoras, computadores
e a´baco.
A lo´gica matema´tica consiste no estudo matema´tico da lo´gica e na aplicac¸a˜o deste estudo a outras
a´reas da matema´tica. A lo´gica matema´tica guarda estritas conexo˜es com a cieˆncia da computac¸a˜o. Foi
tambe´m chamada de lo´gica simbo´lica. Inclui a lo´gica cla´ssica (de Aristo´teles), mas com uma notac¸a˜o
diferente, mais abstrata, tomada da a´lgebra. Tradicionalmente dividida em Teoria dos Conjuntos,
Teoria dos Modelos, Teoria da Prova e Teoria da Recursa˜o, inclui as partes da lo´gica que podem ser
modeladas e estudadas matematicamente. Os principais operadores utilizados sa˜o E, OU e NA˜O e
suas combinac¸o˜es
2.1 Operadores aritme´ticos
+ − ∗ \ } : soma, subtrac¸a˜o, produto e divisa˜o
%/% %% : parte inteira da divisa˜o, parte fraciona´ria da divisa˜o
%*% : produto interno de vetores (ou matrizes)
sqrt( ) : raiz quadrada
abs( ) : valor absoluto (positivo)
sin( ) cos( ) tan( ) : func¸o˜es trigonome´tricasasin( ) acos( ) atan( ) : func¸o˜es trigonome´tricas inversas
sinh( ) cosh( ) tanh( ) : func¸o˜es hiperbo´licas
asinh( ) acosh( ) atanh( ) : func¸o˜es hiperbo´licas inversas
exp( ) log( ) : exponencial e logar´ıtmo natural
log10( ) : logar´ıtimo base-10
2.2 Operadores lo´gicos
< : menor do que
<= : menor ou igual
> : maior do que
>= : maior ou igual a
== : igual a
! = : nao igual a (diferente de)
c1&c2 : intersec¸a˜o (E) - Elementos de c1 e c2
c1|c2 : unia˜o (OU) - Elementos de c1 ou c2
!c1 : negac¸a˜o de c1
Sendo c1 e c2 expresso˜es lo´gicas.
2.3 Arredondamento (aproximac¸o˜es) de nu´meros
(i) round(x,digits=0) : Arredonda o nu´mero x com o nu´mero de casas decimais definidas por digits.
x : e´ um vetor de nu´meros.
digits : um nu´mero inteiro indicando um nu´mero de casas decimais
apo´s o arredondamento.
Exemplo: Consideremos o nu´mero 1,901945 arredondado para 4, 3 e 2 casas decimais.
> round(1.901945, digits = 4)
[1] 1.9019
> round(1.901945, digits = 3)
[1] 1.902
> round(1.901945, digits = 2)
[1] 1.9
(ii) signif(x,digits=6) : Arredonda o nu´mero x com o nu´mero de d´ıgitos significativos definidos por
digits.
Os algarismos significativos de um nu´mero sa˜o os d´ıgitos diferentes de zero, contados a partir da
esquerda, ate´ o u´ltimo d´ıgito diferente de zero mais a` direita, caso na˜o haja v´ırgula (separador
decimal), ou ate´ o u´ltimo d´ıgito (zero ou na˜o) caso haja uma v´ırgula (separador decimal). Todos
os d´ıgitos diferentes de zero sa˜o significativos. Assim, teremos:
• o nu´mero 3200 ou 3, 2e3 possui 2 algarismos significativos;
• o nu´mero 3200, ou 3, 200e3 possui 4 algarismos significativos;
• o nu´mero 3200, 0 ou 3, 2000e3 possui 5 algarismos significativos;
• o nu´mero 32.050 ou 3, 205e4 possui 4 algarismos significativos;
• o nu´mero 0, 032 ou 3, 2e−2 possui 2 algarismos significativos;
• o nu´mero 0, 03200 ou 3, 200e−2 possui 4 algarismos significativos.
Exemplo: Consideremos o nu´mero 1,9011947 ajustado para 4, 3 e 2 d´ıgitos significativos.
> signif(1.9011947, digits = 4)
[1] 1.901
> signif(1.9011947, digits = 3)
[1] 1.9
> signif(1.9011947, digits = 2)
[1] 1.9
(iii) floor(x) : Extrai o maior nu´mero inteiro abaixo (menor) do nu´mero x.
Exemplo:
> floor(0.9556)
[1] 0
> floor(-2.5278)
[1] -3
> floor(2.5278)
[1] 2
(iv) ceiling(x) : Extrai o menor nu´mero inteiro acima (maior) do nu´mero x.
> ceiling(0.9556)
[1] 1
> ceiling(-2.5278)
[1] -2
> ceiling(2.5278)
[1] 3
(v) trunc(x) : Extrai a parte inteira do nu´mero (sem arredondamento).
Exemplo
> trunc(0.9897)
[1] 0
> trunc(2.0103)
[1] 2
> trunc(-5.5)
[1] -5
(vi) format(x, digits= ,nsmall= )
3 VETORES
Um vetor e´ uma sequeˆncia nume´rica finita de valores (inteiros, reais, complexo) que teˆm em comum
um nome para refereˆncias. O nu´mero de elementos da sequeˆncia e´ chamada de dimensa˜o deste vetor.
No ambiente do R, todo nu´mero isolado e´ definido como um vetor que conte´m somente um elemento.
E´ um conceito diferente de vetor unita´rio e de mo´dulo pois o valor em questa˜o ira´ conservar todas
das propriedades dos conceitos definidos pela a´lgebra linear. um vetor e´ formado na workspace, pela
concatenac¸a˜o de seus valores. O comando utilizado para isso e´ c(x1, x2, · · · , xn) onde (x1, x2, · · · , xn)
e´ a segueˆncia de seus elementos. Como exemplo, formaremos o vetor chamado idade cotendo as idades
de 10 indivd´uos tomados ao acaso. Sejam elas 21, 19, 28, 21, 23, 18, 34, 32, 18 e 21.
> idade <- c(21, 19, 28, 21, 23, 18, 34, 32, 18, 21)
Assim, o objeto idade conte´m o valor 21 na primeira posic¸a˜o, o valor 19 na segunda, o valor 28 na
terceira e assim por diante.
Diremos que um vetor e´ uma estrutura atomica quando seus elementos forem todos do mesmo tipo.
Se os elementos na˜o forem do mesmo tipo diremos que o objeto se trata de uma lista. Segundo o tipo
os elementos de um vetor podem ser do tipo:
• inteiros
• nume´ricos reais,
• nume´ricos complexo,
• lo´gico,
• carateres.
Para mais detalhes sobre vetores, consultar as seguintes pa´ginas:
a) Vetores gerais: http://www.leg.ufpr.br/Rtutorial/vectors.html
b) Aritme´tica de vetores: http://www.leg.ufpr.br/Rtutorial/vecarit.html
c) vetor de caracteres e fatores: http://www.leg.ufpr.br/Rtutorial/charfacs.html
d) Vetores lo´gicos: http://www.leg.ufpr.br/Rtutorial/logicals.html
e) Vetor de ı´ndices: http://www.leg.ufpr.br/Rtutorial/subscrip.html
3.1 Indexac¸a˜o, exclusa˜o e substituic¸a˜o de elementos do vetor
Podemos nos referir ao valor em cada posic¸a˜o do vetor por um indicador nume´rico entre colchetes, ao
lado do objeto, espeficicando a posic¸a˜o desejada. Por exemplo, o valor na sexta posic¸a˜o e´ obtido na
forma:
> idade[6]
[1] 18
Para excluir o valor de uma determinada posic¸a˜o de um vetor (um elemento), basta acrescentar o
sinal de menos (−) antes do nu´mero indicador de sua posic¸a˜o. Entretanto, a exclusa˜o so´ se faz na
apresentac¸a˜o na tela; o vetor continua tendo os mesmos elementos originais. A operac¸a˜o significa algo
como: “mostre todos os elementos do vetor, exceto o elemento da posic¸a˜o p”.
Exemplo:
> idade
[1] 21 19 28 21 23 18 34 32 18 21
> (idade[-6])
[1] 21 19 28 21 23 34 32 18 21
> idade
[1] 21 19 28 21 23 18 34 32 18 21
Para substituir o valor de uma determinada posic¸a˜o de um vetor (um elemento), basta atribuir a ele
o novo valor. Entretanto, a substituic¸a˜o na˜o acontece so´ na apresentac¸a˜o na tela; o vetor fica alterado
“definitivamente”.
Exemplo:
> idade
[1] 21 19 28 21 23 18 34 32 18 21
> idade[6] <- 55
> idade
[1] 21 19 28 21 23 55 34 32 18 21
Exerc´ıcios:
a) Extrair os dois ultimos valores de idades codificadas A043 A074 A022 A060 A037 A029 A043 A077
A020 A050 A086.
> ANO = c("A043", "A074", "A022", "A060", "A037", "A029", "A043",
+ "A077", "A020", "A050", "A086")
> as.numeric(substr(ANO, 3, 4))
[1] 43 74 22 60 37 29 43 77 20 50 86
b) Extraindo o primeiro nome dos indiv´ıduos: Ana Carolina Silva, Jose´ Antonio Amaral e Maria Jose´
Oliveira.
> nomes <- c("Ana Carolina Silva", "Jose Antonio Amaral", "Maria Jose Oliveira")
> gsub("(\\w)\\s.*", "\\1", nomes)
[1] "Ana" "Jose" "Maria"
c) Extrair o numeral da decada dos 10 anos obtidos de uma amostra de anos entre os anos 1900 e
1999.
> (ANO = sample(1900:1999, 10, rep = TRUE))
[1] 1918 1915 1986 1981 1979 1909 1921 1933 1989 1984
> as.numeric(substr(as.character(ANO), 3, 4))
[1] 18 15 86 81 79 9 21 33 89 84
3.2 Ordenac¸a˜o de elementos
As principais operac¸o˜es de ordem dos elementos de um vetor sa˜o:
sort(x ) : ordena os elementos do vetor em ordem crescente
sort( x, decreasing=TRUE) : ordena os elementos do vetor em ordem decrescente
rev(x) : inverte a ordem dos elementos do vetor.
order(x) : da´ posic¸a˜o que o valor ordenado ocupa no vetor original.
rank(x ) : posic¸a˜o (posto) de ordem de cada elemento do vetor
Exemplo: seja o vetor idade contendo dos elementos 80, 61, 70, 64, 65, 68, 65.
> idade <- c(80, 61, 70, 64, 65, 68, 65)
a) Idades ordenadas em ordem crescente:
> sort(idade)
[1] 61 64 65 65 68 70 80
b) Idades ordenadas em ordem decrescente:
> sort(idade, decreasing = TRUE)
[1] 80 70 68 65 65 64 61
c) Vetor em ordem reversa (do u´ltimo para o primeiro)
> rev(idade)
[1] 65 68 65 64 70 61 80
d) Posic¸a˜o que cada indiv´ıduo ocupa no vetor ordenado
> order(idade)
[1] 2 4 5 7 6 3 1
e) Posto (ordem) de cada indiv´ıduo
> rank(idade)
[1] 7.0 1.0 6.0 2.0 3.5 5.0 3.5
f) O valor do elemento da sexta posic¸a˜o na se´rie ordenada e´:
> idade[rank(idade) == 6]
[1] 70
g) A posic¸a˜o do valor 70 no vetor ordenado e´:
> rank(idade)[idade == 70]
[1] 6
3.3 Inspecionando (pesquisando) elementos de um vetor
min(· · · ) : Retorna o valor mı´nimo entre os elementos de um vetor
pmin(· · · ) : Para um conjunto de vetores nume´ricos de mesmo comprimento, retorna um
novo vetor onde o seu primeiro elemento e´ a valor mı´nimo entre os primeiros
elementos do conjunto de vetores analisado, o segundo elemento e´ o valor
mı´nimo entre os segundos elementos do mesmo conjunto,e assim por diante.
max(· · · ) : Retorna o valor ma´ximo entre os elementos de um vetor
pmax(· · · ) : Para um conjunto de vetores nume´ricos de mesmo comprimento, retorna um
novo vetor onde o seu primeiro elemento e´ a valor ma´ximo entre os primeiros
elementos do conjunto de vetores analisado, o segundo elemento e´ o valor
ma´ximo entre os segundos elementos do mesmo conjunto, e assim por diante.
which(x, criterio) : Da´ a posic¸a˜o, no vetor original x, cujo valor atenda a um crite´rio lo´gico.
which.max(x) : Da´ a posic¸a˜o do valor ma´ximo no vetor original x.
which.min(x) : Da´ a posic¸a˜o do valor mı´nimo no vetor original x.
length(x) : Da´ o comprimento (nu´mero de elementos) do vetor x.
Exemplo: Sejam os vetores v1 = (1, 0, 4, 3, 3, 2), v2 = (4, 6, 7, 3, 0, 1), v3 = (6, 6, 2, 8, 4, 5)
> v1 = c(1, 0, 4, 3, 3, 2)
> v2 = c(4, 6, 7, 3, 0, 1)
> v3 = c(6, 6, 2, 8, 4, 5)
> v4 <- c(80, 61, 70, 64, 65, 81, 65)
a) O valor mı´nimo do vetor v1 sera´:
> min(v1)
[1] 0
b) O valor ma´ximo do vetor v3 sera´:
> max(v3)
[1] 8
c) O vetor de mı´nimos e de ma´ximos entre os vetores v1, v2, v3 e´:
> pmin(v1, v2, v3)
[1] 1 0 2 3 0 1
> pmax(v1, v2, v3)
[1] 6 6 7 8 4 5
d) A posic¸a˜o do valor 70 no vetor v4 e´:
> which(v4 == 70)
[1] 3
e) A posic¸a˜o dos valores maiores ou iguais a 70 no vetor v4 e´:
> which(v4 >= 70)
[1] 1 3 6
f) As posic¸o˜es dos valores ma´ximo e mı´nimo no vetor v4 sa˜o:
> which.min(v4)
[1] 2
> which.max(v4)
[1] 6
g) Extraindo um subconjunto de elementos de um vetor
> v5 = c(0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1)
> v5[v5 > 0.3]
[1] 0.4 0.5 0.6 0.7 0.8 0.9 1.0
h) Identificando valores que atendem uma condic¸a˜o
> v5 > 0.5
[1] FALSE FALSE FALSE FALSE FALSE FALSE TRUE TRUE TRUE TRUE TRUE
> v5 == 0.5
[1] FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE
> v5 != 0.5
[1] TRUE TRUE TRUE TRUE TRUE FALSE TRUE TRUE TRUE TRUE TRUE
i) Contando elementos de um vetor
(i) comprimento ou quantidade de elementos;
> length(v5)
[1] 11
(ii) quantidade de valores maiores que 0,30
> length(v5[v5 > 0.3])
[1] 7
(iii) quantidade de valores maiores ou iguais que 0,30
> length(v5[v5 >= 0.3])
[1] 8
(iv) quantidade de valores maiores que 0,35
> length(v5[v5 > 0.35])
[1] 7
(v) quantidade de valores iguais a 0,35
> length(v5[v5 == 0.35])
[1] 0
(vi) quantidade de valores iguais a 0,40
> length(v5[v5 == 0.4])
[1] 1
(vii) quantidade de valores diferentes de 0,40
> length(v5[v5 != 0.4])
[1] 10
j) Aumentando um vetor
> (v5 = c(v5, v5[v5 > 0.75]))
[1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0 0.8 0.9 1.0
3.4 Operac¸o˜es aritme´ticas com vetores
a) Todas as operac¸o˜es aritme´ticas sa˜o aplicadas a todos os elementos do vetor. Somar ou subtrair
dois (ou mais) vetores significa somar ou subtrair membro a membro. Se X = (x1, x2, · · · , xn) e
Y = (y1, y2, · · · , yn) sa˜o dois vetores de tamanho n, enta˜o:
X + Y = (x1 + y1, x2 + y2, · · · , xn + yn)
Exemplo:
> v1 + v2 + v3
[1] 11 12 13 14 7 8
b) Ao multiplicar um vetor por uma constante, todos seus elementos ficam multiplicados por essa
constante. Multiplicar dois (ou mais)vetores de mesmo comprimento significa multiplicar membro
a membro. Enta˜o:
X ∗ Y = (x1 ∗ y1, x2 ∗ y2, · · · , xn ∗ yn)
,
Exemplo
> v1 * v2 * v3
[1] 24 0 56 72 0 10
c) O produto interno de dois vetores e´ definido como: X% ∗%Y = (x1 ∗ y1 + x2 ∗ y2+, · · · ,+xn ∗ yn)
e representa um escalar. Por exemplo:
> v1 %*% v2
[,1]
[1,] 43
d) Ao dividir um vetor por uma constante, todos seus elementos ficam multiplicados por essa cons-
tante. Dividir dois (ou mais)vetores de mesmo comprimento significa dividir membro a membro.
Enta˜o:
X
Y
= (
x1
y1
,
x2
y2
, · · · , xn
yn
)
Exemplo
> v1/pi
[1] 0.3183099 0.0000000 1.2732395 0.9549297 0.9549297 0.6366198
> v1/v3
[1] 0.1666667 0.0000000 2.0000000 0.3750000 0.7500000 0.4000000
e) A parte inteira da divisa˜o e o resto da divisa˜o de um vetor por um nu´mero resulta um vetor com o
resultado de cada elemento submetido a´ operac¸a˜o. A parte inteira da divisa˜o e o resto da divisa˜o
de um vetor por outro vetor de mesmo comprimento resulta um vetor com o resultado da operac¸a˜o
elemento a elemento.
Exemplo
> c(2.35, 1.45, 7.11)/5
[1] 0.470 0.290 1.422
> c(2.35, 1.45, 7.11)%/%5
[1] 0 0 1
> c(2.35, 1.45, 7.11)%%2
[1] 0.35 1.45 1.11
Notar que quando um valor na˜o e´ divisivel por outro, o R retorna o pro´prio valor.
f) Escrevendo uma equac¸a˜o com vetores aninhados
> (v2.calc <- sin(v1 <- 1:6) + cos(v2) - pi * (v2/v1))
[1] -12.37854325 -7.55531025 -6.43536060 -4.10298948 0.04107573
[6] -0.26271197
3.5 Criando sequeˆncias
Define-se uma sequeˆncia finita a1, a2, · · · , an como sendo um conjunto S, dotado das seguintes carac-
ter´ısticas:
a) Todos os seus elementos sa˜o do mesmo tipo;
b) Os elementos sa˜o denominados termos da sequeˆncia;
c) Cada termo possui uma posic¸a˜o definida, dentro do conjunto;
d) A posic¸a˜o de cada termo e´ determinada por um nu´mero natural, denominado ı´ndice;
e) Cada termo possui um u´nico ı´ndice, e cada ı´ndice pertence a um u´nico termo (correspondeˆncia
biun´ıvoca);
f) Dois termos so´ podem ser permutados se os seus respectivos ı´ndices tambe´m forem.
No caso de uma segueˆncia nume´rica, a ordem dos elementos e´ determinada por uma lei ou uma func¸a˜o
cujo domı´nio e´ o conjunto dos nu´meros naturais.
Exemplo:
• A sequeˆncia dos quatro primeiros nu´meros naturais mu´ltiplos de 5 e´ (0, 5, 10, 15):
• A sequeˆncia dos nu´meros de dias dos 12 meses de um ano bissexto e´ (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
Os principais comandos utilizados para se produzir sequeˆncias sa˜o:
a : b : produz uma sequeˆncia que comec¸a em a e termina em b, com incrementos
unita´rios.
seq(from,to, by) : produz uma sequeˆncia que inicia em from, termina em to com incrementos
de by.
rep(x,times) : repete o elemento x o nu´mero de vezes definido por times.
rep(x,each) : Se x e´ um vetor, o comando repete cada elemento o nu´mero de vezes definido
por each
rep(x,len) : O comando repete uma sequeˆncia ate´ atingir o nu´mero de elementos definido
por len
Exemplo:
a) Sequeˆncia iniciiando em 0 e terminando em 10 com incrementos unita´rios.
> 0:10
[1] 0 1 2 3 4 5 6 7 8 9 10
b) Sequeˆncia iniciando em 30 e terminando em 20 com incremento decrescente unita´rio
> 30:20
[1] 30 29 28 27 26 25 24 23 22 21 20
c) Sequeˆncias com repetic¸a˜o de valores utilizando a func¸a˜o rep()
(i) Repetindo duas vezes a sequeˆncia de inteiros de 1 a 4.
> rep(1:4, times = 2)
[1] 1 2 3 4 1 2 3 4
(ii) Repetindo a sequeˆncia de inteiros de 1 a 4 duas vezes cada nu´mero.
> rep(1:4, each = 2)
[1] 1 1 2 2 3 3 4 4
(iii) Repetindo a sequeˆncia de inteiros de 1 a 4 ate´ completar 7 elementos.
> rep(1:4, len = 7)
[1] 1 2 3 4 1 2 3
(iv) Repetindo a sequeˆncia de inteiros de 1 a 4 duas vezes cada nu´mero, ate´ completar 5 elementos.
> rep(1:4, each = 2, len = 5)
[1] 1 1 2 2 3
(v) Repetindo a sequeˆncia de inteiros de 1 a 4 duas vezes cada nu´mero, ate´ completar 10 elementos
(com reciclagem).
> rep(1:4, each = 2, len = 10)
[1] 1 1 2 2 3 3 4 4 1 1
(vi) Repetindo duas vezes a sequeˆncia de inteiros de 1 a 4 duas vezes cada nu´mero.
> rep(1:4, each = 2, times = 2)
[1] 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4
(vii) Repetindo uma sequeˆncia que inicia e 20, termina em 45, em intervalos de 5, treˆs vezes cada
nu´mero.
> rep(seq(20, 45, 5), each = 3)
[1] 20 20 20 25 25 25 30 30 30 35 35 35 40 40 40 45 45 45
3.6 Vetores alfa-nume´ricos
Um vetor e´ dito alfa-nume´rico quando os nu´meros sa˜ao tomados como caracteres nume´ricos e na˜o sera´
poss´ıvel operac¸o˜es matema´ticas com eles.
> (vetor.char <- c(0:10, "a"))
[1] "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" "a"
> class(vetor.char[-12])
[1] "character"
> is.numeric(vetor.char)
[1] FALSE
3.7 Lei da Reciclagem
Sob certas circunstaˆncias o R retorna ao in´ıcio de uma sequeˆncia (vetor) em busca de novos dados para
completar uma tarefa. Essas sequeˆncias devem ser mu´ltiplas uma daoutra que se pretende alimentar.
x1 x2 x3 x4
.
..................
...............
............
........... ......... ......... ...........
...........
.
..........
.....
.........
.........•. ..................
...............
............
........... ......... ......... ...........
...........
.
..........
.....
.........
.........•. ..................
...............
............
........... ......... ......... ...........
...........
.
..........
.....
.........
.........•
.
.............................
...........................
.........................
.......................
.....................
................... ................. ................ ................ ................
...........
.....
..........
........
.........
.........
...
.........
.........
......
.........
.........
.........
.........
.........
.........
...
•
- x1 x2 x3 x4
rec.
?
x1x2 x3x4
Figura 2: Lei da reciclagem na construc¸a˜o de sequeˆncias
Suponha que desejamos somar a sequeˆncia de nu´meros de 1 a dez com a sequeˆncia de nu´meros de 1 a
2. Assim, ter´ıamos como resultado:
1 + 1 = 2
2 + 2 = 4
3 + 1 = 4
4 + 2 = 6
5 + 1 = 6
6 + 2 = 8
7 + 1 = 8
8 + 2 = 10
9 + 1 = 10
10 + 2 = 12
Como funciona isso! O R toma o primeiro valor da primeira sequeˆncia e soma com o primeiro valor da
segunda. Depois toma o segundo valor da primeira sequeˆncia e soma com o segundo valor da segunda.
RECICLA a segunda sequeˆncia. Toma o terceiro valor da primeira sequeˆncia e soma com o primeiro
valor da segunda sequeˆncia, toma o quarto valor da primeira sequeˆncia e soma com o segundo valor
da segunda sequeˆncia. RECICLA a segunda sequeˆncia e assim por diante.
1 + 1 = 2
2 + 2 = 4 Recila a segunda sequeˆncia
3 + 1 = 4
4 + 2 = 6 Recila a segunda sequeˆncia
5 + 1 = 6
6 + 2 = 8 Recila a segunda sequeˆncia
7 + 1 = 8
8 + 2 = 10 Recila a segunda sequeˆncia
9 + 1 = 10
10 + 2 = 12 Encerra as duas sequeˆncias
Com o R far´ıamos assim:
> (X = 1:10)
[1] 1 2 3 4 5 6 7 8 9 10
> (Y = c(1, 2))
[1] 1 2
> (X + Y)
[1] 2 4 4 6 6 8 8 10 10 12
Exemplos: Sejam as sequeˆncias que sa˜o mu´ltiplas uma da outra
> X + 1:5
[1] 2 4 6 8 10 7 9 11 13 15
> (1:2) * X
[1] 1 4 3 8 5 12 7 16 9 20
> X/(1:5)
[1] 1.000000 1.000000 1.000000 1.000000 1.000000 6.000000 3.500000 2.666667
[9] 2.250000 2.000000
> X^(1:2)
[1] 1 4 3 16 5 36 7 64 9 100
3.8 Aplicando func¸o˜es a vetores
Na estats´tica um VETOR de comprimento n conte´m n informac¸o˜es de uma u´nica varia´vel (ou uma
u´nica observac¸a˜o de n varia´veis). A aplicac¸a˜o de uma func¸a˜o em um vetor faz com que cada elemento
do domı´nio (conjunto de valores registrados da varia´vel) seja “transformado” pela func¸a˜o.
Exemplo:
> Y <- c(24.1, 19.3, 19.5, 21, 22.5, 22.9, 17.6, 22.8, 20.2, 18,
+ 19.8, 18.6, 20, 24.3, 19.1, 21.1, 22.1, 22.8, 22.6, 23.1,
+ 18.6, 19.5, 16, 20.9, 20.9, 16.1, 18.1, 23.3, 22.6, 23.6,
+ 24.1, 15.4, 20.1, 17.2, 19, 17.7, 19.1, 22.6, 19.6, 21.7,
+ 19.3, 19.9, 21.3, 19, 18.5, 19.3, 18.4, 18.7, 20.7, 20.8,
+ 18.4, 20.2, 19.5)
> sqrt(Y)
[1] 4.909175 4.393177 4.415880 4.582576 4.743416 4.785394 4.195235 4.774935
[9] 4.494441 4.242641 4.449719 4.312772 4.472136 4.929503 4.370355 4.593474
[17] 4.701064 4.774935 4.753946 4.806246 4.312772 4.415880 4.000000 4.571652
[25] 4.571652 4.012481 4.254409 4.827007 4.753946 4.857983 4.909175 3.924283
[33] 4.483302 4.147288 4.358899 4.207137 4.370355 4.753946 4.427189 4.658326
[41] 4.393177 4.460942 4.615192 4.358899 4.301163 4.393177 4.289522 4.324350
[49] 4.549725 4.560702 4.289522 4.494441 4.415880
> sum(Y)
[1] 1071.5
> sin(Y)
[1] -0.8587070 0.4353654 0.6055399 0.8366556 -0.4871745 -0.7887983
[7] -0.9488445 -0.7234948 0.9758205 -0.7509872 0.8136737 -0.2469737
[13] 0.9129453 -0.7397786 0.2478342 0.7777942 -0.1086366 -0.7234948
[19] -0.5719257 -0.8951874 -0.2469737 0.6055399 -0.2879033 0.8871575
[25] 0.8871575 -0.3820714 -0.6813138 -0.9658882 -0.5719257 -0.9992760
[31] -0.8587070 0.3031184 0.9491246 -0.9969001 0.1498772 -0.9125824
[37] 0.2478342 -0.5719257 0.6819636 0.2870527 0.4353654 0.8676441
[43] 0.6374226 0.1498772 -0.3424806 0.4353654 -0.4345656 -0.1489990
[49] 0.9611527 0.9287952 -0.4345656 0.9758205 0.6055399
> log(Y)
[1] 3.182212 2.960105 2.970414 3.044522 3.113515 3.131137 2.867899 3.126761
[9] 3.005683 2.890372 2.985682 2.923162 2.995732 3.190476 2.949688 3.049273
[17] 3.095578 3.126761 3.117950 3.139833 2.923162 2.970414 2.772589 3.039749
[25] 3.039749 2.778819 2.895912 3.148453 3.117950 3.161247 3.182212 2.734368
[33] 3.000720 2.844909 2.944439 2.873565 2.949688 3.117950 2.975530 3.077312
[41] 2.960105 2.990720 3.058707 2.944439 2.917771 2.960105 2.912351 2.928524
[49] 3.030134 3.034953 2.912351 3.005683 2.970414
> log2(Y)
[1] 4.590961 4.270529 4.285402 4.392317 4.491853 4.517276 4.137504 4.510962
[9] 4.336283 4.169925 4.307429 4.217231 4.321928 4.602884 4.255501 4.399171
[17] 4.465974 4.510962 4.498251 4.529821 4.217231 4.285402 4.000000 4.385431
[25] 4.385431 4.008989 4.177918 4.542258 4.498251 4.560715 4.590961 3.944858
[33] 4.329124 4.104337 4.247928 4.145677 4.255501 4.498251 4.292782 4.439623
[41] 4.270529 4.314697 4.412782 4.247928 4.209453 4.270529 4.201634 4.224966
[49] 4.371559 4.378512 4.201634 4.336283 4.285402
3.9 Tipos especiais de vetores
a) Vetores de caracteres
> nomes <- c("Marta", "Regina", "Mario", "Pedro", "Mauricio", "Marcelo",
+ "Patricia", "Cintia", "Abigail", "Renato")
> nomes
[1] "Marta" "Regina" "Mario" "Pedro" "Mauricio" "Marcelo"
[7] "Patricia" "Cintia" "Abigail" "Renato"
> letters
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
[20] "t" "u" "v" "w" "x" "y" "z"
> LETTERS
[1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
[20] "T" "U" "V" "W" "X" "Y" "Z"
> (let5 <- letters[1:5])
[1] "a" "b" "c" "d" "e"
> (let10 <- LETTERS[11:20])
[1] "K" "L" "M" "N" "O" "P" "Q" "R" "S" "T"
b) Vetores de datas
> format(ISOdate(2000, 1:12, 1), "%B")
[1] "janeiro" "fevereiro" "marc¸o" "abril" "maio" "junho"
[7] "julho" "agosto" "setembro" "outubro" "novembro" "dezembro"
> mes.curto <- format(ISOdate(2008, 1:12, 1), "%b")
> mes.curto
[1] "Jan" "Fev" "Mar" "Abr" "Mai" "Jun" "Jul" "Ago" "Set" "Out" "Nov" "Dez"
c) Vetor combinado
paste(a,b): junta os dados do vetor “a” com dados do vetor “b”, caso a caso (com possibilidade de
reciclagem)
> nomes
[1] "Marta" "Regina" "Mario" "Pedro" "Mauricio" "Marcelo"
[7] "Patricia" "Cintia" "Abigail" "Renato"
> paste(nomes, 10:1)
[1] "Marta 10" "Regina 9" "Mario 8" "Pedro 7" "Mauricio 6"
[6] "Marcelo 5" "Patricia 4" "Cintia 3" "Abigail 2" "Renato 1"
> paste("Mario", "Casado", sep = " - ")
[1] "Mario - Casado"
> paste("Mario", 5, sep = "")
[1] "Mario5"
> paste(5, "Mario", sep = ") ")
[1] "5) Mario"
> paste(1:10, nomes, sep = ") ")
[1] "1) Marta" "2) Regina" "3) Mario" "4) Pedro" "5) Mauricio"
[6] "6) Marcelo" "7) Patricia" "8) Cintia" "9) Abigail" "10) Renato"
> paste(letters[1:6], 1:9, sep = "")
[1] "a1" "b2" "c3" "d4" "e5" "f6" "a7" "b8" "c9"
> rep(paste("T", 1:3, sep = ""), c(4, 4, 3))
[1] "T1" "T1" "T1" "T1" "T2" "T2" "T2" "T2" "T3" "T3" "T3"
3.10 Operac¸o˜es lo´gicas em um vetor
Aplicando mudanc¸as seletivas em elementos de um vetor com o comando IF ELSE.
Exemplo: Considerando o vetor de 20 idades de indiv´ıduos com ate´ 30 anos (inclusive).
> (idade = sample(1:30, 20, replace = TRUE))
[1] 29 20 2 21 27 18 23 29 12 19 14 23 25 27 12 14 25 23 2 5
a) Atribuir 1 para os indiv´ıduos entre 1 e 10 anos e zero para os demais. Somar o resultado. O que
significa o resultado dessa soma?
> (idade.jovem = ifelse(idade >= 1 & idade <= 10, 1, 0))
[1] 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
> sum(idade.jovem)
[1] 3
b) Atribuir 1 para os indiv´ıduos entre 1 e 10 anos, 2 para os indiv´ıduos entre 11 e 20 anos e 3 para os
indiv´ıduos entre 21 e 30 anos.
> ifelse(idade >= 1 & idade <= 10, 1, ifelse(idade >= 11 & idade <=
+ 20, 2, 3))
[1] 3 2 1 3 3 2 3 3 2 2 2 3 3 3 2 2 3 3 1 1
4 FATORES
Um objetodo tipo Fator e´ um objeto diferente de um vetor. Fator e´ um tipo de varia´vel indicadora.
Para uso com os conceitos de estat´ıstica, um vetor registra as observac¸o˜es de varia´veis e um fator
registra o tipo da observac¸a˜o
Exemplos:
a) Considere uma varia´vel onde cada observac¸a˜o esteja associada a um dentre treˆs tipos de tratamentos
poss´ıveis.
> factor(rep(paste("T", 1:3, sep = ""), c(4, 4, 3)))
[1] T1 T1 T1 T1 T2 T2 T2 T2 T3 T3 T3
Levels: T1 T2 T3
b) Conasidere um vetor contendo os Estados do Brasil (26 Estados + Distrito Federal)
> rm(list = ls())
> EstadosBrasil = c("AC", "AL", "AP", "AM", "BA", "CE", "DF", "ES",
+ "GO", "MA", "MT", "MS", "MG", "PA", "PB", "PR", "PE", "PI",
+ "RN", "RS", "RJ", "RO", "RR", "SC", "SP", "SE", "TO")
Gerando uma amostra dos Estados, de tamanho 50.
> set.seed(56)
> (estados.amostra = sample(EstadosBrasil, 50, replace = TRUE))
[1] "MT" "RS" "GO" "RS" "MA" "AP" "CE" "BA" "RS" "PA" "SE" "MG" "RN" "SC" "PE"
[16] "MG" "RJ" "RJ" "PA" "BA" "MT" "MA" "RN" "CE" "PA" "RO" "BA" "AP" "AM" "GO"
[31] "GO" "RR" "RS" "MT" "PE" "MS" "RR" "SP" "RJ" "BA" "RJ" "TO" "SP" "GO" "PB"
[46] "RN" "RJ" "SC" "RS" "PI"
Note que a amostra na˜o tem o Estado PR.
Vamos agora converter o vetor amostra de Estados em fator. Os n´ıveis sera˜o baseados no objeto
fonte da amostra.
> (estados.amostra.fator <- factor(estados.amostra, levels = EstadosBrasil))
[1] MT RS GO RS MA AP CE BA RS PA SE MG RN SC PE MG RJ RJ PA BA MT MA RN CE PA
[26] RO BA AP AM GO GO RR RS MT PE MS RR SP RJ BA RJ TO SP GO PB RN RJ SC RS PI
27 Levels: AC AL AP AM BA CE DF ES GO MA MT MS MG PA PB PR PE PI RN RS ... TO
Note as diferenc¸as entre o tipo do objeto da amostra sem conversa˜o (estados.amostra) e objeto
convertido (estados.amostra.fator). Veja o efeito causado pelo comando table nos diferentes objetos.
> class(estados.amostra)
[1] "character"
> class(estados.amostra.fator)
[1] "factor"
> table(estados.amostra)
estados.amostra
AM AP BA CE GO MA MG MS MT PA PB PE PI RJ RN RO RR RS SC SE SP TO
1 2 4 2 4 2 2 1 3 3 1 2 1 5 3 1 2 5 2 1 2 1
> table(estados.amostra.fator)
estados.amostra.fator
AC AL AP AM BA CE DF ES GO MA MT MS MG PA PB PR PE PI RN RS RJ RO RR SC SP SE
0 0 2 1 4 2 0 0 4 2 3 1 2 3 1 0 2 1 3 5 5 1 2 2 2 1
TO
1
A exclusa˜o de um elemento do objeto fator na˜o exclui o atributo. No exemplo, o elemento na
posic¸a˜o 36 corresponde a MS (u´nica ocorreˆncia), entretanto, sua exclusa˜o na˜o elimina o n´ıvel
correspondente, continuando como n´ıvel poss´ıvel.
> (estados.amostra.fator.sel <- estados.amostra.fator[-36])
[1] MT RS GO RS MA AP CE BA RS PA SE MG RN SC PE MG RJ RJ PA BA MT MA RN CE PA
[26] RO BA AP AM GO GO RR RS MT PE RR SP RJ BA RJ TO SP GO PB RN RJ SC RS PI
27 Levels: AC AL AP AM BA CE DF ES GO MA MT MS MG PA PB PR PE PI RN RS ... TO
c) Extraindo os Estados da regia˜o Sul na amostra de estados.
> (est.sul.fator <- factor(estados.amostra, levels = c("PR", "SC",
+ "RS")))
[1] <NA> RS <NA> RS <NA> <NA> <NA> <NA> RS <NA> <NA> <NA> <NA> SC <NA>
[16] <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA>
[31] <NA> <NA> RS <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA> <NA>
[46] <NA> <NA> SC RS <NA>
Levels: PR SC RS
> table(est.sul.fator)
est.sul.fator
PR SC RS
0 2 5
d) Criando fatores com n´ıveis ordenados. Considere um vetor com observac¸o˜es classificadas em treˆs
n´ıveis: baixo, me´dio e alto. Note que existe uma ordenac¸a˜o natural entre as observac¸o˜es, entretanto
o R na˜o entende isto automaticamente. Precisamos orienta´-lo neste sentido. Sem essa orientac¸a˜o
teremos:
> (grau <- c("medio", "baixo", "medio", "medio", "baixo", "baixo",
+ "alto", "medio", "alto", "medio", "baixo"))
[1] "medio" "baixo" "medio" "medio" "baixo" "baixo" "alto" "medio" "alto"
[10] "medio" "baixo"
> factor(grau)
[1] medio baixo medio medio baixo baixo alto medio alto medio baixo
Levels: alto baixo medio
> table(factor(grau))
alto baixo medio
2 4 5
Considerando diretivas de orientac¸a˜o teremos:
> factor(grau, ord = T, levels = c("baixo", "medio", "alto"))
[1] medio baixo medio medio baixo baixo alto medio alto medio baixo
Levels: baixo < medio < alto
> table(factor(grau, ord = T, levels = c("baixo", "medio", "alto")))
baixo medio alto
4 5 2
e) Pode-se gerar um fator com o comando gl(n,k), onde n representa o nu´mero de n´ıveis e k o nu´mero
de repetic¸o˜es.
> gl(3, 5)
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3
Levels: 1 2 3
5 MATRIZES
Definimos aqui uma matriz qualquer tabela retangular (bidimensional) de objetos matema´ticos (nu´-
meros, func¸o˜es, vetores, etc) que pode ser operar em bloco, simultaneamente3. A notac¸a˜o do R e´:
matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE,
dimnames = NULL)
Onde data representa um vetor de dados.
Exemplos:
a) Construir uma matriz 4x3 a partir do vetor (1 2 3 4 5 6 7 8 9 10 11 12) preenchida por linhas
> (m1 <- matrix(1:12, ncol = 3, byrow = T))
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
[4,] 10 11 12
b) Construir uma matriz 4x3 a partir do vetor (1 2 3 4 5 6 7 8 9 10 11 12) preenchida por colunas
> (m2 <- matrix(1:12, ncol = 3, byrow = F))
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
3http://www.mat.ufrgs.br/ portosil/minmatr.html
Uma matriz tabe´m pode ser gerada com os comandos cbind( ) e rbind( ), pela combinac¸a˜o de vetores
coluna ou vetores linha, respectivamente de mesmo comprimento.
Exemplo:
> cbind(1:5, 6:10)
[,1] [,2]
[1,] 1 6
[2,] 2 7
[3,] 3 8
[4,] 4 9
[5,] 5 10
> cbind(1:5, 6)
[,1] [,2]
[1,] 1 6
[2,] 2 6
[3,] 3 6
[4,] 4 6
[5,] 5 6
> is.matrix(cbind(1:5, 6))
[1] TRUE
· · · um outro exemplo (notar o comando abreviado byrow == by)
> matrix(c(1, 5, 7, 4), 2, by = T)
[,1] [,2]
[1,] 1 5
[2,] 7 4
> (x <- cbind(x1 = 3, x2 = c(4:1, 2:5)))
x1 x2
[1,] 3 4
[2,] 3 3
[3,] 3 2
[4,] 3 1
[5,] 3 2
[6,] 3 3
[7,] 3 4
[8,] 3 5
5.1 Nomeando linhas e colunas da matriz
> dimnames(m1) <- list(c("L1", "L2", "L3", "L4"), c("C1", "C2",
+ "C3"))
> m1
C1 C2 C3
L1 1 2 3
L2 4 5 6
L3 7 8 9
L4 10 11 12
· · · ou
(m1.a <- matrix(1:12, ncol=3, byrow=T, dimnames = list(c(’L1’,’L2’,’L3’,’L4’), c(’C1’,’C2’,’C3’)))
m1.a
· · · e ainda, renomeando somente as linhas (primeira dimensa˜o) da matriz.
> (dimnames(x)[[1]] <- letters[1:8])
[1] "a" "b" "c" "d" "e" "f" "g" "h"
5.2 Inspecionando uma matriz
length(x) : indica o nm´eros de elementos da matriz
dim(x) : indica a dimensa˜o da matriz (linhas x colunas)
nrow(x) : indica o nu´mero de linhas da matriz
ncol(x) : indica o nu´mero de colunas da matriz
x[i,j] : indica o elemento no cruzamento da i−e´sima linha com a j−’esima coluna
x[,j] : indica todos os elementos da j−’esima coluna
x[i,] : indica todos os elementos da i−e´sima linha
x[a:b,c:d] : da´ a submatriz definida pelas linhas entre a e b e entre as colunas c e d.
diag(n) : gera uma matriz identidade de ordem n (n x n
dimnames(x)[[1]] : renomeia somente as linhas (primeira dimensa˜o) da matriz x
dimnames(x)[[2]] : renomeia somente as colunas (segunda dimensa˜o) da matriz x
5.3 Operac¸o˜es ba´sicas com matrizes
t( ) : transposta da matriz
%*% : produto interno
solve : soluc¸a˜o de sistemas quadra´ticos (inversa)
Exemplos:
> (m4 <- matrix(1:6, nc = 3))
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
> (m5 <- matrix(10 * (1:6), nc = 3))
[,1] [,2] [,3]
[1,] 10 30 50
[2,] 20 40 60
> m4 + m5
[,1] [,2] [,3]
[1,] 11 33 55
[2,] 22 44 66
> m4 * m5
[,1] [,2] [,3]
[1,] 10 90 250
[2,] 40 160 360
> m5 - m4
[,1] [,2] [,3]
[1,] 9 27 45
[2,] 18 36 54
> m5/m4
[,1] [,2] [,3]
[1,] 10 10 10
[2,] 10 10 10
> t(m4)
[,1] [,2]
[1,] 1 2
[2,] 3 4
[3,] 5 6
> dim(m4)
[1] 2 3
> dim(t(m4))
[1] 3 2
> dim(m5)
[1] 2 3
> m6 <- t(m4) %*% m5
> m6
[,1] [,2] [,3]
[1,] 50 110 170
[2,] 110 250 390
[3,] 170 390 610
> det(m6)
[1] -4.054396e-12
Consideremos o seguinte sistema de equac¸o˜es lineares (Ax = b)

x + 3y − z = 10
5x − 2y + z = 15
2x + y − z = 7
> (mat <- matrix(c(1, 5, 2, 3, -2, 1, -1, 1, -1), nc = 3))
[,1] [,2][,3]
[1,] 1 3 -1
[2,] 5 -2 1
[3,] 2 1 -1
> (vec <- c(10, 15, 7))
[1] 10 15 7
> solve(mat, vec)
[1] 3.615385 3.307692 3.538462
5.4 Aplicando func¸o˜es a` matrizes
O comando apply oferece uma maneira elegante de manipular vetores ou matrizes, aplicando-se suces-
sivamente uma func¸a˜o a cada linha (primeira dimensa˜o), cada coluna (segunda dimensa˜o ou a cada
n´ıvel em uma dimensa˜o superior a 2. A sintaxe do comando e´:
apply(X, n, FUN, ...)
onde X e´ a matris/vetor a ser utilizado, n e´ um valor que quando for igual a 1 indica que a func¸a˜o sera´
aplicada a`s linhas e quando for 2 a func¸a˜o sera´ aplicada a`s colunas. FUN e´ a func¸a˜o a ser aplicada.
No caso da func¸a˜o ser +, %*%, etc, esta deve ser colocada entre chaves.
Exemplo: Seja a seguinte matriz A:
A = (aij)7×5 =

5.7 5.7 4.4 5.7 4.7
7.0 5.6 5.0 4.9 5.2
3.6 4.8 4.7 5.0 5.9
2.9 5.6 2.3 4.8 4.2
3.1 4.1 5.1 4.2 3.4
5.2 5.9 6.2 6.5 7.1
3.4 5.5 4.8 5.9 5.1

a) Soma das colunas
> A = matrix(c(5.7, 5.7, 4.4, 5.7, 4.7, 7, 5.6, 5, 4.9, 5.2, 3.6,
+ 4.8, 4.7, 5, 5.9, 2.9, 5.6, 2.3, 4.8, 4.2, 3.1, 4.1, 5.1,
+ 4.2, 3.4, 5.2, 5.9, 6.2, 6.5, 7.1, 3.4, 5.5, 4.8, 5.9, 5.1),
+ 7, by = T)
> apply(A, 2, sum)
[1] 30.9 37.2 32.5 37.0 35.6
b) Me´dia das colunas
> apply(A, 2, mean)
[1] 4.414286 5.314286 4.642857 5.285714 5.085714
c) Me´dia das linhas
> apply(A, 1, mean)
[1] 5.24 5.54 4.80 3.96 3.98 6.18 4.94
d) Enfeitando a matriz
> col.sums <- apply(A, 2, sum)
> row.sums <- apply(A, 1, sum)
> rbind(cbind(A, Rtot = row.sums), Ctot = c(col.sums, sum(col.sums)))
Rtot
5.7 5.7 4.4 5.7 4.7 26.2
7.0 5.6 5.0 4.9 5.2 27.7
3.6 4.8 4.7 5.0 5.9 24.0
2.9 5.6 2.3 4.8 4.2 19.8
3.1 4.1 5.1 4.2 3.4 19.9
5.2 5.9 6.2 6.5 7.1 30.9
3.4 5.5 4.8 5.9 5.1 24.7
Ctot 30.9 37.2 32.5 37.0 35.6 173.2
5.5 sapply e tapply
..... em construc¸a˜o
6 MATRIZES
Um objeto do tipo ARRAY e´ um objeto semelhante a MATRIX, mas com dimensa˜o maior do que
2(matrizes n-dimensionais). A sintaxe do comando e´:
array(data, dim)
onde data corresponde a um vetor de dados, e dim um vetor onde cada elemento corresponde a uma
dimensa˜o do array. A estrutura ARRAY e´ obrigatoriamente preenchida por colunas em cada dimensa˜o.
Exemplo: Sejam as matrizes A, B e C, cada uma com dimensa˜o 3 x 4. O ARRAY que “junta” essas
matrizes tera´ dimensa˜o 3 (linhas) x 4 (colunas) x 3 (camadas), necessitando de um vetor de dados
com 36 elementos (3x4x3=36).
A = (aij)3×4 =
 1 4 7 102 5 8 11
3 6 9 12

B = (bij)3×4 =
 13 16 19 2214 17 20 23
15 18 21 24

C = (cij)3×4 =
 25 28 31 3426 29 32 35
27 30 33 36

> (M3 = array(1:36, dim = c(3, 4, 3)))
, , 1
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
, , 2
[,1] [,2] [,3] [,4]
[1,] 13 16 19 22
[2,] 14 17 20 23
[3,] 15 18 21 24
, , 3
[,1] [,2] [,3] [,4]
[1,] 25 28 31 34
[2,] 26 29 32 35
[3,] 27 30 33 36
Para visualizarmos todos os valores da terceira coluna da segunda matriz fazemos:
> M3[, 3, 2]
[1] 19 20 21
7 TABELAS (data.frame)
O objeto data.frame e´ semelhante a` uma matriz mas as colunas podem receber dados de tipos diferentes
(variaveis diferentes) como nu´meros inteiros em uma coluna, nu´meros reais (decimais) em outra,
caracteres em outra, textos, e assim por diante. Veja a Tabela 1.
Exemplo: Contruir, com comandos do R, um objeto com os dados da Tabela 1.
> EC = c("solteiro", " casado", " casado", "solteiro", "solteiro",
+ "casado", "solteiro", "solteiro", "casado", "solteiro")
> GI = c("1oGrau", "1oGrau", "1oGrau", "2oGrau", "1oGrau", "1oGrau",
+ "1oGrau", "1oGrau", "2oGrau", "2oGrau")
> NF = c(NA, 1, 2, NA, NA, 0, NA, NA, 1, NA)
> NS = c(4, 4.56, 5.25, 5.73, 6.26, 6.66, 6.86, 7.39, 7.59, 7.44)
> ID.anos = c(26, 32, 36, 20, 40, 28, 41, 43, 34, 23)
> ID.meses = c(3, 10, 5, 10, 7, 0, 0, 4, 10, 6)
> ORi = c("interior", "capital", "capital", "outro", "outro", "interior",
+ "interior", "capital", "capital", "outro")
> (tabela = data.frame(cbind(EC, GI, NF, NS, ID.anos, ID.meses,
+ ORi)))
Tabela 1: Dados de Bussab & Moretin
Funciona´rio Est. Civil Instruc¸a˜o # Filhos Sala´rio Ano Meˆs Regia˜o
1 solteiro 1o
¯
Grau - 4,00 26 3 interior
2 casado 1o
¯
Grau 1 4,56 32 10 capital
3 casado 1o
¯
Grau 2 5,25 36 5 capital
4 solteiro 2o
¯
Grau - 5,73 20 10 outro
5 solteiro 1o
¯
Grau - 6,26 40 7 outro
6 casado 1o
¯
Grau 0 6,66 28 0 interior
7 solteiro 1o
¯
Grau - 6,86 41 0 interior
8 solteiro 1o
¯
Grau - 7,39 43 4 capital
9 casado 2o
¯
Grau 1 7,59 34 10 capital
10 solteiro 2o
¯
Grau - 7,44 23 6 outro
Fonte: Bussab, Wilton de O.; Moretin, Pedro A. Estat´ıstica Ba´sica. 5.ed. Sa˜o Paulo: Saraiva, 2003 .
EC GI NF NS ID.anos ID.meses ORi
1 solteiro 1oGrau <NA> 4 26 3 interior
2 casado 1oGrau 1 4.56 32 10 capital
3 casado 1oGrau 2 5.25 36 5 capital
4 solteiro 2oGrau <NA> 5.73 20 10 outro
5 solteiro 1oGrau <NA> 6.26 40 7 outro
6 casado 1oGrau 0 6.66 28 0 interior
7 solteiro 1oGrau <NA> 6.86 41 0 interior
8 solteiro 1oGrau <NA> 7.39 43 4 capital
9 casado 2oGrau 1 7.59 34 10 capital
10 solteiro 2oGrau <NA> 7.44 23 6 outro
Note que o objeto foi nominado tabela. Embora a tabela seja um objeto u´nico, qualquer coluna dela
pode ser acessada independentemente da outra, separando o seu nome do nome do objeto, com o
s´ımbolo de cifra˜o ($). Por exemplo, para se referir a` coluna EC - Estado Civil, fazemos:
> tabela$EC
[1] solteiro casado casado solteiro solteiro casado solteiro solteiro
[9] casado solteiro
Levels: casado casado solteiro
Para recuperarmos o nome das colunas da tabela, utiliza-se o comando names( )
> names(tabela)
[1] "EC" "GI" "NF" "NS" "ID.anos" "ID.meses" "ORi"
Outra forma de se trabalhar com as colunas de uma tabela, sem ter que colocar o seu nome antes do
nome da coluna (varia´vel) em questa˜o)
”
e´ “abrindo-se” o objeto com o comando attach( ).
> attach(tabela)
The following object(s) are masked _by_ '.GlobalEnv':
EC, GI, ID.anos, ID.meses, NF, NS, ORi
> EC
[1] "solteiro" " casado" " casado" "solteiro" "solteiro" "casado"
[7] "solteiro" "solteiro" "casado" "solteiro"
> GI
[1] "1oGrau" "1oGrau" "1oGrau" "2oGrau" "1oGrau" "1oGrau" "1oGrau" "1oGrau"
[9] "2oGrau" "2oGrau"
> NF
[1] NA 1 2 NA NA 0 NA NA 1 NA
Para “fechar” novamente o objeto, utiliza-se o comando detach.
> detach(tabela)
Exemplo de uma tabela com o nome das colunas automatico
> d <- data.frame(cbind(1, 1:10, sample(LETTERS, 10, replace = TRUE)))
> is.data.frame(d)
[1] TRUE
Mais um exemplo
> (d1 <- data.frame(X = 1:10, Y = c(51, 54, 61, 67, 68, 75, 77,
+ 75, 80, 82)))
X Y
1 1 51
2 2 54
3 3 61
4 4 67
5 5 68
6 6 75
7 7 77
8 8 75
9 9 80
10 10 82
> names(d1)
[1] "X" "Y"
> d1$X
[1] 1 2 3 4 5 6 7 8 9 10
> plot(d1)
l
l
l
l
l
l
l
l
l
l
2 4 6 8 10
50
55
60
65
70
75
80
X
Y
Outro exemplo onde cada conjunto de 5 elementos segue um modelo Y= cte + aleat
> set.seed(556)
> (d2 <- data.frame(Y = c(round(9 + rnorm(5, sd = 2.3), 1), round(16 +
+ rnorm(5, sd = 2), 1), round(4 + rnorm(5, sd = 2.1), 1))))
Y
1 9.6
2 7.9
3 6.0
4 10.2
5 8.7
6 13.9
7 17.2
8 15.9
9 15.9
10 12.4
11 4.0
12 8.8
13 4.6
14 4.4
15 1.0
> names(d2)
[1] "Y"
Ampliacao de d2
> d2$lev <- gl(3, 5)
> d2
Y lev
1 9.6 1
2 7.9 1
3 6.0 1
4 10.2 1
5 8.7 1
6 13.9 2
7 17.2 2
8 15.9 2
9 15.9 2
10 12.4 2
11 4.0 3
12 8.8 3
13 4.6 3
14 4.4 3
15 1.0 3
> sum(d2$Y)
[1] 140.5
> by(d2$Y, d2$lev, sum)
d2$lev: 1
[1] 42.4
------------------------------------------------------------
d2$lev: 2
[1] 75.3
------------------------------------------------------------
d2$lev: 3
[1] 22.8
8 LISTAS
LISTAS sa˜o estruturas gene´ricas e flex´ıveis que permitem armazenar diversos formatos em um unico
objeto. No exemplo a seguir, o comando list “empacota” um objeto do tipo vetor, um texto e uma
matriz.
> Vetor = 1:10
> Texto = "Esta eh uma mensagem"
> Matriz = matrix(1:9, ncol = 3)
> (lista <- list(Vetor, Texto, Matriz))
[[1]]
[1] 1 2 3 4 5 6 7 8 9 10
[[2]]
[1] "Esta eh uma mensagem"
[[3]]
[,1] [,2] [,3]
[1,] 1 4 7
[2,]2 5 8
[3,] 3 6 9
> names(lista)
NULL
Analogamente, o s´ımbolo do cifra˜o depois do objeto direciona para o elemento (sub objeto) dentro da
lista.
> mat.c <- lista$Matriz
> mat.c
NULL