Um tutorial sobre loops em R — uso e alternativas

Entendendo os for loops

Essa estrutura, formada pelo retângulo de ‘init’ (inicialização), pelo losango de decisão e pelo retângulo i1, é executada um número conhecido de vezes.

Em termos de fluxograma, retângulos significam “faça algo que não envolve decisões”. Losangos (ou rombos) são “símbolos de decisão” e se traduzem em perguntas com duas respostas lógicas possíveis: verdadeiro (T) ou falso (F).

Observação: para simplificar, outros símbolos possíveis foram omitidos da figura.

Uma ou mais instruções dentro do retângulo de inicialização são seguidas pela avaliação de uma condição sobre uma variável que pode assumir valores dentro de uma sequência. No desenho, isso é representado pelo losango: os símbolos significam “o valor atual de v pertence à sequência seq?”.

Em outras palavras, você está testando se o valor atual de v está em um intervalo especificado. Normalmente você define esse intervalo na inicialização, com algo como 1:100, para garantir que o loop comece.

Se a condição não for atendida e o resultado for False, o loop nunca é executado. Isso é indicado pela seta solta à direita da estrutura do for. O programa então executa a primeira instrução após o bloco do loop.

Se a condição for satisfeita, uma instrução — ou bloco de instruções — i1 é executada. E talvez esse bloco seja outro loop. Nesse caso, falamos de loop aninhado.

Feito isso, a condição é novamente avaliada. Isso é indicado pelas linhas que vão de i1 de volta ao topo, logo após a caixa de inicialização. Em R — e em Python — é possível expressar isso em linguagem natural, perguntando se a variável pertence a um intervalo de valores.

Observação: em outras linguagens, como C, a condição é mais explícita com operadores lógicos (maior/menor que, igual a, etc.).

Exemplo simples de for loop:

# Crie um vetor com valores normais aleatórios
u1 <- rnorm(30)
print("Este loop calcula o quadrado dos 10 primeiros elementos do vetor u1")

# Inicialize `usq`
usq <- 0.

for (i in 1:10) {
    # i-ésimo elemento de `u1` ao quadrado na posição i de `usq`
    usq[i] <- u1[i] * u1[i]
    print(usq[i])
}

print(i)

O bloco for fica entre chaves. Elas podem ser colocadas logo após a condição ou na linha de baixo, de preferência com indentação. Nada disso é obrigatório, mas as chaves aumentam a legibilidade do código e facilitam encontrar o bloco do loop e possíveis erros.

Observação: o vetor de quadrados, usq, foi inicializado. Isso não seria necessário em código R puro, mas na versão com marcação, o knitr não compila porque não encontra a referência ao vetor antes do uso, gerando erro no RStudio. Para saber mais sobre knitr, acesse a página do R Markdown.

Aninhando for loops

Agora que você sabe que for loops podem ser aninhados, talvez esteja se perguntando por que e quando usar isso.

Suponha que você queira manipular um arranjo bidimensional definindo seus elementos com valores específicos.

Você poderia fazer algo assim:

# Insira um inteiro
my_int <- 42

nr <- as.integer(my_int)

# Crie uma matriz `n` x `n` com zeros
mymat <- matrix(0, nr, nr)

# Para cada linha e coluna, atribua valores com base na posição
# Esses valores são o produto de dois índices
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

Dica: para mais informações sobre a função matrix(), visite a R Documentation.

Você tem dois for loops aninhados no código acima e, portanto, dois conjuntos de chaves, cada um com seu bloco e governado pelo seu índice. Ou seja, i percorre as linhas e j percorre as colunas.

 

O que foi produzido?

# Mostre o primeiro bloco 10x10 ou o primeiro bloco `nr` x `nr`
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

Observação: para evitar que o usuário inunde a tela com tabelas enormes, colocamos uma condição no fim para imprimir apenas o bloco 10 x 10 se o inteiro solicitado for maior que 10. Caso contrário, será impresso um bloco n x n.

O código completo fica assim:

# Insira um inteiro
my_int <- 42

nr <- as.integer(my_int)

# Crie uma matriz `n` x `n` com zeros
mymat <- matrix(0, nr, nr)

# Para cada linha e coluna, atribua valores com base na posição
# Esses valores são o produto de dois índices
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

# Mostre o primeiro bloco 10x10 ou o primeiro bloco `nr` x `nr`
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

For loops: populares, mas nem sempre ideais

O loop for é, de longe, o mais popular, e sua construção pressupõe que o número de iterações é fixo e conhecido de antemão, como em “gerar os primeiros 200 números primos” ou “listar os 10 clientes mais importantes”.

Mas e se você não souber nem controlar o número de iterações, e uma ou várias condições imprevisíveis puderem ocorrer?

Por exemplo, você pode querer contar quantos clientes moram em uma área com determinado CEP, ou quantos cliques um banner teve em uma página nos últimos dois dias, ou outros eventos imprevistos.

Nesses casos, o loop while e seu primo repeat podem salvar o dia…

Interrompa seus loops com break

Quando o interpretador do R encontra um break, ele passa o controle para a instrução imediatamente após o fim do loop (se houver). No caso de loops aninhados, o break sai apenas do loop mais interno.

Exemplo:

Este trecho define uma matriz m x n de zeros e entra em um for aninhado para preencher as posições, mas somente quando os dois índices diferem. O objetivo é criar uma matriz triangular inferior, isto é, elementos abaixo da diagonal principal são não nulos. Os demais ficam como zero.

Quando os índices são iguais e, portanto, a condição no loop interno (sobre o índice de coluna j) é satisfeita, um break é executado e o loop interno é interrompido, saltando diretamente para a instrução após o loop interno — um print(). Em seguida, o controle volta à condição do for externo (linhas, índice i), que é reavaliada.

Se os índices diferirem, a atribuição é feita e o contador é incrementado em 1. Ao final, o programa imprime o contador ctr, com o número de elementos atribuídos.

# Faça uma matriz triangular inferior (zeros no canto superior direito)
m = 10
n = 10

# Um contador para as atribuições
ctr = 0

# Crie uma matriz 10 x 10 com zeros
mymat = matrix(0, m, n)

for (i in 1:m) {
    for (j in 1:n) {
        if (i == j) {
            break
        } else {
            # atribui valores apenas quando i<>j
            mymat[i, j] = i * j
            ctr = ctr + 1
        }
    }
    print(i * j)
}

# Imprima quantas células foram atribuídas
print(ctr)

Observação: pode ser um pouco zeloso usar chaves mesmo quando não são estritamente necessárias. Fazemos isso para garantir que tudo que abre com { também feche com }. Se notar números não correspondentes de { ou }, há um erro — embora o inverso nem sempre seja verdade!

O uso de next em loops

next descontinua uma iteração específica e salta para o próximo ciclo. Na prática, ele volta para a avaliação da condição do loop atual.

Em outras linguagens, o equivalente pode se chamar “continue” (um pouco confuso), mas significa o mesmo: ao verificar a condição, salte para a avaliação do loop.

Um exemplo simples de manter o loop em execução enquanto descarta um ciclo ao ocorrer certa condição:

m = 20

for (k in 1:m) {
    if (!k %% 2)
        next
    print(k)
}

Esse código imprime todos os números ímpares no intervalo 1:m (aqui, m=20). Em outras palavras, todos os inteiros, exceto aqueles com resto diferente de zero ao serem divididos por 2 (daí o uso do operador módulo %%), conforme especificado no teste do if, serão impressos.

Números cujo resto é zero não serão impressos, pois o programa salta para a avaliação de i in 1:m e ignora quaisquer instruções seguintes. Neste caso, print(k) é ignorado.

v1 <- c(3,4,5)
v2 <- c(3,4,6)
v3 <- c(0,0,0)
n = length(v1)

for (i in 1:n) {
    v3[i] <- v1[i] + v2[i]
}
v3

v3 = v1 + v2
v3

A <- matrix(1:6, nrow = 3, ncol = 2)
B <- matrix(c(2,4,3,1,5,7), nrow=3, ncol=2)

C= A + B
C

Vetorização em R explicada

Por que a vetorização roda mais rápido, se o número de operações elementares parece o mesmo?

A melhor explicação exige olhar os detalhes internos do R (assunto para outro post). Resumindo: em primeiro lugar, R é interpretado e, como tal, todos os detalhes sobre definição de variáveis são tratados pelo interpretador. Você não precisa especificar que um número é ponto flutuante ou alocar memória com ponteiros, por exemplo.

O interpretador do R “entende” essas questões a partir do contexto conforme você digita os comandos, mas faz isso comando a comando. Assim, ele precisa lidar com essas definições toda vez que você emite um comando, mesmo que seja repetido.

Um compilador, por sua vez, resolve todas as definições na compilação de todo o código; o resultado vira binário compacto e otimizado, antes da execução. Agora, como funções R são escritas em linguagens de baixo nível, elas são mais eficientes.

Na prática, ao olhar o código de baixo nível, veríamos chamadas a C ou C++, geralmente dentro de um “wrapper”.

Em segundo lugar, em linguagens que suportam vetorização (como R ou Matlab), toda instrução que usa um dado numérico atua sobre um objeto nativamente definido como vetor, mesmo que tenha um único elemento. Este é o padrão ao definir, por exemplo, uma variável numérica única: sua representação interna no R será sempre um vetor, ainda que com um número só.

Os loops continuam existindo sob o capô, mas no nível compilado e mais rápido (C/C++). A vantagem de trabalhar com vetor é que as definições são resolvidas pelo interpretador uma única vez, sobre todo o vetor, independentemente do tamanho, em contraste com um loop sobre escalares, no qual definições e alocações precisam ser feitas elemento a elemento — e isso é mais lento.

Por fim, lidar com o formato vetorial nativo permite usar rotinas de Álgebra Linear muito eficientes (como BLAS). Assim, ao executar instruções vetorizadas, o R aproveita essas rotinas numéricas. A mensagem é: se possível, processe estruturas inteiras em uma única chamada de função para evitar cópias desnecessárias.

Chega de digressões: vamos a um exemplo geral de vetorização e, na próxima subseção, aprofundamos em funções vetorizadas populares no R para substituir loops.

Um exemplo de vetorização em R

Voltemos à ideia de “fazer dados crescerem”, um jeito tipicamente ineficiente de “atualizar” um data frame.

Primeiro, você cria uma matriz m x n com replicate(m, rnorm(n)), com m=10 vetores coluna de n=10 elementos gerados por rnorm(n).

Depois transforma em data frame (ou seja, 10 observações de 10 variáveis) e realiza uma operação algébrica em cada elemento usando um for aninhado: a cada iteração, uma função senoidal incrementa cada elemento referenciado pelos dois índices.

O exemplo é um pouco artificial, mas poderia representar a adição de um sinal a um ruído aleatório:

# Este é um loop ruim que "faz os dados crescerem"
set.seed(42)
m = 10
n = 10

# Crie matriz de números normais aleatórios
mymat <- replicate(m, rnorm(n))

# Transforme em data frame
mydframe <- data.frame(mymat)

for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
    print(mydframe)
  }
}

Aqui, a maior parte do tempo de execução é gasta com cópia e gerenciamento do loop.

Veja a solução vetorizada:

set.seed(42)
m = 10
n = 10
mymat <- replicate(m, rnorm(n))
mydframe <- data.frame(mymat)
mydframe <- mydframe + 10 * sin(0.75 * pi)
mydframe

Bem mais simples: a última linha substitui o for aninhado. Observação: usamos set.seed() para garantir resultados idênticos nas duas implementações.

Agora vamos medir o tempo de execução das duas soluções.

Você pode usar comandos do sistema do R, como system.time(), passando um trecho de código assim:

Dica: coloque o código que deseja avaliar entre os parênteses de system.time().

# Insira `system.time()` para medir o loop
for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
  }
}

# Adicione `system.time()` para medir a execução vetorizada
mydframe <- mydframe + 10 * sin(0.75 * pi) 

No trecho acima, você faz a escolha de m e n, cria a matriz e a transforma em data frame apenas uma vez no início e, depois, avalia o bloco for em comparação com a “one-liner” vetorizada em duas chamadas separadas a system.time().

Mesmo com m=n=10, a versão vetorizada já é cerca de 7 vezes mais rápida — embora, para valores tão baixos, isso pouco importe para o usuário.

As diferenças ficam perceptíveis (a olho nu) com m=n=100, enquanto aumentar para 1000 faz o for parecer travar por dezenas de segundos, e a versão vetorizada ainda executa num piscar de olhos.

Para m=n=10000, o for leva mais de um minuto, enquanto a vetorizada precisa de cerca de 2,54 s. Claro, essas medições variam conforme hardware e software (tente evitar dezenas de abas abertas no navegador e vários apps em segundo plano), mas ilustram bem as diferenças.

Justiça seja feita: aumentar m e n também impacta fortemente a geração da matriz — você pode ver isso envolvendo a função de replicação com outro system.time().

Brinque com m e n para ver como o tempo muda, plotando-o em função do produto m x n. Esse é o indicador relevante, pois expressa a dimensão das matrizes criadas e quantifica o número de iterações necessárias no for aninhado.

Este foi um exemplo de vetorização. Mas há muitos outros. No R News, na página 46, há funções muito eficientes para somas e médias por dimensão em matrizes/arrays: rowSums(), colSums(), rowMeans() e colMeans().

Além disso, a newsletter menciona que “...as funções da família ‘apply’, [s,l,m,t]apply, são fornecidas para aplicar outra função aos elementos/dimensões de objetos. Essas funções ‘apply’ oferecem uma sintaxe compacta para tarefas às vezes complexas, mais legível e rápida que loops mal escritos”.