Vetores no R: c(), seq(), Indexação e Matemática Vetorizada

Tudo no R É um Vetor

A maioria das linguagens tem escalares - valores únicos - e depois algum tipo de contêiner para guardar vários deles. O R pula o escalar. Um vetor é uma coleção ordenada de valores que compartilham um mesmo tipo, e é a unidade sobre a qual todo o resto é construído. Até o que parece ser um número solitário é um vetor de comprimento 1:

scores <- c(70, 85, 92)
print(scores)
print(length(scores))

print(is.vector(5))
print(length(5))

c() - abreviação de combine - é como você constrói um vetor à mão. length() diz quantos elementos ele guarda. E 5 sozinho reporta is.vector como TRUE com comprimento 1: o R nunca deixa de trabalhar com vetores, apenas às vezes trabalha com vetores bem curtos.

Esse design é o motivo pelo qual código em R parece diferente de Python ou JavaScript: operações para as quais você escreveria um laço em outra linguagem se aplicam a vetores inteiros em uma única expressão. Chegaremos lá logo abaixo.

Uma regra para internalizar agora: todos os elementos de um vetor têm o mesmo tipo. Se você entregar uma mistura ao c(), ele não reclama - converte silenciosamente tudo para o tipo mais flexível presente:

mixed <- c(1, "two", TRUE)
print(mixed)
print(class(mixed))

numish <- c(1, TRUE, FALSE)
print(numish)
print(class(numish))

Uma string na mistura transforma tudo em strings ("1", "TRUE"). Lógicos entre números viram 1 e 0. Essa coerção segue uma hierarquia fixa - lógico → inteiro → double → caractere - e acontece sem aviso, e é por isso que um "7" perdido em uma coluna de números pode transformar silenciosamente todo o seu conjunto de dados em texto. A hierarquia completa está em tipos de dados; se você precisa guardar valores genuinamente mistos, é para isso que servem as listas.

Gerando Sequências: :, seq() e rep()

Digitar cada elemento dentro de c() cansa rápido. O R tem três atalhos para padrões regulares:

print(1:10)
print(seq(0, 1, by = 0.25))
print(seq(2, 20, length.out = 4))
print(seq_len(5))

print(rep("ha", 3))
print(rep(c(1, 2), times = 3))
print(rep(c(1, 2), each = 3))

• 1:10 é o do dia a dia: inteiros de um limite ao outro, em passos de 1.
• seq() generaliza: escolha o passo com by =, ou diga quantos elementos você quer com length.out = e deixe o R calcular o espaçamento.
• seq_len(n) produz de 1 até n e é a forma segura de construir índices de laço - diferente de 1:n, ele corretamente devolve um vetor vazio quando n é 0, em vez de contar 1 0 de trás para frente.
• rep() repete: times = repete o vetor inteiro de ponta a ponta (1 2 1 2 1 2), each = repete cada elemento no lugar (1 1 1 2 2 2). Os dois são fáceis de confundir; rode o trecho e compare.

Indexação: o R Conta a Partir de 1

Colchetes extraem elementos. O primeiro elemento é [1] - não [0]. Se você está chegando de Python ou JavaScript, esse é o tropeço inicial mais comum de todos:

fruits <- c("apple", "banana", "cherry", "date")

print(fruits[1])
print(fruits[c(2, 4)])
print(fruits[-1])
print(fruits[-c(1, 2)])

Três coisas aqui merecem uma pausa:

• Você pode indexar com um vetor de posições - fruits[c(2, 4)] pega o segundo e o quarto de uma só vez.
• Índices negativos significam "tudo exceto". fruits[-1] é o vetor sem seu primeiro elemento. Isso é completamente diferente de Python, onde -1 significa o último elemento. Você não pode misturar índices positivos e negativos na mesma chamada.
• fruits[0] não é um erro - retorna um character(0) vazio. Um bug de índice deslocado em R muitas vezes produz resultados vazios silenciosos em vez de um travamento, então vale a pena checar length() quando algo mais adiante parece misteriosamente em branco.

Elementos também podem carregar nomes, o que dá uma terceira forma de indexar - por rótulo:

prices <- c(coffee = 3.5, tea = 2.8, juice = 4.2)
print(prices["tea"])
print(prices[c("coffee", "juice")])
print(names(prices))

Vetores nomeados funcionam como uma tabela de consulta leve e mantêm o código legível: prices["tea"] diz o que significa, prices[2] não.

Máscaras Lógicas e which()

A forma mais poderosa de indexar é com um vetor lógico - uma máscara de valores TRUE/FALSE do mesmo comprimento dos dados. Toda comparação sobre um vetor produz exatamente isso:

temps <- c(18, 25, 31, 22, 35)

hot <- temps > 24
print(hot)
print(temps[hot])

print(temps[temps > 24 & temps < 33])
print(which(temps > 24))

temps > 24 não dá uma resposta - dá cinco, uma por elemento. Colocar essa máscara dentro de [ ] mantém os elementos onde a máscara é TRUE. Combine condições com & (e) e | (ou), cobertos junto com o resto dos operadores.

which() traduz uma máscara em posições: aqui 2 3 5, os índices das leituras quentes. Recorra a ela quando você precisa saber onde estão as correspondências - para reportá-las, ou para indexar um vetor diferente nos mesmos pontos. Para filtragem simples, temps[temps > 24] é mais direto que temps[which(temps > 24)].

Esse padrão de filtrar-com-uma-máscara é a espinha dorsal de praticamente todo trabalho com dados no R - ele volta na hora em que você filtra linhas de um data frame.

Matemática Vetorizada e a Regra de Reciclagem

A aritmética no R se aplica elemento a elemento em vetores inteiros - nenhum laço necessário:

prices <- c(10, 20, 30)

print(prices * 2)
print(prices + c(1, 2, 3))
print(c(1, 2, 3, 4) + c(10, 20))

A primeira linha é o recurso de destaque: prices * 2 dobra cada elemento. Onde outras linguagens precisam de um laço for, o R precisa de um operador - e a forma vetorizada é ao mesmo tempo mais curta e mais rápida, porque a repetição acontece em C otimizado por baixo. Escreva um laço for quando cada passo depende do anterior; para contas elemento a elemento, vetorize.

A terceira linha mostra a regra de reciclagem: quando os vetores têm comprimentos diferentes, o R repete o mais curto para acompanhar. c(10, 20) é reciclado para 10 20 10 20, dando 11 22 13 24. Reciclar 2 sobre um vetor de comprimento 3 é exatamente o que fez prices * 2 funcionar - um escalar é apenas um vetor de comprimento 1 sendo reciclado.

A reciclagem é limpa quando o comprimento maior é um múltiplo exato do menor. Quando não é, o R ainda calcula uma resposta - e emite um aviso:

print(c(1, 2, 3) + c(10, 20))

Você recebe 11 22 13 mais um aviso de que o comprimento do objeto maior não é múltiplo do comprimento do objeto menor. Trate esse aviso como um relatório de bug: reciclagem parcial quase nunca é o que você quis dizer, e normalmente significa que dois vetores que deveriam ter o mesmo comprimento não têm.

Ordenar, Inverter, Remover Duplicatas

Três pequenos utilitários que você vai usar o tempo todo:

x <- c(3, 1, 4, 1, 5)

print(sort(x))
print(sort(x, decreasing = TRUE))
print(rev(x))
print(unique(x))

sort() ordena os valores, rev() inverte a ordem existente sem ordenar, e unique() descarta duplicatas mantendo as primeiras aparições. Nenhum deles modifica x - como quase tudo no R, eles retornam um novo vetor e deixam o original em paz.

O Que Você Leva Daqui

• Um vetor é a unidade fundamental do R: ordenado, de um único tipo do começo ao fim, e mesmo valores únicos são vetores de comprimento 1.
• Construa com c(), gere padrões com :, seq() e rep() - e lembre-se de que c() faz coerção silenciosa de tipos misturados.
• A indexação começa em 1; índices negativos removem elementos; nomes permitem indexar por rótulo.
• Máscaras lógicas (x[x > 5]) são o idioma de filtragem de toda a linguagem; which() transforma uma máscara em posições.
• A matemática é vetorizada, vetores mais curtos são reciclados, e um aviso de reciclagem parcial significa que você tem um bug.

A seguir: listas - o contêiner para quando seus valores não compartilham todos o mesmo tipo.