1.  Introdução  ao  sistema  R  

 

1.1  O  que  é  o  R  ?  
 
O   R   é   um   sistema   de   computação   científica   e   estatística,   programável   e   que  
permite  o  tratamento  de  vários  tipos  de  dados.  Na  sua  versão  base  possui  um  conjunto  
de   ferramentas   que   permitem   o   armazenamento,   processamento,   cálculo,   análise   e  
visualização   de   dados.   Possui   ainda   uma   poderosa   linguagem   de   programação   que  
permite   a   implementação   de   novas   funções   com   o   comportamento   definido   pelo  
utilizador.  Para  além  disso,  é  de  acesso  livre,  existindo  uma  comunidade  bastante  ativa  
de  investigadores  (designada  por  CRAN)  que  desenvolvem  funcionalidades  que  podem  
ser  instaladas  para  estender  as  funcionalidades  do  sistema.  
O   R   começou   por   ser   essencialmente   desenvolvido   como   um   sistema   de  
tratamento   estatístico   de   dados,   mas   tem   evoluído   no   sentido   de   se   tornar   num  
ambiente   de   desenvolvimento   coerente,   mais   genérico   e   multifacetado.   Ainda   assim,  
existem   disponíveis   na   versão   base   do   R   muitas   ferramentas   de   tratamento   estatístico  
de  dados  e  muitas  outras  estão  disponíveis  para  instalação  adicional  e  opcional.      
 

1.2  Instalar  o  R  
 
O   projeto   R   tem   um   sítio   na   WWW   em   [Link]   onde   poderá  
encontrar   a   última   versão   disponível   do   software.   Existem   versões   para   Microsoft  
Windows,   Linux   e   Mac   OS   X   que   podem   ser   instaladas   livremente.   Neste   site   estão  
também  disponíveis  uma  série  de  sites  alternativos  (mirrors)  onde  podem  encontrar  os  
ficheiros  de  instalação,  podendo  ser  escolhido  um  próximo  da  sua  localização  geográfica.  
A  versão  atual  do  R  (em  Setembro  de  2014)  é  a  3.1.  
Para   a   instalação   do   R   deverá   escolher   o   mirror   e   a   opção   “base”,   fazendo   em  
seguida  download  do  ficheiro  de  instalação  adequado  para  o  seu  computador  e  sistema  
operativo.   No   MS   Windows   bastará   em   seguida   correr   o   ficheiro   de   instalação   para  
instalar   o   programa.   Este   criará   um   atalho   no   ambiente   de   trabalho,   podendo   também  
ser  corrido  da  lista  de  programas.  
 

  6  
1.3  Edição  de  comandos  
 
O  R  é  um  ambiente  orientado  ao  uso  de  uma  linha  de  comandos,  apesar  de  nas  
versões   do   sistema   operativo   MS   Windows   e   Mac   OS   X   ter   um   conjunto   de   menus  
disponíveis   que   permitem   realizar   algumas   operações.   Note   que   existem   programas,  
denominados   de   IDEs   (integrated  development  environments),   que   criam   um   ambiente  
integrado   que   inclui   a   linha   de   comandos   R   e   um   conjunto   de   ferramentas  
complementares.   Um   exemplo   recomendado   deste   tipo   de   software   é   o   Rstudio  
([Link]  
Assim,  o  R  permite  escrever  comandos  a  seguir  ao  prompt  (>)  do  interpretador  e  
executa-­‐os  de  seguida.  Em  muitos  casos,  o  R  não  imprime  no  ecrã  nenhum  resultado  da  
computação   efectuada   (e.g.   por   ser   guardado   em   algum   objeto)   e   apenas   altera   o   estado  
das  suas  variáveis  internas  (ou  objetos).  Quando  o  resultado  não  é  guardado  num  objeto  
ele   é   apenas   mostrado   no   ecrã   não   podendo   ser   reutilizado.   Para   este   efeito,   o   resultado  
deve  ser  armazenado  em  variáveis/  objetos  do  R.    
Para  tornar  o  seu  trabalho  mais  eficiente,  pode  sempre  recuperar  os  comandos  
anteriores   utilizando   as   setas   do   cursor,   bem   como   editar   os   comandos   com   as   teclas  
Delete   ou   Backspace,   Home   e   End,   que   tomam   os   seus   comportamentos   habituais.   Há  
que   tomar   em   atenção   que   o   R   é   sensível   à   diferença   entre   maiúsculas   e   minúsculas.  
Assim,  quer  o  nome  dos  objetos  quer  os  comandos  deverão  ser  escritos  na  forma  correta  
(e.g.  “a”  e  “A”  são  símbolos  diferentes).  
Quando  um  comando  não  é  terminado  numa  dada  linha  o  símbolo  +  aparece  no  
início  da  linha  seguinte  indicando  que  o  interpretador  do  R  espera  que  o  comando  seja  
terminado.  Quando  se  pretende  criar  um  conjunto  composto  de  comandos  estes  deverão  
ser   iniciados   com   o   símbolo   {   e   terminados   com   o   símbolo   }.   Os   comandos   individuais  
podem  ser  separados  por  ;  ou  simplesmente  mudando  de  linha.  
A  função  q(  )  é  usada  para  terminar  a  sua  sessão  no  R.  
 

1.4  Objetos  e  funções  

 
Existem   dois   conceitos   fundamentais   no   R:   objetos   e   funções.   Os   objetos   (ou  
variáveis)   são   os   “contentores”   da   informação,   ou   seja,   permitem   guardar   dados   de  
diversos   tipos.   Nos   capítulos   seguintes   analisar-­‐se-­‐ão   em   detalhe   diversos   tipos   de  
objetos  existentes  no  R.  

  7  
 As   funções,   por   outro   lado,   constituem   os   mecanismos   de   processamento   e  
manipulação   dos   dados.   Tipicamente,   uma   função   consta   de   uma   operação   de  
manipulação  de  dados  que  pode  receber  zero  ou  mais  argumentos  de  entradas  (objetos  
ou   variáveis)   e   retorna   como   resultado   um   novo   objeto   ou   variável   (podendo   não  
retornar   resultado   algum).   As   funções   em   R   constituem   assim   uma   implementação  
(ainda   que   mais   flexível)   do   conceito   matemático   de   função.   As   funções   podem   ser  
chamadas  em  R  através  da  sintaxe:  nome_função(argumentos)    
Quando  o  R  arranca  são  carregados  alguns  packages  nucleares  que  possuem  um  
conjunto  de  funções  já  disponíveis.  É  possível  carregar  novos  packages  instalados  na  sua  
distribuição   com   a   função   library(package)   tornando   as   funções   desse   package  
disponíveis.   A   função   library,   chamada   sem   argumentos   –   library()   –   permite   saber  
quais  os  packages  instalados.    
É   ainda   possível   instalar   novos   packages   disponíveis   alargando   assim   o   leque   de  
funções   disponíveis.   Note   que   ao   instalar   um   novo   package   terá   que   o   carregar   em  
seguida.   No   MS   Windows   e   Mac   OS   X   existe   o   menu   Packages   onde   poderá   encontrar  
opções  que  lhe  permitem  instalar  novos  packages  e  atualizar  os  existentes.  Pode  ainda  
instalar  novos  packages  com  a  função  [Link](packages).  
Por   outro   lado,   o   R   disponibiliza   ainda   uma   linguagem   de   programação   que  
permite   o   desenvolvimento   de   novas   funções   pelo   utilizador,   que   passam   a   estar  
disponíveis  para  serem  utilizadas  exatamente  da  mesma  forma  que  as  pré-­‐definidas  (ver  
capítulo  5).  
 

1.5  Ajuda  e  documentação  

 
O  R  possui  um  sistema  de  ajuda.  Este  pode  ser  consultado  de  várias  formas:  
• Consultar   uma   ajuda   genérica   sobre   o   R.   O   comando   [Link]()   irá   abrir  
uma  janela  de  um  browser  (e.g.  Internet   Explorer  ou  Firefox)  e  mostrar  uma  
página  útil  para  uma  introdução  ao  R.  
• Usando   a   função   help   para   descobrir   ajuda   sobre   uma   função   do   sistema  
(e.g.,  help(matrix))  
• Procurar  todas  as  páginas  de  help  onde  esteja  uma  dada  palavra  chave  com  a  
função  [Link]  (e.g.  [Link]("matrix"))  
 

  8  
 No   MS   Windows   ou   Mac   OS   X,   ao   nível   do   menu   Help   poderá   ainda   encontrar  
outras   alternativas   ao   nível   da   ajuda   ao   utilizador.   Neste   menu   tem   ainda   a   opção   de  
consultar  alguns  manuais  disponíveis  em  PDF  que  acompanham  a  instalação  do  R.  
Uma   função   bastante   útil   é   a   função   example(função)   que   permite   consultar  
exemplos   ilustrativos   do   uso   de   cada   função,   passando   o   nome   da   função   como  
parâmetro.  
 

1.6  Gravar/  recuperar  uma  sessão    

 
As   seguintes   funções   poderão   ser   usadas   para   guardar   o   seu   trabalho   no   final   de  
uma  sessão  e  recuperá-­‐lo  na  sessão  seguinte:  
• A   função   savehistory(nome_ficheiro)   guarda   os   comandos   efectuados  
durante  uma  sessão  podendo  especificar-­‐se  o  nome  do  ficheiro  
• A  função  loadhistory(nome_ficheiro)  carrega  os  comandos  efectuados  de  um  
ficheiro.   Este   é   um   ficheiro   de   texto   que   poderá   ser   aberto   por   qualquer  
editor  de  texto.  Estas  opções  estão  também  disponíveis  no  menu  File.  
• A   função   [Link](nome_ficheiro)   guarda   os   dados   criados   durante   uma  
sessão  podendo  especificar-­‐se  o  nome  do  ficheiro.    
• A  função  load(nome_ficheiro)  realiza  a  operação  inversa.  Este  é  um  ficheiro  
binário  que  só  pode  ser  aberto  com  o  R.    
 
Ao   terminar   uma   sessão   tem   a   opção   de   guardar   os   dados   e   os   comandos  
efetuados.   Se   responder   afirmativamente,   os   dados   serão   guardados   num   ficheiro  
chamado   “.RData”   e   os   comandos   no   ficheiro   “.Rhistory”,   na   sua   pasta   corrente   de  
trabalho.   Se   o   R   for   recomeçado   da   mesma   diretoria   estes   ficheiros   são  
automaticamente  carregados  no  início  da  sessão  seguinte.  Na  secção  4.1  poderá  verificar  
mais  detalhes  sobre  como  verificar  e  alterar  a  sua  diretoria  de  trabalho.  
   

  9  
2.  Vetores  e  tipos  primitivos  
 

2.1  Objetos  e  atribuição  de  valores  

 
Como   foi   já   referido   no   capítulo   anterior,   o   R   permite   definir   objetos,   que   não  
são   mais   do   que   a   forma   de   guardar   informação   de   forma   a   poder   ser   re-­‐utilizada.   A  
cada   objeto   no   R   é   atribuído   um   nome   que   o   identifica   e   um   determinado   tipo,   que  
indica  qual  a  estrutura  dos  dados  que  pode  guardar.  
A  operação  mais  básica  que  se  pode  realizar  sobre  um  objeto  é  a  atribuição,  i.e,  
associar   um   valor   ou   conteúdo   a   um   nome.   Para   o   efeito   usam-­‐se   os   operadores   <-­‐   ou   =.  
Assim  os  comandos  seguintes  atribuem,  ambos,  o  valor  2  ao  objeto  x:  
 
> x = 2
> x <- 2
 
Note   que   quando   efetua   uma   atribuição   não   é   imprimido   nenhum   valor   na   linha   de  
comando.   Para   verificar   o   conteúdo   de   um   objeto   terá   que   escrever   o   seu   nome   na   linha  
de  comando  do  R,  sendo  que  este  é  imprimido  no  ecrã:  
 
> x
[1] 2
 
A   lista   de   objetos   disponíveis   numa   sessão   de   trabalho   de   R   pode   ser   consultada  
através  da  função  ls(  ).  A  função  rm(objeto)  poderá  ser  usado  para  remover  um  objeto  
da  sessão  de  trabalho.  Por  outro  lado,  a  função  typeof(objeto)  permite  determinar  o  tipo  
de  dados  associado  ao  objeto.    
 

2.2  Valores  numéricos  e  operadores  aritméticos  

 
Pelas   suas   características,   o   tipo   de   dados   mais   usual   no   R   é   o   tipo   numérico.  
Sobre   valores   numéricos   é   possível   realizar   diversos   tipos   de   cálculos   usando  
operadores   aritméticos   comuns   (+,   -­‐,   *,   /)   ou   funções   pré-­‐definidas   (que   serão  
abordadas   mais   tarde).   Para   ilustrar   algumas   destas   funcionalidades,   vejamos   exemplos  
onde  a  linha  de  comandos  do  R  é  usada  ao  estilo  de  uma  calculadora:  

  10  
  
> 2+3
[1] 5
> 3 * 1/2
[1] 1.5
> 5.3 - 4.2 / 2.3
[1] 3.473913
 
Note   nos   exemplos   acima   que   quando   escreve   uma   expressão   na   linha   de  
comandos  R,  o  seu  valor  é  calculado  e  escrito  no  ecrã.  O  valor  1  entre  parêntesis  retos  
indica  apenas  que  se  trata  do  primeiro  elemento  do  resultado,  e  neste  caso  o  único.  Note  
ainda  que  as  regras  de  prioridade  dos  operadores  aritméticos  se  mantêm.  
Vimos   já   acima   como   criar   um   objeto   numérico   e   atribuir-­‐lhe   um   valor.   Vejamos  
em  seguida  mais  alguns  exemplos  ilustrativos:  
 
> y = 3.1
> z = 6.2
> y / z
[1] 0.5
> w = y * z + 2
 
Neste   caso,   os   operadores   aritméticos   +,   -­‐   e   /   têm   o   significado   habitual,  
enquanto  *  significa  multiplicação.  Podem  ainda  usar-­‐se  a  exponenciação  (símbolo  ^),  a  
divisão  inteira  (símbolo  %/%)  e  o  resto  da  divisão  inteira  (%%),  como  se  pode  observar  
pelos  exemplos:  
 
> y=5
> y^2
[1] 25
> y%%2
[1] 1
> y%/%2
[1] 2

2.3  Vetores  numéricos    

 
Vimos   anteriormente   exemplos   de   variáveis   escalares.   No   entanto,   o   R   é  
orientado   aos   vetores   que   constituem   objetos   que   permitem   guardar   uma   sequência   de  

  11  
valores.   Assim,   não   existem   em   R   variáveis   escalares   com   um   único   valor,   sendo   estas  
casos  particulares  de  vetores  com  apenas  um  elemento.    
A  função  c  permite  concatenar  um  vetor  com  outros  elementos  (ou  com  outros  
vetores),  sendo  a  forma  mais  direta  de  formar  um  novo  vector:  
 
> v1 = c(1,5,8,10)
> v1
[1] 1 5 8 10
> v2 = c(3,v1)
> v2
[1] 3 1 5 8 10
 
Outra   forma   de   criar   vetores   numéricos,   com   utilidade   prática,   é   a   geração   de  
sequências   de   números.   Um   dos   casos   mais   simples   consiste   em   gerar,   por   exemplo,   um  
vetor   com   todos   os   números   inteiros   entre   1   e   10.   Podemos   fazer   isso   utilizando   o  
operador  :,  como  se  ilustra  de  seguida:  
 
> 1:10
[1] 1 2 3 4 5 6 7 8 9 10
> 10:2
[1] 10 9 8 7 6 5 4 3 2
 
É  ainda  possível  gerar  sequências  duma  forma  mais  genérica  utilizando  a  função  
seq.  Esta  tem  como  argumentos:  o  valor  inicial  da  sequência  (from),  o  valor  final  (to)  e  
intervalo  entre  os  elementos  (by).  Vejamos  um  exemplo  simples  de  uma  sequência  entre  
1.0  e  5.0,  com  passo  de  0.1.  
 
> seq(1, 2, 0.1)
[1] 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0
 
Em   R   podemos   escrever   os   argumentos   das   funções   pela   sua   ordem   ou   pelo  
nome   podendo   assim   defini-­‐los   por   uma   outra   ordem.   Assim,   este   comando   obtém  
exatamente  o  mesmo  resultado  que  o  anterior:  
 
> seq(by = 0.1, to = 5, from = 1)
 

  12  
 Por   outro   lado,   podemos   ainda   omitir   alguns   argumentos,   desde   que   estes  
tenham   um   valor   por   omissão.   No   exemplo   seguinte,   o   parâmetro  by   foi   omitido   tendo   o  
valor  1  por  omissão:    
 
> seq(1, 10)
[1] 1 2 3 4 5 6 7 8 9 10
 
Uma  função  relacionada  com  esta  é  a  função  rep,  que  permite  criar  vectores  com  
repetição  de  elementos.  Os  principais  argumentos  desta  função  definem  os  elementos  a  
repetir,   o   número   de   vezes   que   determinado   elemento   é   repetido   (each)   e   o   número  
total  de  repetições  a  efetuar  (times).  Os  exemplos  seguintes  ilustram  o  comportamento  
da  função:  
 
> x = c(2,4,6)
> rep(x, times=5)
[1] 2 4 6 2 4 6 2 4 6 2 4 6 2 4 6
> rep(x, each=5)
[1] 2 2 2 2 2 4 4 4 4 4 6 6 6 6 6
 
De  uma  forma  mais  genérica,  um  vetor  pode  ser  criado  usando  a  função  vector.  
Esta   função   recebe   como   parâmetros   o   tipo   de   dados   do   vector   denominado   de   mode  
(que   pode   ser   “numeric”   para   vetores   numéricos,   “logical”   no   caso   de   vetores   lógicos   ,ou  
“character”   no   caso   das   strings,   que   se   tratarão   em   secções   próximas)   e   o   tamanho  
(length):  
 
> v = vector(mode="numeric", length=10)
> v
[1] 0 0 0 0 0 0 0 0 0 0
 
Uma  forma  alternativa  e  útil  de  gerar  vetores  numéricos  passa  pela  sua  geração  
aleatória  a  partir  de  uma  dada  distribuição  estatística,  das  quais  se  podem  destacar:  
 
• runif:  gera  valores  aleatórios  num  dado  intervalo  onde  cada  valor  tem  a  
mesma  probabilidade  de  ser  gerado.  Recebe  como  argumentos  o  número  
de   elementos   a   gerar,   o   limite   inferior   e   o   limite   superior   do   intervalo  
(por  omissão  estes  valores  são  0  e  1).    

  13  
 • rnorm:   gera   valores   de   uma   distribuição   normal.   Recebe   como  
argumentos  o  número  de  elementos  a  gerar,  a  média  e  o  desvio  padrão  
da  distribuição.  
• rpois:   gera   valores   de   uma   distribuição   de   Poisson   (discretos),  
recebendo   como   argumentos   o   número   de   valores   e   o   parâmetro   λ   da  
distribuição.  
 
 Alguns  exemplos:  
 
> x=runif(10)
> x
[1] 0.20005861 0.52085024 0.71153606 0.79749557 0.05269482
0.43319890
[7] 0.75369573 0.06322223 0.22304411 0.76038862
> y = runif(10,5,10)
> y
[1] 9.918916 7.585866 8.772228 8.953732 6.417860 5.893641 8.355221
7.710591
[9] 9.907576 9.939798
 
É   possível   realizar   operações   aritméticas   sobre   vetores   de   uma   forma   bastante  
simples   e   análoga   à   forma   como   realizamos   as   operações   sobre   valores   individuais  
(escalares),  como  se  pode  verificar  pelos  exemplos  seguintes:  
 
> x = 1:10
> 2*x+1
[1] 3 5 7 9 11 13 15 17 19 21
> x/2
[1] 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
> x-5
[1] -4 -3 -2 -1 0 1 2 3 4 5
 
Uma  operação  aritmética  utiliza  vetores  do  mesmo  tamanho  e  realiza  a  operação  
entre  cada  par  de  valores  nas  mesmas  posições  de  ambos  os  vetores.  Se  os  vetores  não  
tiverem   o   mesmo   tamanho,   o   mais   pequeno   será   reciclado,   isto   é,   será   repetido  
enquanto   for   necessário.   Isto   acontece   normalmente   em   R   quando   é   necessário   um  
vetor   de   um   certo   tamanho   e   se   usa   um   mais   pequeno.   Vejamos   um   exemplo,   onde   cada  
elemento  do  vetor  vm  é  usado  duas  vezes  enquanto  cada  elemento  de  vn  é  apenas  usado  
uma:  

  14  
  
> vm = 1:5
> vn = 1:10
> vm+vn
[1] 2 4 6 8 10 7 9 11 13 15
 
Quando   o   tamanho   do   vetor   maior   não   é   múltiplo   do   menor   tem-­‐se   uma  
mensagem   de   aviso,   pois   este   caso   é   muitas   vezes   sinónimo   de   comportamentos   não  
desejados  pelo  utilizador.  Veja-­‐se  o  exemplo  seguinte:  
 
> vm = 1:3
> vn = 1:10
> vm+vn
[1] 2 4 6 5 7 9 8 10 12 11
Warning message:
longer object length is not a multiple of shorter object length in:
vm + vn
 

2.4  Acesso  aos  elementos  de  vetores  

 
É   possível   consultar   certos   índices   de   um   vetor   escrevendo   o   nome   do   vetor   e,  
entre  parêntesis  rectos,  os  índices.  Assim,  se  quisermos  aceder  ao  elemento  do  vetor  x  
na  posição  i  escrevemos  x[i].  Um  exemplo  simples:    
 
> x
[1] 1 2 3 4 5 6 7 8 9 10
> x[2]
[1] 2
 
A   indexação   pode   também   ser   feita   usando   um   vetor   como   índice,   sendo   neste  
caso   retornado   um   vetor   com   os   valores   do   vetor   inicial   nas   posições   constantes   do  
vetor  índice.  Veja-­‐se  um  exemplo:  
 
> v1
[1] 1 5 8 10
> ind=2:3
> v1[ind]
[1] 5 8
 

  15  
 Se   os   índices   forem   negativos,   isto   quer   dizer   que   todos   os   valores   excepto   os  
valores  dos  índices  são  selecionados:  
 
> v1[-2]
[1] 1 8 10
> v1[-(2:3)]
[1] 1 10
 
O   R   permite   ainda   atribuir   nomes   a   cada   uma   das   posições   do   vetor   e   depois  
usar   esses   nomes   para   aceder   aos   seus   valores.   Os   nomes   associados   a   um   vetor   são  
atribuídos  usando  a  função  names:  
 
> v1 = c(1,5,8,10)
> names(v1) = c("azul","amarelo","verde","vermelho")
> v1
azul amarelo verde vermelho
1 5 8 10
> v1["verde"]
verde
8
> v1[c("amarelo","vermelho")]
amarelo vermelho
5 10
 
Os   nomes   associados   a   um   vetor   são,   de   facto,   um   vetor   de   strings   que   serão  
abordados  em  mais  detalhe  numa  das  próximas  secções.  
 

2.5  Funções  sobre  vetores  numéricos  

 
Existem   inúmeras   funções   que   podem   ser   aplicadas   sobre   vetores   numéricos.  
Um   grupo   de   funções   pode   ser   identificado   como   funções   matemáticas   tipicamente  
aplicadas   a   um   único   valor   e   que   no   R   são   aplicadas   individualmente   a   todos   os  
elementos   de   um   vetor,   gerando   um   novo   vetor   com   o   mesmo   comprimento.     Estas  
podem   obviamente   ser   aplicadas   a   vetores   com   um   único   elemento,   usadas   para  
representar  variáveis  escalares.    
Identificam-­‐se  aqui  algumas  das  mais  usadas:  
 
• Valor  absoluto  (módulo):  abs;  

  16  
 • Raiz  quadrada:  sqrt;  
• Funções  trigonométricas:  seno  (sin),  coseno  (cos),  tangente  (tan);  
• Arredondar   um   valor   para   um   determinado   número   de   casas   decimais:  
round;  
• Exponenciação  natural  (ex):  exp;  
• Logaritmos:   log   (logaritmo   natural),   logb   (logaritmo   em   que   a   base   é  
passada   por   argumento),   log2   (logaritmo   base   2)   e   log10   (logaritmo  
base  10).  
 
Alguns   exemplos   (de   referir   que   no   exemplo   é   usada   a   constante   pi,   que  
representa  o  valor  de  П):  
 
> v =c(-1,2,3,-4)
> abs(v)
[1] 1 2 3 4
> sqrt(abs(v))
[1] 1.000000 1.414214 1.732051 2.000000
> sin(pi/2*v)
[1] -1.000000e+00 1.224606e-16 -1.000000e+00 2.449213e-16
> nr = c(1.23, 2.321, 4.07654, 3, 2.345)
> round(nr, 1)
[1] 1.2 2.3 4.1 3.0 2.3
> p10 = c(10,100,1000,10000)
> log10(p10)
[1] 1 2 3 4
 
A   função   mapply   permite   ainda   aplicar   qualquer   função   (ou   operador  
aritmético)   do   R   ou   definida   pelo   utilizador   a   todos   os   elementos   de   um   vetor,  
recebendo  como  argumentos  o  nome  da  função  e  o  vetor:  
 
> mapply(sqrt, abs(v))
[1] 1.000000 1.414214 1.732051 2.000000
> mapply("/",p10,10)
[1] 1 10 100 1000
 
Por   outro   lado,   algumas   funções   são   aplicadas   a   um   vector   de   forma   global  
gerando  um  novo  vector.  Entre  estas  poderão  destacar-­‐se:  
 
• sort:  ordena  um  vetor  por  ordem  crescente  ou  decrescente;  

  17  
 • order:  dá  a  ordem  dos  elementos  do  vetor  (pelos  seus  índices);  
• unique:  dá  um  vetor  apenas  com  os  elementos  únicos  (sem  repetidos);  
• rev:  dá  o  inverso  de  um  vector;  
• cumsum:   dá   a   soma   cumulativa   de   um   vetor,   i.e.   em   cada   posição   o  
resultado  é  a  soma  dos  elementos  anteriores;  
• cumprod:  dá  o  produto  cumulativo  de  um  vetor;  
• diff:  retorna  um  vetor  com  as  primeiras  diferenças  do  original.  
 
Alguns  exemplos  de  utilização:  
 
> v = c(2,4,7,6,3,1)
> rev(v)
[1] 1 3 6 7 4 2
> sort(v)
[1] 1 2 3 4 6 7
> sort(v, decreasing=TRUE)
[1] 7 6 4 3 2 1
> order(v)
[1] 6 1 5 2 4 3
> v[order(v)]
[1] 1 2 3 4 6 7
> unique(c(1,2,1,2,3))
[1] 1 2 3
> cumsum(v)
[1] 2 6 13 19 22 23
> cumprod(v)
[1] 2 8 56 336 1008 1008
> diff(v)
[1] 2 3 -1 -3 -2
 
Um  outro  conjunto  de  funções  permite  calcular  valores  escalares  a  partir  de  um  
vetor.  Neste  caso,  têm-­‐se  os  seguintes  exemplos:  
 
• Número  de  elementos  (comprimento)  de  um  vector:  length  
• Menor  valor  do  vetor  (min),  índice  do  menor  valor  ([Link]),  maior  
valor  (max),  índice  do  maior  valor  ([Link]);  
• Soma  dos  elementos  de  um  vector:  sum  
• Média  dos  elementos  de  um  vector:  mean  
 

  18  
 Note-­‐se   que   a   função   length   pode   aplicar-­‐se   a   qualquer   tipo   de   vetor.   Alguns  
exemplos:  
 
> vs = c(3,5,7,9)
> sum(vs)
[1] 24
> mean(vs)
[1] 6
> min(v)
[1] 3
> max(v)
[1] 9
> [Link](v)
[1] 4
> [Link](v)
[1] 1
> range(v)
[1] 3 9
 
O   tipo   de   dados   existente   num   dado   vector   pode   ser   consultado   com   a   função  
typeof:    
 
> typeof(v1)
[1] "double"
 
Neste   caso,   o   tipo   “double”   corresponde   a   valores   numéricos   usando   uma  
representação   interna   de   precisão   dupla   que   permite   guardar   um   leque   alargado   de  
valores  e  é  o  modo  por  omissão  para  valores  numéricos.    
Uma   outra   função   usada   para   determinar   o   tipo   de   objetos   com   que   se   está   a  
trabalhar   é   a   função   class.   Um   vector   numérico   tem   como   classe   “numeric”.   Por   outro  
lado,   os   vetores   lógicos   que   se   tratarão   na   próxima   secção   têm   por   classe   e   por   tipo   o  
valor  “logical”.  
O  R  permite  trabalhar  com  números  complexos  especificando-­‐se  a  componente  
imaginária   colocando   um   valor   numérico   e   o   símbolo   i.   Um   exemplo   de   um   vetor   de  
valores  complexos  é  o  seguinte:  
 
> vc = c(2+3i, 4-21, 3i, 4)
> sum(vc)
[1] -11+6i
> mean(vc)

  19  
[1] -2.75+1.5i
 
No   exemplo   anterior,   é   possível   verificar   que   se   aplicam   a   estes   valores   as  
mesmas   funções   que   a   valores   reais   (quando   tal   fizer   sentido   do   ponto   de   vista  
matemático).    
Um   vetor   passa   a   ter   o   tipo   de   dados   “complex”   se   pelo   menos   um   dos   seus  
membros   for   um   número   complexo.   Assim,   se   quisermos   calcular   raízes   quadradas   de  
valores  negativos  devemos  defini-­‐los  como  complexos,  conforme  o  exemplo  seguinte:  
 
> vc = c(4, -4)
> sqrt(vc)
[1] 2 NaN
Warning message:
NaNs produced in: sqrt(vc)
> vc = c(4, -4+0i)
> sqrt(vc)
[1] 2+0i 0+2i

2.6  Vetores  lógicos  

 
Um   outro   tipo   de   dados   importante   no   R   são   os   vetores   lógicos,   cujos   elementos  
são   variáveis   Booleanas   ou   lógicas,   ou   seja,   que   podem   tomar   o   valor   verdadeiro  
(representado   como   TRUE)   ou   falso   (FALSE).   Estes   vectores   podem   ser   criados  
diretamente  a  partir  da  função  c  referida  anteriormente:  
 
> vb1 = c(TRUE,TRUE,FALSE,TRUE,FALSE)
> vb1
[1] TRUE TRUE FALSE TRUE FALSE
> vb1[3]
[1] FALSE
 
Em   alternativa,   este   tipo   de   vetores   pode   ser   criado   a   partir   de   um   vetor  
numérico,  aplicando  a  cada  elemento  uma  condição  que  define  se  o  valor  a  colocar  nessa  
posição  é  verdadeiro  ou  falso.  Um  exemplo  simples  segue:  
 
> v = 1:10
> vb2 = v > 5

  20  
> vb2
[1] FALSE FALSE FALSE FALSE FALSE TRUE TRUE TRUE TRUE TRUE
 
Ao   nível   das   condições,   poder-­‐se-­‐ão   utilizar   os   operadores   >,   <,   >=,   <=   com   os  
significados  habituais.  A  igualdade  é  representada  por  ==  e  a  desigualdade  por  !=.  Note  a  
diferença  entre  o  símbolo  =  para  a  atribuição,  e  o  símbolo  ==  para  definir  uma  condição.  
Por  exemplo  x  =  3,  significa  que  o  objeto  x  passa  a  ter  como  conteúdo  o  valor  3,  enquanto  
que  x   ==   3  é  uma  expressão  lógica  que  testa  se  o  conteúdo  do  objeto  x  é  3,  podendo  ter  
um   valor   de   TRUE   ou   FALSE.   Um   outro   operador   que   retorna   um   valor   lógico   é   o  
operador  %in%  que  tem  o  significado  da  pertença  de  conjuntos.  
Por   outro   lado,   podem   aplicar-­‐se   a   vetores   lógicos   os   operadores   lógicos  
habituais:  
• negação:  representada  pelo  símbolo  !  (e.g.  !c  representa  a  negação  de  c);  
• conjunção:  representada  pelo  símbolo  &.  
• disjunção:  representada  pelo  símbolo  |.    
 
Estes   operadores   podem   ser   usados   para   definir   condições   mais   complexas.   A  
forma   de   usar   estes   operadores   segue   a   filosofia   vetorial   apontada   para   o   caso   dos  
operadores   aritméticos,   como   se   ilustra   nos   exemplos.   Nestes   demonstra-­‐se   ainda   o   uso  
das   funções   all   e   any.   Como   os   nomes   indicam,   a   primeira   retorna   TRUE   apenas   quando  
todos   os   elementos   do   vetor   forem   TRUE,   enquanto   a   segunda   retorna   TRUE   se   pelo  
menos   um   dos   elementos   for   TRUE.   Finalmente,   a   função   which   pode   ser   usada   sobre  
um  vetor  lógico  para  identificar  os  índices  dos  elementos  que  são  TRUE.    
 
>  vb2  |  vb1  
 [1]    TRUE    TRUE  FALSE    TRUE  FALSE    TRUE    TRUE    TRUE    TRUE    TRUE  
>  vb1  &  !vb2  
 [1]    TRUE    TRUE  FALSE    TRUE  FALSE  FALSE  FALSE  FALSE  FALSE  FALSE  
> all(vb1)
[1] FALSE
> any(vb1)
[1] TRUE
> which (vb1)
[1] 1 2 4
 
Os  vetores  lógicos  podem  ainda  ser  usados  como  vetores  numéricos,  sendo  que  
o  valor  de  TRUE  é  tomado  como  1  e  o  valor  de  FALSE  é  tomado  como  0.  

  21  
 Uma   funcionalidade   interessante   dos   vetores   lógicos   é   a   sua   utilização   como  
forma  de  indexar  outros  vetores.  Neste  caso,  os  valores  dos  índices  para  o  qual  o  vetor  
lógico   é   verdadeiro   são   considerados   e   os   restantes   são   ignorados.   Seguem-­‐se   exemplos  
demonstrativos:  
 
> ve = 8:2
> ve
[1] 8 7 6 5 4 3 2
> vb = ve > 5
> vb
[1] TRUE TRUE TRUE FALSE FALSE FALSE FALSE
> ve[vb]
[1] 8 7 6
> ve[ve<6]
[1] 5 4 3 2
 

2.7  Strings    
 
Um   dos   tipos   de   vetores   existentes   em   R   permite   guardar   em   cada   posição  
sequências  de  caracteres,  também  designadas  por  strings.  Um  exemplo  muito  simples  da  
utilização  deste  tipo  de  variáveis  é  dado  em  seguida:  
 
> cores = c("azul","amarelo","verde","vermelho")
> cores[3]
[1] "verde"
> muitascores = rep(cores, 2)
> muitascores
[1] "azul" "amarelo" "verde" "vermelho" "azul" "amarelo"
"verde"
[8] "vermelho"
> muitascores[1] == muitascores[5]
[1] TRUE
 
Existem   um   conjunto   de   funções   específicas   para   trabalhar   sobre   strings,   das  
quais  se  podem  destacar  as  seguintes:  
 
• nchar:  dá  o  número  de  caracteres  de  uma  string;  
• paste:  concatena  os  valores  de  dois  vectores  de  strings;  

  22  
 • substr:   permite   extrair   uma   sub-­‐string   de   uma   string,   permitindo   por  
exemplo  retirar  prefixos  e  sufixos;  
• toupper/   tolower:   convertem   uma   string   para   maiúsculas   ou  
minúsculas,  respectivamente;  
• grep:  permite  procurar  padrões  em  strings;    
• sub/   gsub:   permitem   procurar   e   substituir   padrões   em   strings   (o   sub  
subsitui   apenas   a   primeira   ocorrência   do   padrão   enquanto   o   gsub  
substitui  todas  as  ocorrências);  
• chartr:   permite   substituir   em   paralelo   um   conjunto   de   caracteres   por  
um  outro,  definidos  posição  a  posição.  
 
O  comportamento  destas  funções  é  exemplificado  pelos  seguintes  exemplos:  
 
> nome = "paulo"
> apelido = "silva"
> toupper(nome)
[1] "PAULO"
> paste(nome, apelido)
[1] "paulo silva"
> substr(apelido,2,4)
[1] "ilv"
> nchar(nome)
[1] 5
> sub("lo","la",nome)
[1] "paula"
> str = "abracadabra"
> gsub("a","x",str)
[1] "xbrxcxdxbrx"
> chartr("abc","ABC",str)
[1] "ABrACAdABrA"
 
Algumas   destas   funções   podem   ser   aplicadas   a  vetores   de   strings   e   não   apenas   a  
uma   string   individualmente.   No   caso   de   os   vectores   não   serem   do   mesmo   tamanho  
aplica-­‐se   a   regra   anterior   de   recomeçar   do   início   do   vetor   mais   pequeno.   A   função  
mapply   definida   anteriormente   pode   também   ser   usada   com   vetores   de   strings.  
Seguem-­‐se  alguns  exemplos:  
 
> nomes = c("joao", "joaquim", "jose")
> apelidos = c("silva", "sousa")
> paste(nomes, apelidos, sep=" ")

  23  
[1] "joao silva" "joaquim sousa" "jose silva"
> toupper(nomes)
[1] "JOAO" "JOAQUIM" "JOSE"
> mapply(nchar,nomes)
joao joaquim jose
4 7 4
> sub("j","J",nomes)
[1] "Joao" "Joaquim" "Jose"
> grep("abra", c("cabra", "braga", "abracadabra"))
[1] 1 3
 
 
Note-­‐se  ainda  a  existência  em  R  de  duas  constantes  pré-­‐definidas  que  guardam  o  
conjunto  de  letras  maiúsculas  e  minúsculas:    
 
> letters
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p"
"q" "r" "s" "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" "T" "U" "V" "W" "X" "Y" "Z"

2.8  Fatores    
 
Os   fatores   constituem   um   tipo   de   dados   existente   em   R   que   permite   representar  
variáveis  cuja  gama  de  valores  possíveis  é  um  conjunto  discreto.  Um  objeto  do  tipo  fator  
pode   ser   construído   a   partir   de   um   vetor   de   strings,   sendo   identificados   os   valores  
distintos   existentes   que   tomam   o   nome   de   “levels”.   A   função   factor   efetua   esta   tarefa,  
sendo   a   função   levels   aplicada   sobre   um   objeto   do   tipo   factor   para   determinar   o  
conjunto  de  valores  distintos.  Alguns  exemplos:  
 
> racas = c("bulldog", "rafeiro", "doberman", "rafeiro", "bulldog",
"rafeiro", "rafeiro", "doberman")
> fr = factor(racas)
> fr
[1] bulldog rafeiro doberman rafeiro bulldog rafeiro rafeiro
doberman
Levels: bulldog doberman rafeiro
> levels(fr)

  24  
[1] "bulldog" "doberman" "rafeiro"
 
A  principal  utilização  dos  factores  surge  na  análise  estatística,  podendo  dividir-­‐
se   os   dados   pelas   classes   ou   categorias   presentes.   Pode   usar-­‐se   a   função   table   para  
criar-­‐se  uma  tabela  de  frequências  de  cada  uma  das  categorias:  
 
> table(fr)
fr
bulldog doberman rafeiro
2 2 4
 
Podem  também  calcular-­‐se  diversas  estatísticas  sobre  cada  uma  das  categorias.  
Para   o   efeito   uma   função   importante   é   a   função   tapply.   Esta   recebe   como   argumentos  
um   vetor   com   a   variável   a   analisar   estatisticamente,   um   vector   com   os   factores   e   uma  
função  a  aplicar  aos  dados.  
Por   exemplo,   suponha-­‐se   que   no   exemplo   anterior   se   tem   um   vector   com   o   peso  
de  cada  um  dos  cães  considerados  e  que  se  pretende  calcular  a  média  de  pesos  por  raça:  
 
> pesos = c(12, 15, 35, 10, 20, 8, 13, 25)
> tapply(pesos,fr,mean)
bulldog doberman rafeiro
16.0 30.0 11.5
 
A   função   ordered   pode   ser   usada   para   criar   um   objeto   do   tipo   factor,   em   que  
estes  são  ordenados  por  uma  ordem  definida  pelo  utilizador.  
 
> tamanhos = c("medio", "medio", "grande", "pequeno", "grande",
"pequeno", "medio", "grande")
> of = ordered(tamanhos, c("pequeno","medio","grande"))
> of
[1] medio medio grande pequeno grande pequeno medio grande
Levels: pequeno < medio < grande
> tapply(pesos, of, range)
$pequeno
[1] 8 10
$medio
[1] 12 15
$grande
[1] 20 35

  25  
2.9  Valores  em  falta  
 
O   R   permite   que   num   vetor   possam   existir   valores   que   não   são,   em   dado  
momento,  conhecidos  tendo  um  valor  especial  –  NA  –  que  representa  estes  casos1.  Este  
valor   poderá   ser   usado   em   casos   onde   o   valor   de   uma   dada   variável   não   é   conhecido   ou  
ainda   não   foi   inicializado.   Note   que   este   é   um   valor   especial,   pelo   que   o   teste   x  ==  NA  
terá  sempre  como  resultado  FALSE,  mesmo  que  x  não  seja  conhecido  e  tenha  valor  NA.  
A  função  [Link]  pode  ser  aplicada  a  um  vector,  retornando  um  vector  lógico  que  
tem  o  valor  TRUE  nas  posições  onde  o  vector  original  tem  o  valor  NA.  Esta  função  pode  
ser  usada,  por  exemplo,  para  filtrar  de  um  vetor  todos  os  elementos  NA  antes  de  realizar  
alguma  operação:  
 
> v = c(NA, 2, 3, NA, 5)
> v
[1] NA 2 3 NA 5
> v[[Link](v)]
[1] NA NA
> v[]
[1] 2 3 5
 
Um   segundo   tipo   de   valor   especial   é   o   NaN,   que   deriva   de   “Not   A   Number”,  
usado  para  representar  situações  de  erro  em  alguns  tipos  de  cálculo,  por  exemplo  0/0.  É  
de   referir  que  existe  ainda   uma  constante  –  Inf  –  que   representa   o   valor   de   infinito.   Este  
será  o  resultado,  por  exemplo,  de  dividir  qualquer  valor  por  zero.  A  expressão  Inf  –  Inf  
produzirá   NaN   como   resultado.   De   forma   semelhante   à   anterior   existe   também   uma  
função  [Link].  
 

Exercícios  resolvidos  
 
1.    
i)  Crie  duas  variáveis  x  e  y  com  valores  numéricos  inteiros.    
ii)  Calcule  a  sua  soma,  subtração,  multiplicação,  divisão,  divisão  inteira  e  resto  da  divisão  
inteira.  
 
> x=20
> y=7
                                                                                                                         
1
NA deriva de “Not available”

  26  
> x+y
[1] 27
> x/y
[1] 2.857143
> x*y
[1] 140
> x%%y
[1] 6
> x%/%y
[1] 2
 
2.  Calcule  o  seno,  o  coseno  e  a  tangente  de  π/6  .  
 
> a = pi/6
> cos(a)
[1] 0.8660254
> sin(a)
[1] 0.5
> tan(a)
[1] 0.5773503
 
3.    
i)  Defina  uma  variável  com  a  sequência  dos  números  ímpares  menores  do  que  40.  
ii)  Calcule  a  soma  deste  vector.  
iii)  Selecione  os  membros  desta  sequência  que  são  múltiplos  de  3.  
iv)  Calcule  a  divisão  da  sequência  obtida  em  iii)  por  3.    
 
> si = seq(1,39,2)
> si
[1] 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39
> sum(si)
[1] 400
> si[si%%3==0]
[1] 3 9 15 21 27 33 39
> si[si%%3==0] / 3
[1] 1 3 5 7 9 11 13
 
4.  Calcule  a  soma  dos  números  inteiros  pares  menores  do  que  1000.  
 
> sum(seq(2,998,2))
[1] 249500

  27  
5.  Defina  um  vetor  com  a  raiz  quadrada  dos  números  inteiros  de  1  até  20.  
 
> sqrt(1:20)
[1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490 2.645751 2.828427
[9] 3.000000 3.162278 3.316625 3.464102 3.605551 3.741657 3.872983 4.000000
[17] 4.123106 4.242641 4.358899 4.472136

 
6.    
i)  Defina  um  vetor  p  com  os  20  primeiros  números  naturais.    
ii)  Calcule  o  vetor  inverso  de  p.    
iii)  Calcule  o  vetor  soma  de  p  com  o  seu  inverso.    
iv)  Calcule  o  vetor  resultante  de  somar  a  constante  3  a  cada  elemento  de  p.    
v)  Calcule  o  vetor  1/p.  
 
> p = 1:20
> rev(p)
[1] 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
> p+rev(p)
[1] 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21
> p+3
[1] 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
> 1/p
[1] 1.000000 0.500000 0.333333 0.250000 0.200000 0.166667
[7] 0.142857 0.125000 0.111111 0.100000 0.090909 0.083333
[13] 0.076923 0.071428 0.066667 0.062500 0.058823 0.055556
[19] 0.052631 0.050000
 
7.    
i)  Crie  uma  variável  do  tipo  string  fazendo  cor  =  “azul”.  Verifique  o  seu  valor.    
ii)  Crie  uma  outra  variável  cor2,  atribuindo-­‐lhe  o  valor  “amarelo”.  
iii)  Teste  a  função  paste  para  criar  uma  variável  que  seja  a  junção  de  ambas  as  variáveis  
anteriores.  
 
> cor="azul"
> cor2 = "amarelo"
> paste(cor, cor2)
[1] "azul amarelo"
 
8.   Dada   uma   string   com   um   nome,   substitua   o   primeiro   carácter   pela   letra   maiúscula  
correspondente.    

  28  
  
> nome="paulo"
> paste(toupper(substr(nome,1,1)),substr(nome,2,nchar(nome)),sep="")
[1] "Paulo"
 
9.   Dado   um   vetor   com   números   de   alunos,   um   vetor   com   os   seus   nomes   e   um   vetor   com  
as   suas   notas,   criar   um   vetor   de   strings   com   elementos   na   forma:     “número   –   nome   –  
nota”.  
   
> numeros = c(23, 37, 51)
> nomes = c("Joao", "Pedro", "Joaquim")
> notas = c(10, 12, 14)
> paste (numeros, nomes, notas, sep=" - ")
[1] "23 - Joao - 10" "37 - Pedro - 12" "51 - Joaquim - 14"
 
   

  29  
3.  Estruturas  de  dados  e  funções    
 
 
Neste   capítulo   abordar-­‐se-­‐ão   diversas   estruturas   de   dados   primitivas   do   R,   as  
suas  capacidades  e  principais  funções.  Cobrir-­‐se-­‐ão  os  casos  das  matrizes,  arrays,  lists  e  
data  frames.  
 

3.1  Matrizes  
 
O  R  permite  definir  matrizes  de  uma  forma  bastante  similar  ao  conceito  de  vetor,  
mas  agora  com  duas  dimensões  de  dados:  as  linhas  e  as  colunas.  Uma  matriz  pode  ser  
criada  usando  a  função  matrix,  que  toma  como  argumentos  um  vetor  com  os  dados,  o  
número  de  linhas  e  o  número  de  colunas:  
 
> mat = matrix(1:20, 4, 5)
> mat
[,1] [,2] [,3] [,4] [,5]
[1,] 1 5 9 13 17
[2,] 2 6 10 14 18
[3,] 3 7 11 15 19
[4,] 4 8 12 16 20
 
Os  comandos  cbind  e  rbind  permitem  definir  matrizes  de  outras  formas.  Veja  os  
exemplos   dados   a   seguir.   Repare   que   cbind   junta   colunas   (sejam   estas   simples   vectores  
ou  mesmo  matrizes)  e  rbind  junta  linhas  (podendo,  tal  como  cbind,  estas  serem  vetores  
ou  matrizes).  
 
> x=1:10
> m1 <- cbind(x, x^2, x^3)
> m1
x
[1,] 1 1 1
[2,] 2 4 8
[3,] 3 9 27
[4,] 4 16 64
[5,] 5 25 125
[6,] 6 36 216
[7,] 7 49 343

  30  
 [8,] 8 64 512
[9,] 9 81 729
[10,] 10 100 1000
> rbind(m1, c(20, 40, 60))
x
[1,] 1 1 1
[2,] 2 4 8
[3,] 3 9 27
[4,] 4 16 64
[5,] 5 25 125
[6,] 6 36 216
[7,] 7 49 343
[8,] 8 64 512
[9,] 9 81 729
[10,] 10 100 1000
[11,] 20 40 60
 
A   indexação   de   elementos   na   matriz   faz-­‐se   de   uma   forma   semelhante   ao   dos  
vetores,   indicando-­‐se   agora   entre   parêntesis   retos   o   valor   da   linha   e   o   da   coluna  
separados  por  uma  vírgula:  
 
> mat[2,3]
[1] 10
> mat[1:2,4:5]
[,1] [,2]
[1,] 13 17
[2,] 14 18
 
O   valor   da   linha   ou   da   coluna   poderão   ser   omitidos,   tendo   como   resultado   um  
vetor  que  representa  toda  uma  linha  ou  toda  uma  coluna:  
 
> mat[2,]
[1] 2 6 10 14 18
> mat[,1]
[1] 1 2 3 4
> mat[2:3,]
[,1] [,2] [,3] [,4] [,5]
[1,] 2 6 10 14 18
[2,] 3 7 11 15 19
 
A   função   [Link]   pode   ser   usada   para   determinar   se   uma   variável   é   uma  
matriz.   As   dimensões   de   uma   matriz   podem   obter-­‐se   usando   as   funções   nrow   para   o  

  31  
número  de  linhas  e  ncol  para  o  número  de  colunas.  A  função  dim   dá  um  vector  com  os  
dois  valores  anteriores:  
 
> dim(mat)
[1] 4 5
> nrow(mat)
[1] 4
> ncol(mat)
[1] 5
 
É  possível  alterar  as  dimensões  de  uma  matriz  usando  a  função  dim  para  atribuir  
um  novo  vetor:  
 
> mat1 = matrix(8:1,4,2)
> mat1
[,1] [,2]
[1,] 8 4
[2,] 7 3
[3,] 6 2
[4,] 5 1
> dim(mat1) = c(2,4)
> mat1
[,1] [,2] [,3] [,4]
[1,] 8 6 4 2
[2,] 7 5 3 1
 
As   operações   aritméticas   funcionam   nas   matrizes   de   forma   semelhante   ao   que  
acontece   com   os   vetores.   Podem   também   aplicar-­‐se   a   matrizes   muitas   das   funções  
definidas   no   âmbito   dos   vetores   numéricos,   sendo   neste   caso   aplicadas   a   todos   os  
elementos   da   matriz,   gerando   uma   nova   matriz   com   as   mesmas   dimensões.   Em   seguida,  
mostram-­‐se  alguns  exemplos:  
 
> mean(mat)
[1] 10.5
> sqrt(mat[2:3,3:4])
[,1] [,2]
[1,] 3.162278 3.741657
[2,] 3.316625 3.872983
> cos(pi*mat)
[,1] [,2] [,3] [,4] [,5]
[1,] -1 -1 -1 -1 -1
[2,] 1 1 1 1 1

  32  
[3,] -1 -1 -1 -1 -1
[4,] 1 1 1 1 1
 
Existem   algumas   diferenças   nas   funções   da   família   apply,   que   permitem   a  
aplicação   de   uma   função   a   todos   os   elementos   de   um   vetor/   matriz.   De   facto,   para  
matrizes   é   definida   a   função   apply   que   permite   a   aplicação   de   uma   mesma   função   a  
todas   as   linhas   ou   a   todas   as   colunas   de   uma   matriz.   Assim,   esta   função   toma   como  
argumentos   a   matriz,   a   dimensão   (1   para   as   linhas,   2   para   as   colunas)   e   o   nome   da  
função.  O  exemplo  seguinte  define  um  vetor  com  a  soma  das  linhas  de  uma  matriz:  
   
> apply(mat, 1, sum)
[1] 45 50 55 60
 
Em   relação   aos   operadores   aritméticos   existe   um   operador   que   apenas   pode   ser  
aplicado   a   duas   matrizes:   a   multiplicação   de   matrizes,   que   se   representa   em   R   pelos  
símbolos  %*%  (note-­‐se  que  o  símbolo  *  denota  a  multiplicação  de  uma  matriz  por  um  
escalar  ou  por  um  vetor):  
 
> A = matrix(1:4,2,2)
> B = matrix(4:1,2,2)
> C= A%*%B
> C
[,1] [,2]
[1,] 13 5
[2,] 20 8
 
Existem  ainda  algumas  funções  que  são  próprias  do  cálculo  sobre  matrizes,  das  
quais  se  podem  salientar:  
• t:  calcula  a  matriz  transposta  de  uma  matriz;  
• det:  calcula  o  determinante  de  uma  matriz;  
• eigen:   calcula   valores   e   vetores   próprios   de   uma   matriz   (o   resultado   é  
uma  list,  estrutura  de  dados  que  será  abordada  no  final  deste  capítulo).  
• solve:   resolve   sistemas   de   equações   lineares,   recebendo   como  
argumento   a   matriz   de   coeficientes   das   variáveis   e   o   vetor   de   termos  
independentes.  
 
Alguns  exemplos:  
 

  33  
> t(C)
[,1] [,2]
[1,] 13 20
[2,] 5 8
> det(C)
[1] 4
 
Se  quisermos  usar  a  função  solve  para  resolver  o  seguinte  sistema  de  equações:  
x1  +  3x2  =  1  
2x1  +  4x2  =  3  
 
> A = matrix(1:4,2,2)
> b = c(1,3)
> solve (A,b)
[1] 2.5 -0.5
 
O  resultado  é  um  vetor  com  os  valores  de  x1  e  x2.  

3.2  Arrays  
 
Os  arrays  constituem  uma  generalização  das  matrizes  ao  caso  mais  genérico  de  
N  dimensões.  De  facto,  uma  matriz  é  no  R  um  caso  particular  de  um  array  com  N=2.  
Os   arrays   podem   criar-­‐se   usando   a   função   array,   especificando   os   dados   e   o  
vector  dim.   O   vetor   dim   terá   N   valores,   indicando   em   cada   posição   a   dimensão   do   array  
para  essa  coordenada.  Por  exemplo:  
 
> a = array(1:24, c(4,3,2))
> a
, , 1
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
, , 2
[,1] [,2] [,3]
[1,] 13 17 21
[2,] 14 18 22
[3,] 15 19 23
[4,] 16 20 24
 

  34  
 As   formas   de   indexação   e   as   funções   definidas   anteriormente   para   vetores   e  
matrizes  têm  uma  generalização  bastante  intuitiva  para  o  nível  dos  arrays,  como  se  pode  
verificar  nos  seguintes  exemplos  ilustrativos:  
 
> a[3,2,2]
[1] 19
> a[3,2,]
[1] 7 19
> a[,,1]
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
> sum(a)
[1] 300
> mean(a[1,,])
[1] 11
> cos(pi*a[1,,])
[,1] [,2]
[1,] -1 -1
[2,] -1 -1
[3,] -1 -1
 

3.3  Lists  
 
Os  objetos  do  tipo  list  constituem  no  R  estruturas  de  dados  alternativas  quando  
pretendemos   agrupar   variáveis   de   tipos   diferentes   num   mesmo   objeto.   Um   objeto   do  
tipo   list   constitui   assim   um   conjunto   de   variáveis,   designadas   por   componentes,   sendo  
cada  um  destes  identificado  por  um  nome.  Estes  objetos  podem  ser  criados  através  da  
função  list,  indicando-­‐se  os  nomes  dos  componentes  e  os  seus  conteúdos:  
 
> auto = list(marca="ford", modelo="fiesta", nportas=5,
velocMax=155, consumos=c(6,7.1,9.3))
> auto
$marca
[1] "ford"
$modelo
[1] "fiesta"
$nportas
[1] 5

  35  
$velocMax
[1] 155
$consumos
[1] 6.0 7.1 9.3
 
Uma  lista  pode  ser  indexada  de  várias  formas.  Assim,  a  indexação  com  []  devolve  
uma   nova   lista   com   o(s)   campo(s)   selecionados.   Por   outro   lado,   a   indexação   com   $  
seguido   do   nome   do   campo   permite   obter   a   variável   correspondente   a   esse   campo.   Esta  
última  forma  é  equivalente  à  indexação  com  [[  ]]  usando  um  índice  numérico.  Seguem-­‐se  
alguns  exemplos  ilustrativos:  
 
> auto[2:3]
$modelo
[1] "fiesta"
$nportas
[1] 5
> [Link](auto)
[1] TRUE
> auto[[1]]
[1] "ford"
> auto$marca
[1] "ford"
> auto$consumos[1]
[1] 6
 
No  exemplo  anterior,  a  função  [Link]  testa  se  um  objecto  é,  ou  não,  uma  lista.  A  
função  length  aplicada  sobre  uma  lista  retorna  o  número  de  componentes  da  lista.  
 

3.4  Data  frames  

 
Os   data   frames   constituem   tipos   especiais   de   lists   onde   os   componentes   são  
vetores   numéricos   ou   fatores   e   todos   eles   têm   o   mesmo   comprimento.   Os   vetores   de  
strings  dentro  de  um  data  frame  são  convertidos  para  vetores  de  fatores.  Assim,  o  data  
frame  permite  a  co-­‐existência  de  variáveis  numéricas  e  de  variáveis  discretas  (também  
designadas   por   categóricas   ou   nominais).     Por   esta   razão,   o   data   frame   constitui   a  
estrutura  de  dados  mais  usada  em  R  para  a  tarefas  de  análise  de  dados.  Os  data   frames  
podem   ainda   ser   encarados   como   matrizes   especiais   onde   pode   haver   um   tipo   diferente  
para  cada  coluna.    

  36  
 Um  data  frame  pode  ser  construído  usando  a  função  [Link],  definindo-­‐se  os  
diversos  vetores  que  o  constituem  como  se  pode  observar  no  exemplo  ilustrativo  que  se  
segue:  
 
> racas = c("bulldog", "rafeiro", "doberman", "rafeiro", "bulldog",
"rafeiro", "rafeiro", "doberman")
> pesos = c(12, 15, 35, 10, 20, 8, 13, 25)
> tamanhos = c("medio", "medio", "grande", "pequeno", "grande",
"pequeno", "medio", "grande")
> df = [Link](racas, tamanhos, pesos)
> df
racas tamanhos pesos
1 bulldog medio 12
2 rafeiro medio 15
3 doberman grande 35
4 rafeiro pequeno 10
5 bulldog grande 20
6 rafeiro pequeno 8
7 rafeiro medio 13
8 doberman grande 25
 
O  acesso  a  cada  um  seus  componentes  (ou  campos)  pode  ser  efetuado  da  mesma  
forma   que   se   acede   a   qualquer   lista   com   o   símbolo   $.   Adicionalmente,   dada   a   sua  
semelhança   estrutural   com   matrizes,   podem   usar-­‐se   nos   data  frames   os   mesmos   tipos  
de  indexação  que  se  definiram  para  as  matrizes.  Vejam-­‐se  alguns  exemplos  ilustrativos  
com  o  data  frame  anteriormente  criado:  
 
> df$tamanhos
[1] medio medio grande pequeno grande pequeno medio grande
Levels: grande medio pequeno
> df$pesos[1:4]
[1] 12 15 35 10
> df[2,2]
[1] medio
Levels: grande medio pequeno
> df[1:3,]
racas tamanhos pesos
1 bulldog medio 12
2 rafeiro medio 15
3 doberman grande 35
> df[,2]
[1] medio medio grande pequeno grande pequeno medio grande
Levels: grande medio pequeno

  37  
  
Os   mecanismos   de   indexação   do   data   frame   são   também   semelhantes   aos   de  
vetores  e  matrizes  no  que  diz  respeito  à  aplicação  de  filtros  usando  condições  ou  vetores  
lógicos.  Vejam-­‐se  alguns  exemplos:  
 
> df[df$racas=="bulldog",]
racas tamanhos pesos
1 bulldog medio 12
5 bulldog grande 20
> df[df$racas=="bulldog" & df$tamanhos=="medio",]
racas tamanhos pesos
1 bulldog medio 12
> vl = df$pesos > 12
> vl
[1] FALSE TRUE TRUE FALSE TRUE FALSE TRUE TRUE
> df[vl,]
racas tamanhos pesos
2 rafeiro medio 15
3 doberman grande 35
5 bulldog grande 20
7 rafeiro medio 13
8 doberman grande 25
 
Um  data  frame  pode  ser  editado  com  a  função  edit:  
 
> df1=edit(df)
 
Neste  caso,  podem  fazer-­‐se  alterações  ao  data  frame  df  e  estas  ficarão  guardadas  
no   data   frame   df1.   As   alterações   poderão   envolver   adicionar   novas   linhas   (novos  
exemplos),  novas  variáveis  ou  simplesmente  alterar  os  valores.  
Para   criar   com   esta   interface   um   novo   data   frame   deverá   iniciar-­‐se   o   edit   com  
um  [Link]  vazio:  
 
> df2 = edit([Link]())
 
O  R  possui  alguns  conjuntos  de  dados  internos,  que  podem  ser  listados  fazendo  
data().  Cada  um  destes  pode  ser  carregado  usando  a  função  data  e  indicando  o  nome  do  
conjunto  de  dados  como  argumento.  Pode,  ainda,  listar-­‐se  os  datasets  associados  a  um  
determinado  package  com  data(package=”...”).  

  38  
 Nos   exemplos   seguintes,   ir-­‐se-­‐á   usar   o   conjunto   de   dados   íris   que   tem   5  
componentes  (4  numéricas  e  1  fator).  Note  a  utilização  da  função  dim  para  determinar  o  
tamanho  do  data   frame,  da  função  names  para  listar  os  campos  e  da  função  head  para  
listas  os  primeiros  elementos  do  data  frame  (uma  vez  que  estes  são  frequentemente  de  
grande  dimensão  esta  função  tem  bastante  utilidade).  Dá-­‐se  ainda  um  primeiro  exemplo  
de  um  filtro  sobre  o  data  frame.  
 
> data(iris)
> dim(iris)
[1] 150 5
> names(iris)
[1] "[Link]" "[Link]" "[Link]" "[Link]"
"Species"
> head(iris)
[Link] [Link] [Link] [Link] Species
1 5.1 3.5 1.4 0.2 setosa
2 4.9 3.0 1.4 0.2 setosa
3 4.7 3.2 1.3 0.2 setosa
4 4.6 3.1 1.5 0.2 setosa
5 5.0 3.6 1.4 0.2 setosa
6 5.4 3.9 1.7 0.4 setosa
> iris[iris$[Link]>7.6,]
[Link] [Link] [Link] [Link] Species
118 7.7 3.8 6.7 2.2 virginica
119 7.7 2.6 6.9 2.3 virginica
123 7.7 2.8 6.7 2.0 virginica
132 7.9 3.8 6.4 2.0 virginica
136 7.7 3.0 6.1 2.3 virginica
> table(iris$Species)
setosa versicolor virginica
50 50 50
> tapply(iris$[Link],iris$Species,mean)
setosa versicolor virginica
1.462 4.260 5.552
 
Uma  forma  alternativa  de  realizar  a  filtragem  de  dados  é  o  uso  da  função  subset.  
A  melhor  forma  de  se  perceber  o  seu  uso  é  através  de  alguns  exemplos.  
 
> subset(iris, subset=iris$[Link]>6.5)
[Link] [Link] [Link] [Link] Species
106 7.6 3.0 6.6 2.1 virginica
118 7.7 3.8 6.7 2.2 virginica
119 7.7 2.6 6.9 2.3 virginica

  39  
123 7.7 2.8 6.7 2.0 virginica
> subset(iris, subset=iris$[Link]<0.2, select=c(Species,
[Link]))
Species [Link]
10 setosa 0.1
13 setosa 0.1
14 setosa 0.1
33 setosa 0.1
38 setosa 0.1
 
 
Ao  trabalhar  repetidamente  sobre  o  mesmo  data  frame  pode  tornar-­‐se  cansativo  
usar  sempre  os  nomes  completos  dos  campos  com  o  símbolo  $.  Uma  opção  para  tornar  
mais   direto   o   uso   de   um   data  frame   e   sua   indexação   passa   pela   operação   de  attachment.  
Esta   permite   usar   os   campos   do   data   frame   como   se   se   tratassem   de   variáveis.   Este  
processo  é  iniciado  com  a  função  attach  e  terminado  com  a  função  detach.  Veja-­‐se  um  
exemplo:    
 
> attach(iris)
> Species[1:3]
[1] setosa setosa setosa
Levels: setosa versicolor virginica
> detach(iris)
> Species
Error: object 'Species' not found
 

3.5  Conversões  entre  estruturas  de  dados  

 
O   R   disponibiliza   um   conjunto   de   funções   que   permitem   converter   objetos   de  
vários   tipos   em   objetos   de   tipos   diferentes,   sempre   que   tal   faz   sentido.   Estas   funções  
têm   tipicamente   um   nome   iniciado   por   as   e   seguido   do   tipo   para   o   qual   se   quer  
converter.  Assim:  
• A   função   [Link]   permite   converter   objetos   de   vários   tipos   em   vetores;   por  
exemplo   pode   ser   aplicado   a   uma   matriz   dando   os   seus   valores   de   forma  
linearizada  
• A   função   [Link]   permite   converter   objetos   em   matrizes;   pode   por   exemplo  
ser  usada  sobre  um  data  frame  dando  uma  matriz  numérica  se  o  data  frame  só  
tiver  campos  numéricos  ou  uma  matriz  de  strings  se  o  data  frame  tiver  strings  

  40  
 ou   fatores   (neste   último   caso,   os   valores   numéricos   são   transformados   em  
strings)  
• A   função   [Link]   permite   converter   outros   objetos   em   [Link];   um  
exemplo   é   a   conversão   de   uma   matriz,   sendo   criado   um   campo   para   cada   coluna  
da  matriz.  
 
 

Exercícios  resolvidos  
 
1.    
i)  Crie  uma  matriz  com  2  linhas  e  3  colunas,  com  os  números  inteiros  de  1  a  6.    
ii)  Identifique  a  linha  2  da  matriz  e  a  coluna  3.    
iii)  Verifique  as  dimensões  da  matriz.    
iv)  Calcule  a  soma  dos  elementos  da  matriz.    
v)  Calcule  a  soma  dos  elementos  da  1ª  linha.    
vi)  Crie  um  vetor  cujos  elementos  sejam  as  médias  dos  valores  de  cada  coluna.  
 
> mat = matrix(1:6,2,3)
> mat[2,]
[1] 2 4 6
> mat[,3]
[1] 5 6
> dim(mat)
[1] 2 3
> typeof(dim(mat))
[1] "integer"
> class(dim(mat))
[1] "integer"
> sum(mat)
[1] 21
> sum(mat[1,])
[1] 9
> v = c(mean(mat[,1]), mean(mat[,2]), mean(mat[,3]))
> v
[1] 1.5 3.5 5.5
 
2.    
i)  Defina  um  vetor  com  os  valores  entre  1  e  100.    
ii)  Transforme  o  vetor  anterior  numa  matriz  de  dimensões  10x10.  

  41  
iii)   Coloque   a   dimensão   da   matriz   em   ii)   como   c(100).   Qual   a   diferença   do   vetor   que  
criou  em  i)  e  o  objeto  que  tem  agora?  
 
> uv = 1:100
> dim(uv)= c(10,10)
 
3.    
i)  Crie  um  array  tri-­‐dimensional  com  as  dimensões  2,5,3  e  os  trinta  primeiros  números  
inteiros.    
ii)  Calcule  a  soma  dos  elementos  do  array  cujo  valor  na  segunda  dimensão  é  3.  
iii)  Calcule  a  média  dos  valores  que  têm  nas  primeiras  duas  dimensões  1.  
iv)  Calcule  o  array  que  se  obtém  multiplicando  todos  os  valores  do  array  anterior  por  2  
e  somando  a  constante  3.  
 
> a=array(1:30, c(2,5,3))
> sum(a[,3,])
[1] 93
> mean(a[1,1,])
[1] 11
> a*2+3
 
4.    
i)   Defina   duas   matrizes:   a   matriz   A   com   dimensões   2   x   3   e   com   o   valor   2   em   todas   as  
células;  a  matriz  B  com  dimensões  2  x  3  e  os  valores  entre  1  e  6  
ii)  Calcule  A+  B  (com  o  operador  aritmético  +)  
iii)  Altere  as  dimensões  da  matriz  B  para  que  fique  com  3  x  2  
iv)  Calcule  a  multiplicação  de  A  por  B.  
 
> A = matrix(2,2,3)
> B = matrix(1:6,2,3)
> A+B
[,1] [,2] [,3]
[1,] 3 5 7
[2,] 4 6 8
> dim(B)=c(3,2)
> A%*%B
[,1] [,2]
[1,] 12 30
[2,] 12 30
 

  42  
5.    
i)  Defina  uma  variável  l  como  uma  list  com  dois  campos:  nome  =  “João”  e  idade  =  30.    
ii)  Veja  o  conteúdo  de  l,  aceda  ao  campo  nome  e  ao  campo  idade  com  $  e  [[  ]].  
 
> l = list(nome="Joao",idade=30)
> l
$nome
[1] "Joao"
$idade
[1] 30
> l[[2]]
[1] 30
> l$idade
[1] 30
 
6.    
i)  Carregue  o  conjunto  de  dados  pressure.  
ii)   Calcule   a   média   dos   valores   de   pressão   (campo   pressure)   de   todos   os   elementos   do  
conjunto  de  dados.  
iii)  Verificar  qual  é  a  pressão  para  uma  temperatura  de  320.  
iv)  Calcular  o  máximo  de  pressão  que  se  pode  obter  com  temperaturas  menores  do  que  
100.  
v)  Crie  um  novo  data  frame  com  todas  as  linhas  com  pressão  menor  do  que  100.  
 
> data(pressure)
> mean(pressure$pressure)
> pressure[pressure$temperature==320,2]
> max(pressure[pressure$temperature<100,2])
> pressure[pressure$pressure<100,]
 
7.   Carregue   o   conjunto   de   dados   sleep.   Verifique   os   tipos   de   dados   de   cada   campo.  
Calcule  a  média  do  campo  extra  para  um  dos  grupos  (campo  group).  
 
> data(sleep)
> class(sleep)
> mapply(class,sleep)
> tapply(sleep$extra,sleep$group,mean)
   

  43