Tipos de dados, variáveis e vetores

Tipos de dados

No R existem os seguintes tipos de dados e variáveis:

Tipo de Dado Exemplo
Lógico (Logic) TRUE, FALSE
Numérico (Numeric) 12.3, 5, 999
Inteiro (Integer) 2L, 34L, 0L
Complexo (Complex) 1 + 2i
Caracter (Character) ‘a’, “Bom dia”, “TRUE”, ‘23.4’
(Raw) “Bom dia” é armazenado como 42 6f 6d 20 64 69 61
*Em R não existem, de fato, escalares. Eles são representados por vetores com um único componente.

Com estes dados (e variáveis) se pode construir objetos predefinidos e mais complexos: eles são os escalares* (scalars), vetores (vectors), matrizes (matrices), arrays (matrizes em dimensões maiores que m × n), data frames e listas (lists).

Observe que R é sensível ao caso. TESTE, Teste e teste são variáveis diferentes. Os valores lógicos devem ser escritos em maiúsculas (mas podem ser abreviados para T e F).

Com frequência mencionaremos o nome de uma entidade em inglês para facilitar a leitura dos textos abundantes na internet. Em alguns casos podemos manter a nomenclatura original, em inglês.

Variáveis e vetores

e <- 154 # um escalar, numérico
l <- "pedro" # um escalar, caracter

a <- c(1, 3, 9.5, 6, -2, 4) # vetor numérico
b <- c("um", "dois", "três") # vetor de caracter
c <- c(TRUE, TRUE, FALSE, TRUE, FALSE) # vetor lógico

Todos os componentes de um vetor devem ser do mesmo tipo.

> # um escalar pode ser criado assim:
> x <- 10
> x
[1] 10
> print(x)
[1] 10
> # um vetor é criado usando o operador c()
> vetor_numerico <- c(1.2, 3.4, 5, 7, 8)
> vetor_numerico
[1] 1.2 3.4 5.0 7.0 8.0
> vetor_string <- c("a", "b", "c", "d")
> vetor_string
[1] "a" "b" "c" "d"
> vetor_logico <- c(FALSE, TRUE, TRUE)
> vetor_logico
[1] FALSE  TRUE  TRUE
> vetor_inteiros <- c(12L, 15L, 18L)
> vetor_inteiros
[1] 12 15 18
> # a classe de um objeto pode ser consultada com a função class()
> class(vetor_inteiros)
[1] "integer"
> class(vetor_logico)
[1] "logical"
> # O primeiro componente do vetor_numerico é
> vetor_numerico[1]
[1] 1.2
> # Seu comprimento
> length(vetor_numerico)
[1] 5
> # Podemos então obter seu último componente
> vetor_numerico[length(vetor_numerico)]
[1] 8
> # O terceiro e o quinto componentes são
> vetor_numerico[c(3, 5)] # 2nd and 4th elements of vector
[1] 5 8
> # O vetor v = (1, 2, 3, 4, 5, 6) pode ser criado com
> v <- c(1:6)
> v
[1] 1 2 3 4 5 6
> # Desta forma podemos obter 4 (por ex.)
> # elementos sequenciados de vetor_numerico
> vetor_numerico[(1:4)]
[1] 1.2 3.4 5.0 7.0
# Um componente pode ser alterado a qualquer momento
> vetor_numerico[1] <- 0
> vetor_numerico
[1] 0.0 3.4 5.0 7.0 8.0
# Novos componentes podem ser inseridos
> vetor_numerico[6] <- 203
> vetor_numerico
[1]   0   3   5   7   8 203
> Observe que o operador c concatena vetores
> frutas <- c("maçã","laranja")
> verduras <- c("alface", "brocolis","couve")
> c(frutas, verduras)
[1] "maçã"  "laranja"  "alface"  "brocolis"  "couve"

> # Em R um objeto é dinâmicamente modificado para acomodar uma atribuição
> w <- 1:3
> w[7] <- 17
> w
[1]  1  2  3 NA NA NA 17
NA é uma constante interna representando um valor ausente ou não disponível, Not Available.

Diferente do que ocorre na maioria das linguagens de programação os índices são contados à partir de 1 (e não 0).

Usamos os seguintes novos operadores:

Operador Efeito
v <- c(1:6) cria* o vetor v = (1, 2, 3, 4, 5, 6)
v <- c(a1, ..., an) cria o vetor v = (a1, ..., an), de comprimento n
v[r] retorna o r-ésimo componente, ar, se r ≤ n, NA caso contrário
v[c(p, q)] retorna componentes ap e aq
v[r] <- 5 substitui o valor de ar se r ≤ n, insere caso contrário
lenght(v) retorna o comprimento do vetor, lenght(v) = n neste caso.
*Mencionamos que o operador c concatena vetores.

Como já foi usado acima, podemos filtrar um vetor para pegar apenas alguns de seus componentes. Para ilustrar esta operação vamos criar um longo vetor e, a partir dele construir outro vetor apenas com algumas de suas componentes:

> u <- 1:10 # forma resumida de c(1:10)
> filtro <- c(T,T,T,F,F,F,T,T,T,F) # resumindo T = TRUE, F = FALSE
> u[filtro]
[1] 1 2 3 7 8 9
> # Observe ainda que podemos excluir o terceiro elemento
> u[-3]
[1]  1  2  4  5  6  7  8  9 10
> # ou todos os elementos entre o terceiro e o quinto, inclusive
> u[-3:-5]
[1]  1  2  6  7  8  9 10
> # Podemos atribuir este vetor filtrado a outra variável, para uso futuro
> novo_u <- u[-3:-5]
> # e remover o antigo, caso ele não seja mais necessário
> rm(u)
> # Se um valor for inserido o vetor muda de comprimento
> u[12] <- 100
> u
[1] 1 2 3 4 5 6 7 8 9 10 NA 100
> # A posição 11 fica indeterminada (NA)

> # A função seq fornece uma forma adicional de criar um vetor
> # onde se fornece os valores inicial e final e o acréscimo (ou passo)
> v2 <- seq(from=0, to=3, by=.25)
> v2
[1] 0.00 0.25 0.50 0.75 1.00 1.25 1.50 1.75 2.00 2.25 2.50 2.75 3.00
> # Um vetor pode ser repetido dentro de outro vetor maior
> v <- 1:3    # um shortcut para c(1:3)
> rep(v, times=3)
[1] 1 2 3 1 2 3 1 2 3
# Para repetir cada componente 2 vezes
> rep(v, each=2)
[1] 1 1 2 2 3 3
> # Podemos especificar quantas vezes repetir cada componente
> # No ex. abaixo repetir o primeiro componente 4 x, o segundo 2
> rep(c(0, 7), times = c(4,2))
[1] 0 0 0 0 7 7
> rep(v, times = c(1,0,3))
[1] 1 3 3 3
> # Repetir um vetor até obter outro de comprimento length.out
> rep(v,length.out=7)
[1] 1 2 3 1 2 3 1
> # Além das funções rep e seq podemos usar:
> # any: testa se algum elemento do vetor satisfaz uma condição
> any(v > 2)
[1] TRUE
>  any(v >= 4)
[1] FALSE
> # all: testa se todos os elementos do vetor satisfazem uma condição
> all(v > 2)
[1] FALSE
>  all(v >= 0)
[1] TRUE

Resumindo, usamos:

Função Efeito
rep(v, times = n) repete o vetor v n vezes
rep(v, times = c(r, s)) repete o primeiro componente r vezes, o segundo s vezes
rep(v, each = n) repete o vetor v, cada componente n vezes
rep(v, lenght.out = l) repete o vetor v até atingir um vetor de comprimento l
any(v condição) verifica se algum componente de v satisfaz à condição
all(v condição) verifica se todos os componentes de v satisfazem à condição

Um vetor vazio pode ser criado através da função vector(). O vetor pode ser populado em seguida. Além disso vetores possuem o atributo names que é também um vetor. Ele permite atribuir nomes aos componentes do vetor, como mostrado abaixo:

> # Cria um vetor vazio (inicialmente um vetor lógico)
> v <- vector()
> v
logical(0)
> # Popula o vetor v
> v[1] <- 1
> v[2] <- 2
> v[3] <- 3
> v
[1] 1 2 3
> is.vector(v)
[1] TRUE
# Nenhum valor foi associado a names
> names(v)
NULL
> # Popula o vetor names associado a v
> names(v)[1] <- "primeiro"
> names(v)[2] <- "segundo"
> names(v)[3] <- "terceiro"
> v
primeiro  segundo terceiro
       1        2        3
> # Alternativamente
> names(v) <- c("um", "dois" ,"três")
> v
  um dois três
   1    2    3
> # O vetor continua sendo um vetor numérico
> class(v)
[1] "numeric"
> # Um vetor pode ser criado com seu atributo names definido
> v <- c('a'=1, 'b'=2, 'c'=3)
> names(v)
[1] "a" "b" "c"
> # As aspas acima são opcionais.
> # O mesmo efeito seria obtido com v <- c(a=1, b=2, c=3)
> v
a b c
1 2 3
> # Como dito, names é um vetor. Seu primeiro componente é
> names(v)[1]
[1] "a"
> # É possível obter o componente do vetor pelo seu atributo
> pessoa <- c("nome"="Pedro","Sobrenome"="Malazartes")
> pessoa["nome"]
   nome
"Pedro"

Regras de reciclagem (recycling)

Vetores que aparecem um uma expressão não precisam, necessariamente, ter o mesmo comprimento. Caso um dos vetores seja de menor comprimento que o outro (ou outros) o resultado da expressão terá o comprimento do maior deles e os vetores menores serão reciclados (recycled). Na reciclagem eles são repetidos quantas vezes for necessário, podendo ser fracionados. Uma constante (um vetor de um elemento) é simplesmente repetido.

> u <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
> v <- c(1, 2, 3)
> u + v
[1]  2  4  6  5  7  9  8 10  12  11
> # v é reciclado para v' = (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2)
> u + 10
 [1] 11 12 13 14 15 16 17 18 19 20


Matrizes e Arrays.

Leave a Reply

Your email address will not be published. Required fields are marked *