• Objetos no R
  • Vetores
  • Matrizes e Arrays
  • Listas
• Importando Dados

• Por exemplo, vamos criar um objeto e dar o valor de \(e^1\):

x = exp(1)
x

## [1] 2.718282

• E esse objeto será da classe numeric:

class(x)

## [1] "numeric"

• Podemos usar quase qualquer nome para um objeto, exceto alguns nomes que já são usados internamente pelo R, como TRUE ou Inf.

.Machine$double.xmax    # maior numero antes de Inf

## [1] 1.797693e+308

2e+307<Inf   # verdadeiro ou falso?

## [1] TRUE

2e+308<Inf   # verdadeiro ou falso?

## [1] FALSE

• Outros objetos e classes já definidos no R:

0/0   # não está definido

## [1] NaN

pi    # 3,1416...

## [1] 3.141593

• É possível criar um objeto com o nome pi e sobreescrever o valor default, mas não é uma boa ideia. Assim como não se deve usar T e F.

• Nomes de objetos também não podem começar com números. Podemos criar os objetos x2, x_2, x.2, mas não 2x!

• Podemos criar novos objetos a partir de objetos já existentes.

y = x+1
y

## [1] 3.718282

Vai criar o objeto y com valor \(e+1\).

y também é da classe numeric e não é uma função de x, ou seja, se o valor x mudar, isso não vai afetar o valor de y.

• Um objeto da classe numeric assume valores de \(\mathbb{R}\).

• Um objeto da classe integer assume valores de \(\mathbb{Z}\).

• Um objeto da classe logical asssume valores TRUE ou FALSE.

• O melhor jeito para armazenar mais de um valor no R é usando um vetor.

x = c(-1,0,2)
x

## [1] -1  0  2

y = c(0, 2^x)
y

## [1] 0.0 0.5 1.0 4.0

• Criando vetores com sequências de números:

u = 1:50
u
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
## [26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

seq(from=0, to=1, by=.1)
##  [1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
seq(5,2,-1)
## [1] 5 4 3 2
seq(5,2,len=9)
## [1] 5.000 4.625 4.250 3.875 3.500 3.125 2.750 2.375 2.000

• Elemento “nulo”:

c(NULL,x)
## [1] -1  0  2

Útil para criar objetos para serem usados em um loop:

y = NULL
for(i in 1:10){
  y = c(y, max(sin(u[1:i])))
}
y

##  [1] 0.8414710 0.9092974 0.9092974 0.9092974 0.9092974 0.9092974 0.9092974
##  [8] 0.9893582 0.9893582 0.9893582

• É possível dar nomes aos elementos de um vetor:

names(x) = c("A","B","C")
x

##  A  B  C 
## -1  0  2

• Acessando os elementos:

x[c(3,2)]

## C B 
## 2 0

x[c("C","B")]

## C B 
## 2 0

• Quando fazemos uma operação com dois vetores de tamanhos diferentes, o menor vetor é “reciclado” até atingir o tamanho do maior vetor.

x = c(100,200,300,400,500,600,700,800)
y = c(1,2,3,4)
x+y
## [1] 101 202 303 404 501 602 703 804

y = c(1,2,3)
x+y
## Warning in x + y: comprimento do objeto maior não é múltiplo do comprimento do
## objeto menor
## [1] 101 202 303 401 502 603 701 802

• A vantagem de uma linguagem de programação baseada em vetores é a facilidade de acessar partes de um vetor:

set.seed(1)
U = runif(10)
U
##  [1] 0.26550866 0.37212390 0.57285336 0.90820779 0.20168193 0.89838968
##  [7] 0.94467527 0.66079779 0.62911404 0.06178627

U[ U > 0.8 ]
## [1] 0.9082078 0.8983897 0.9446753
U[ (U>.4) & (U<.6) ]
## [1] 0.5728534

• Também é possível retornar os índices dos elementos que satisfazem uma condição:

which( (U>.4) & (U<.6) )
## [1] 3

• E para obter o complementar:

which( !((U>.4) & (U<.5)) )
##  [1]  1  2  3  4  5  6  7  8  9 10

which( (U<=.4) | (U>=.5) )
##  [1]  1  2  3  4  5  6  7  8  9 10

• Para valores inteiros, podemos usar o teste lógico:

y

## [1] 1 2 3

y==2

## [1] FALSE  TRUE FALSE

Mas evitar quando fizer comparação entre números não inteiros (por exemplo, usar all.equal).

• Uma matriz é um vetor organizado de acordo com as dimensões especificadas por dim(): número de linhas nrow e número de colunas ncol.

M = matrix(U, nrow=5, ncol=4)
M

##           [,1]       [,2]      [,3]       [,4]
## [1,] 0.2655087 0.89838968 0.2655087 0.89838968
## [2,] 0.3721239 0.94467527 0.3721239 0.94467527
## [3,] 0.5728534 0.66079779 0.5728534 0.66079779
## [4,] 0.9082078 0.62911404 0.9082078 0.62911404
## [5,] 0.2016819 0.06178627 0.2016819 0.06178627

dim(M)

## [1] 5 4

• Podemos acessar os objetos que satisfazem uma condição do mesmo jeito que fizemos com vetores.

• Por exemplo, se quisermos as linhas de M cujo elemento da última coluna é maior do que 0.8:

M[ M[,4] > 0.8, ]

##           [,1]      [,2]      [,3]      [,4]
## [1,] 0.2655087 0.8983897 0.2655087 0.8983897
## [2,] 0.3721239 0.9446753 0.3721239 0.9446753

• Existem várias funções para manipular matrizes. Por exemplo, a função sweep() pode ser usada para aplicar uma função às linhas (MARGIN=1) ou colunas (MARGIN=2) de uma matriz.

• Por exemplo, se quisermos somar \(i\) a cada linha \(i\) da matriz M:

sweep(M, MARGIN=1, STATS=1:nrow(M), FUN="+")

##          [,1]     [,2]     [,3]     [,4]
## [1,] 1.265509 1.898390 1.265509 1.898390
## [2,] 2.372124 2.944675 2.372124 2.944675
## [3,] 3.572853 3.660798 3.572853 3.660798
## [4,] 4.908208 4.629114 4.908208 4.629114
## [5,] 5.201682 5.061786 5.201682 5.061786

• A regra de “reciclagem” também afeta as matrizes.

M = matrix(1:8, nrow=4, ncol=3, byrow=FALSE)
## Warning in matrix(1:8, nrow = 4, ncol = 3, byrow = FALSE): data length [8] is
## not a sub-multiple or multiple of the number of columns [3]

M + c(10,20,30,40,50)
## Warning in M + c(10, 20, 30, 40, 50): comprimento do objeto maior não é
## múltiplo do comprimento do objeto menor
##      [,1] [,2] [,3]
## [1,]   11   55   41
## [2,]   22   16   52
## [3,]   33   27   13
## [4,]   44   38   24

• Função para concatenar vetores: c()

• Funções para concatenar matrizes: rbind() para adicionar linhas, cbind() para adicionar colunas.

A = matrix(0,2,2)
A
##      [,1] [,2]
## [1,]    0    0
## [2,]    0    0
B = matrix(1,1,2)
B
##      [,1] [,2]
## [1,]    1    1

rbind(A,B)
##      [,1] [,2]
## [1,]    0    0
## [2,]    0    0
## [3,]    1    1
cbind(A, t(B))
##      [,1] [,2] [,3]
## [1,]    0    0    1
## [2,]    0    0    1

• Arrays são extensões multidimensionais de vetores (matrizes são arrays bidimensionais).

• Assim como vetores e matrizes, todos os elementos de um array precisam ser do mesmo tipo.

A = array(1:36 ,c(3,6,2))
A

## , , 1
## 
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]    1    4    7   10   13   16
## [2,]    2    5    8   11   14   17
## [3,]    3    6    9   12   15   18
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]   19   22   25   28   31   34
## [2,]   20   23   26   29   32   35
## [3,]   21   24   27   30   33   36

• É possível guardar diversos objetos em um único objeto usando uma lista.

lista = list(subM = M[1:2,], sequence=U)
lista
## $subM
##      [,1] [,2] [,3]
## [1,]    1    5    1
## [2,]    2    6    2
## 
## $sequence
##  [1] 0.26550866 0.37212390 0.57285336 0.90820779 0.20168193 0.89838968
##  [7] 0.94467527 0.66079779 0.62911404 0.06178627
names(lista)
## [1] "subM"     "sequence"

• Acessando elementos:

lista[[2]]

##  [1] 0.26550866 0.37212390 0.57285336 0.90820779 0.20168193 0.89838968
##  [7] 0.94467527 0.66079779 0.62911404 0.06178627

lista$sequence

##  [1] 0.26550866 0.37212390 0.57285336 0.90820779 0.20168193 0.89838968
##  [7] 0.94467527 0.66079779 0.62911404 0.06178627

• Já vimos como criar vários objetos no R, mas muitas vezes precisaremos importar objetos e dados de outras fontes.

• Por exemplo, ao fazer cálculo de seguros de vida, podemos precisar importar tabelas de vida ou histórico de rendimentos, ou ao precificar seguros de carro, precisaremos de histórico de indenizações e dados sobre as apólices.

• Para isso, vamos usar objetos do tipo dataframe, que é uma coleção de vetores nomeados de mesmo tamanho. Funciona como uma planilha ou uma tabela de banco de dados.

• A função read.table() é usada para importar um dataframe no R.

  • Todas as variáveis no arquivo original devem estar separadas por um caracter definido pelo argumento sep (pode ser espaço, tab, vírgula).

  • Se o dataframe for muito grande para visualizar, podemos usar os comandos head() e tail() para ver as primeiras ou últimas linhas dos dados.

• Para importar os dados, é preciso especificar em qual diretório o arquivo está localizado.

setwd("C:/Documents and Settings/user/Dados")
db = read.table("file.txt")

db = read.table("C:/Documents and Settings/user/Dados/file.txt")

• Vamos importar o banco de dados 'extremedatasince1899.csv' com a lista de todos os ciclones tropicais da agência nacional NHC dos EUA entre 1899-2006.

file = "../datasets/extremedatasince1899.csv"
StormMax = read.table(file, header=T, sep=",")
head(StormMax, 3)

##     Yr Region     Wmax   nao   soi        sst      sstmda sun split
## 1 1899  Basin 96.64138 -0.64 -0.21 0.05193367 -0.03133333 8.4     0
## 2 1899   East 90.19791 -0.64 -0.21 0.05193367 -0.03133333 8.4     0
## 3 1899  Basin 90.35300 -0.64 -0.21 0.05193367 -0.03133333 8.4     0

• Cada coluna é um vetor, tem um nome único e armazena um tipo de variável.

str(StormMax)   # mostra a estrutura (structure) de um objeto

## 'data.frame':    2010 obs. of  9 variables:
##  $ Yr    : int  1899 1899 1899 1899 1899 1899 1899 1899 1899 1899 ...
##  $ Region: chr  "Basin" "East" "Basin" "East" ...
##  $ Wmax  : num  96.6 90.2 90.4 37.5 51.1 ...
##  $ nao   : num  -0.64 -0.64 -0.64 -0.64 -0.64 -0.64 -0.64 -0.64 -0.64 -0.64 ...
##  $ soi   : num  -0.21 -0.21 -0.21 -0.21 -0.21 -0.21 -0.21 -0.21 -0.21 -0.21 ...
##  $ sst   : num  0.0519 0.0519 0.0519 0.0519 0.0519 ...
##  $ sstmda: num  -0.0313 -0.0313 -0.0313 -0.0313 -0.0313 ...
##  $ sun   : num  8.4 8.4 8.4 8.4 8.4 8.4 8.4 8.4 8.4 8.4 ...
##  $ split : int  0 0 0 0 0 0 0 0 0 0 ...

Observe que a função read.table converteu variáveis de texto em factors. Isso pode ser evitado usando o argumento stringsAsFactors.

• Podemos acessar a terceira coluna usando o seu nome StormMax$Wmax ou com a notação de matriz StormMax[,3].

• Podemos usar também a função attach(StormMax) e então acessar as variáveis diretamente com Wmax.

• Outra opção é usar a função with() ao executar funções com esse dataframe.

• Ordernar a base de acordo com uma variável:

set.seed(123)
df = data.frame( x1=rnorm(5), x2=sample(1:2,size=5,replace=T), x3=rnorm(5))
df

##            x1 x2         x3
## 1 -0.56047565  2  1.2805549
## 2 -0.23017749  2 -1.7272706
## 3  1.55870831  2  1.6901844
## 4  0.07050839  1  0.5038124
## 5  0.12928774  2  2.5283366

• Ordernar a base de acordo com uma variável:

(primeiro, crescente em x2, e depois decrescente em x1)

df [ order(df$x2, -df$x1), ]

##            x1 x2         x3
## 4  0.07050839  1  0.5038124
## 3  1.55870831  2  1.6901844
## 5  0.12928774  2  2.5283366
## 2 -0.23017749  2 -1.7272706
## 1 -0.56047565  2  1.2805549

• Para bases de dados muito grandes, uma estratégia é selecionar algumas colunas para importar, manualmente ou usando uma função do pacote colbycol.

• Outra opção que pode ser mais rápida é importar uma versão zipada com a função unz.

• O R usa a memória RAM do computador, e por isso tem um limite do tamanho de dados que podemos carregar. Há alguns pacotes e outras alternativas para trabalhar com bases de dados grandes no R.

• Em bases reais, pode haver dados ausentes (missing data). Esse valores normalmente são representados por NA.

• Para testar se há dados ausentes, use a função is.na(). Ela irá retornar TRUE ou FALSE.

• Para trabalhar apenas com a parte dos dados completa:

Xfull = X[!is.na(X)]

• Várias funções no R tem uma opção para como lidar com missing data (na.rm ou na.action).

• Planilhas do Excel são um formato comum para armazenamento de dados e comunicação entre profissionais como atuários.

• Como as planilhas podem ter sub-planilhas com fórmulas conectadas e outras funções, pode ser complicado ler as planilhas corretamente no R. Por isso, é recomendado extrair as informações do Excel usando um ou mais arquivos de texto, para depois importar no R.

• Para importar planilhas diretamente, ou arquivos de outros softwares, usar o pacote foreign.