29 Agrupando comandos, execução condicional, controle de fluxo, "loops" e a
"família" *apply
29.1 Agrupando comandos
O R é uma linguagem que interpreta expressões, o que implica que o único tipo de comando
usado é uma expressão ou função que executa o processamento da requisição e retorna
algum resultado. Nesta sessão vamos ver alguns formatos para facilitar/agilizar o uso de
comandos.
É possível atribuir os mesmos valores a vários objetos de uma só vez utilizando atribuições
múltiplas de valores.
> a <- b <- 10> a
[1] 10
> b
[1] 10
> x <- y <- z <- numeric(5)> x
[1] 0 0 0 0 0
> y
[1] 0 0 0 0 0
> z
[1] 0 0 0 0 0
Um grupo de comandos pode ser agrupado com "{ }" e separados por ";" para digitação em
uma mesma linha. Em certas situações, como no "prompt"do R as chaves são opcionais.
> {x <- 1:3; y <- x+4 ; z <- y/x}> x <- 1:3; y <- x+4 ; z <- y/x; x; y; z
[1] 1 2 3
[1] 5 6 7
[1] 5.000000 3.000000 2.333333
29.2 Execução condicional
Execuções condicionais são controladas por funções especiais que verificam se uma condição é
satisfeita para permitir a execução de um comando. As seguintes funções e operadores podem ser
usadas para controlar execução condicional.
if() (opcionalmente) acompanhado de else
\(\& \), \(\|\), \(\& \& \) e \(\|\|\)
ifelse()
switch()
A estrutura if() else é comumente usada, em especial dentro de funções. Quando aplicada
diretamente na linha de comando, é uma prática recomendada colocar chaves marcando o
início e fim dos comandos de execução condicional. Quando a expressão que segue o if()
e/ou else tem uma única linha ela pode ser escrita diretamente, entretanto, caso sigam-se
mais de duas linhas deve-se novamente usar chaves, agora também depois destes de forma
que todos os comandos da execução condicional fiquem contidos na chave, caso contrário
apenas a primeira linha será considerada para execução condicional e todas as demais são
processadas normalmente. Inspecione os comandos a seguir que ilustram os diferentes usos.
> x <- 10 ; y <- 15> {+ if(x > 8) z <- 2*x+ }> z
[1] 20
> rm(x,y,z); x <- 10 ; y <- 15>>> {if(x > 12) z <- 2*x+ else z <- 5*x+ }> z
[1] 50
> rm(x,y,z); x <- 10 ; y <- 15>> {if(x > 8){+ z <- 2*x+ w <- z+y+ }+ else{+ z <- 5*x+ w <- z - y+ }+ }> z
[1] 20
> w
[1] 35
> rm(x,y,z,w); x <- 10 ; y <- 15>> {if(x > 8) z <- 2*x+ w <- z+y+ if(x <= 8) z <- 5*x+ w <- z - y+ }> z
[1] 20
> w
[1] 5
> rm(x,y,z,w)
Um comando útil para manipulação de dados é o split() que permite separa dados por grupos.
Por exemplo considere o conjunto de dados mtcars, que possui várias variáveis relacionadas a
características de veículos. Entre as variáveis estão as que indicam o consumo (mpg - miles per
gallon) e o tipo de câmbio, manual ou automático (am). Para separar os dados da variável mpg para
cada tipo de câmbio, podemos usar:
Outro comando com funcionalidade similar é aggregate().
29.3 Controle de fluxo
O controle de fluxo no R é implementado pelas funções for(), while() e repeat(). A escolha de
qual usar vai depender do contexto e objetivo do código e em geral não existe solução única, sendo
que uma mesma tarefa pode ser feita por uma ou outra.
Apenas para ilustração considere o seguinte exemplo resolvido de três formas diferentes com cada
uma destas funções: Dado um valor de \(n\) gerar amostras de tamanho \(1, 2, \ldots , n\) e calcular a média de cada amostra, com 3 casas
decimais.
Primeiro vamos implementar uma solução usando for().
> f1 <- function(n){+ medias <- numeric(n)+ for (i in 1:n){+ am <- rnorm(i)+ medias[i] <- round(mean(am), dig=3)+ }+ return(medias)+ }> set.seed(283)> f1(10)
NOTA: as soluções acima são apenas ilustrativas e não representam a forma mais eficiente de
efetuar tal operação no R. Na verdade, para este tipo de cálculo recomenda-se o uso de funções do
tipo *apply que veremos no restante desta sessão.
29.4 Alguns comentários adicionais
Nas soluções acima as amostras foram usadas para calcular as médias e depois descartadas. Suponha
agora que queremos preservar e retornar também os dados simulados. Para ilustrar vamos mostrar
como fazer isto modificando um pouco a primeira função.
> f1a <- function(n){+ res <- list()+ res$amostras <- list()+ res$medias <- numeric(n)+ for (i in 1:n){+ res$amostras[[i]] <- rnorm(i)+ res$medias[i] <- round(mean(res$amostras[[i]]), dig=3)+ }+ return(res)+ }> set.seed(283)> ap <- f1a(4)>> names(ap)
Vamos agora ver uma outra modificação. Nas funções acima geravamos amostras com tamanhos
sequenciais com incremento de 1 elemento no tamanho da amostra. A função a seguir mostra como
gerar amostras de tamanhos especificados pelo usuário e para isto toma como argumento um vetor de
tamanhos de amostra.
> f5 <- function(ns){+ medias <- numeric(length(ns))+ j <- 1+ for (i in ns){+ am <- rnorm(i)+ medias[j] <- round(mean(am), dig=3)+ j <- j+1+ }+ return(medias)+ }> set.seed(231)> f5(c(2, 5, 8, 10))
[1] -1.422 -0.177 0.056 0.158
29.5 Evitando "loops" — a "família" *apply
O R é uma linguagem vetorial e "loops"podem e devem ser substituídos por outras
formas de cálculo sempre que possível. Usualmente usamos as funções apply(), sapply(),
tapply() e lapply() para implementar cálculos de forma mais eficiente. Vejamos alguns
exemplos.
apply() para uso em matrizes, arrays ou data-frames
tapply() para uso em vetores, sempre retornando uma lista
sapply() para uso em vetores, simplificando a estrutura de dados do resultado se possível
(para vetor ou matriz)
mapply() para uso em vetores, versão multivariada de sapply()
lapply() para ser aplicado em listas
1.
Seja o problema mencionado no início desta sessão de gerar amostras de tamanhos sequenciais e
calcular a média para cada uma delas. Uma alternativa aos códigos apresentados seria:
No próximo exemplo consideramos uma função que simula dados e calcula medidas de posição e
dispersão associadas utilizando para cada uma delas duas medidas alternativas. Inicialmente
definimos a função:
O resultado está armazenado no objeto res, que neste caso é uma lista. Agora vamos
extrair desta lista as médias aritméticas e depois ambas, média aritmética e aparada:
> mediaA <- function(x) x$A$pos> mA <- sapply(res, mediaA)> mediaAB <- function(x) c(x$A$pos, x$B$pos)> mAB <- sapply(res, mediaAB)> rownames(mAB) <- paste("modelo", LETTERS[1:2], sep="")> mAB
A função tapply() pode ser usada para calcular o resultado de uma operação sobre dados, para
cada um dos níveis de uma segunda variável. No primeiro exemplo consideramos novamente o
conjunto de dados mtcars mencionado anteriormente. Os comandos abaixo calculam
média, variância e coeficiente de variação do consumo para cada tipo de câmbio.
A B C D E49.91571 51.03091 45.26204 47.45439 47.25661
> gCV <- with(xy, tapply(x, y, function(z) 100* sd(z)/mean(z)))> gCV
A B C D E16.13100 11.97707 17.35279 18.67300 16.03077
5.
Considere gerarmos uma matriz \(1000 \times 300\) representando 1000 amostras de tamanho 300. O que
desejamos é calcular a média de cada uma das amostras Os códigos a seguir mostras três formas
alternativas de fazer isto. Encapsulamos os comandos com a função system.time() que
compara os tempos de execução.
> x <- matrix(rnorm(1000*300), nc=300)>> system.time({+ f <- function(x){+ mx <- numeric(1000)+ for(i in 1:1000)+ mx[i] <- mean(x[i,])+ mx+ };mx <- f(x)}+ )
usuário sistema decorrido 0.006 0.000 0.006
> system.time(mx <- apply(x, 1, mean))
usuário sistema decorrido 0.005 0.000 0.005
> system.time(mx <- rowMeans(x))
usuário sistema decorrido 0.001 0.000 0.001
A função rowMeans() é substancialmente mais eficiente (menos tempo de execução. Outras
funções simulares são colMeans(), rowSums() e colSums().
6.
Considere o seguinte problema: Sejam li e ls vetores com os limites superiores e inferiores definindo intervalos. Inicialmente
vamos simular estes valores.
> li <-round(rnorm(500, m=70, sd=10))> ls <- li + rpois(li, lam=5)
O que queremos montar um vetor com os valores únicos que definem estes intervalos, e testar a
pertinência de cada elemento a cada um dos intervalos. Ao final teremos uma matriz
indicando, para cada elemento do vetor de valores únicos, a pertinência a cada intervalo.
Inicialmente vamos fazer um código usando "loops"guardando os resultados no objeto B.
> system.time({+ aux<-sort(c(li,ls))+ m<-length(table(aux))+ all<-rep(min(aux),m)+ for(j in 1:(m-1)){ all[j+1]<- min(aux[aux>all[j]])}+ n<-length(li)+ aij<-matrix(0,nrow=n,ncol=m)+ for(i in 1:n){+ for(j in 1:m){+ aij[i,j]<-ifelse(all[j]>=li[i] & all[j]<=ls[i],1,0)+ }+ B<-aij+ }+ })
usuário sistema decorrido 0.048 0.017 0.066
Agora, usando a estrutura vetorial da linguagem R vamos reimplementar este código de
maneira mais eficiente e adequada para a linguagem, usando sapply(), guardando os
resultados no objeto A. Ao final usamos identical() para testar se os resultados
numéricos são exatamente os mesmos. Note a diferença nos tempos de execução.
> system.time({+ all <- sort(unique(c(li,ls)))+ interv1 <- function(x, inf, sup) ifelse(x >= inf & x <= sup, 1, 0)+ A <- sapply(all, interv1, inf=li, sup=ls)+ })
usuário sistema decorrido 0.003 0.000 0.002
> identical(A,B)
[1] TRUE
7.
Considere agora uma extensão do problema anterior. Queremos montar o vetor com os valores
únicos que definem estes intervalos como no caso anterior, e depois usar este vetor montar
intervalos com pares de elementos consecutivos deste vetor e testar se cada um destes intervalos
está contido em cada um dos intervalos originais. O resultado final é uma matriz indicando para
cada intervalo obtido desta forma a sua pertinência a cada um dos intervalos originais. Da
mesma forma que no caso anterior implementamos com um "loop"e depois usando a estrutura
vetorial da linguagem, e testando a igualdade dos resultados com identical().
> li <-round(rnorm(500, m=70, sd=10))> ls <- li + rpois(li, lam=5)>> system.time({+ aux<-sort(c(li,ls))+ m<-length(table(aux))+ all<-rep(min(aux),m)+ for(j in 1:(m-1)){ all[j+1]<- min(aux[aux>all[j]])}+ n<-length(li)+ aij<-matrix(0,nrow=n,ncol=m-1)+ for(i in 1:n){+ for(j in 1:m-1){+ aij[i,j]<-ifelse(all[j]>=li[i] & all[j+1]<=ls[i],1,0)+ }+ B<-aij+ }+ })
Uso da família *apply – outros exemplos
Os exemplos a seguir foram retirados de mensagens enviadas à lista R_STAT.
1.
adaptado de mensagem enviada por Silvano C Costa
Tenho uma pergunta onde pode haver mais de uma resposta, por exemplo:
Q1 - Qual Esporte você pratica:
1.()Futebol 2.()Volei 3.() Natação 4.()Atletismo
Q2 - Sexo:
1.Masculino() 2.Feminino()
Então teria os dados dessa forma:
Q1.1 Q1.2 Q1.3 Q1.4 Q2
1 0 1 0 1 => Homem Praticante de Futebol,Natacao
0 1 1 0 2 => Mulher praticante de Volei e Natação
0 0 0 1 2 => Mulher praticante de Atletismo
Gostaria de criar uma tabela cruzada entre essas variáveis:
M F
Futebol 21 10
Natação 13 20
Volei 5 2
Atletismo 10 10
Para mostrar como obter a solução, como não temos o questionário aqui vamos primeiro simular
dados deste tipo como se tivéssemos 75 questionários.
Solução 1: Para cada esporte podemos contar os praticantes de cada sexo em cada esporte,
separadamente utilizando table() e verificando a segunda linha da tablea a seguir.
> with(esportes, table(Futebol, S))
SFutebol F M 0 16 24 1 21 14
Desta forma, podemos obter a tabela desejada combinando os resultados de tabelas para cada
esporte.
Solução 2: alternativamente, podemos usar sapply() para tomar cada esporte e, como os
dados são codificados em 0/1, usar tapply() para somar os praticantes (1) de cada sexo.
Queria fazer uma amostragem e tirar as informações. Tenho duas amostras.
Aplico o teste t e tenho um P-valor.
a <-c(1,2,4,5,3,4,5,6,6,7,2)
b <-c(5,3,4,5,3,4,5,3,4,3,5)
Eu gostaria de juntar estes dois vetores num mesmo vetor e fazer 1000
reamostragens neste vetor de tamanho do vetor a e com reposição.
e <- c(5,3,4,5,3,4,5,3,4,3,5,1,2,4,5,3,4,5,6,6,7,2)
Depois eu queria ver aplicar o teste t(nas amostras) e ver como se
comportam estes p-valores.
Inicialmente vamos entrar com os dados e obter o teste-t.
> a <-c(1,2,4,5,3,4,5,6,6,7,2)> b <-c(5,3,4,5,3,4,5,3,4,3,5)> tt.ab <- t.test(a, b)> tt.ab
Welch Two Sample t-testdata: a and bt = 0.14228, df = 14.14, p-value = 0.8889alternative hypothesis: true difference in means is not equal to 095 percent confidence interval: -1.278239 1.460057sample estimates:mean of x mean of y 4.090909 4.000000
Agora obtemos as 1000 reamostras deste vetor cada uma com \(11\times 2=22\) valores utilizando sample(). As
reamostras serão arranjadas num array de dimensão \(11\times 2\times 1000\).
> e <- c(5,3,4,5,3,4,5,3,4,3,5,1,2,4,5,3,4,5,6,6,7,2)> reamostras <- array(sample(e, length(e)*1000, rep=T),+ dim=c(length(e)/2,2,1000))
Portanto cada elemento da terceira dimensão corresponde a uma reamostra. Para fazer os
testes-t nas 1000 reamostras utilizamos apply() que vai gerar uma lista de 1000 elementos com
resultados dos testes.
Para ver o resultado do teste em uma das amostras selecionamos um elemento da lista.
> TT[[1]]
Welch Two Sample t-testdata: x[, 1] and x[, 2]t = 1.3948, df = 16.273, p-value = 0.1818alternative hypothesis: true difference in means is not equal to 095 percent confidence interval: -0.4707033 2.2888851sample estimates:mean of x mean of y 4.272727 3.363636
Finalmente pode-se extrair uma quantidade de interesse dos resultados, como no exemplo a
seguir, extraímos os p-valores.
Os gráficos na Figura 77 mostram valores obtidos na amostra, comparados aos valores obtidos
na reamostragem. À esquerda é mostrado a estimativa da diferença de médias, e à direita os
p-valores.
Figura 77: Valores da diferença de médias (esquerda) e p-valor (direita) da amostra (linhas
verticais) comparados aos histogramas dos valores obtidos nas reamostras.
OBS: note que estão sendo usadas as opções default do teste-t para comparação de duas
amostras dadas em t.test() (bilateral, não pareado, variâncias diferentes, etc). Para alterar
algum argumento basta acrescentar o argumento desejados na chamada de apply().
As funções da família *apply têm o propósito geral de aplicar uma função repetidamente a diversas
partes de um conjunto de dados. Além das mencionadas acima várias outras têm sido implementadas.
Notadamente se destacam as do pacote plyr (a_ply, d_ply, l_ply, r_ply, dentre váris
outras).
Por exemplo considere a função l_ply que aplica uma função em elementos uma lista porém em
situações onde estamos interessados apenas em um efeito colateral (gráfico, arquivo gravado em disco,
etc) de função e não no resultado que ela retorna. Como exemplo considere o conjunto de dados
trees, uma data-frame que possui três colunas com diâmetros, alturas e volumes de árvores. Suponha
que desejamos fazer o histograma das três variáveis, e então uma possível forma seria utilizar o
comando lapply().
Neste caso, além de produzir os gráficos as resultados dos cálculos do histograma são retornados na
tela, o que pode ser indesejável e/ou desnecessário. A função l_ply() produz o mesmo
resultado gráfico porém sem que os resultados dos cálculos do histograma sejam retornados.
> require(plyr)> l_ply(trees, hist)
Para mais informações sobre o pacote plyr consulte as informações e documentações em
http://had.co.nz/plyr/.
