Trucos

Hoy he encontrado una solución decente a un problema que venía arrastrando desde hace un tiempo en R. Tengo una tabla muy grande (decenas de millones de registros) con su id. Me interesa quedarme con el subconjunto de la tabla original en que para cada id el valor de una determinada variable es mínimo.

Un caso de uso: esa variable adicional mide la distancia de la observación a los centroides de unos clústers. El registro con el menor valor proporciona la asignación del sujeto a su grupo.

Un truco para generar variables aleatorias (aproximadamente) normales: sumar doce uniformes y restar seis.

En efecto,

x <- replicate(1000, sum(runif(12)) - 6)
qqnorm(x)
qqline(x, col=2)

produce

Ayuda a entender el motivo (de por qué el procedimiento genera variables aleatorias “casi” normales) que la varianza de la distribución uniforme es 1/12 y que su media es 1/2.

La operación que voy a discutir hoy es una que plantea problemas a muchos programadores nuevos en R: cómo renombrar niveles de un factor. Un caso típico ocurre al leer una tabla que contiene datos no normalizados. Por ejemplo,

mi.factor <- factor( c("a", "a", "b", "B", "A") )

donde se entiende que a y A, b y B son la misma cosa. Otro caso similar ocurre cuando se quieren agrupar niveles poco frecuentes como en

mi.factor <- factor(c(rep("a", 1000), rep("b", 500), letters[3:10]))

Para homogeneizar la entrada se recomienda sustituir sobre levels(mi.factor) así:

Ante las preguntas de alguno de mis lectores, voy a proporcionar una explicación acerca de la misteriosa L. Bueno, voy más bien a dejar que la deduzcan ellos mismos a partir de la siguiente serie de bloques de código:

a <- rep( 0, 10 )
typeof( a )
object.size( a )

b <- rep( 0L, 10 )
typeof( b )
object.size( b )

##############

a <- 1:10
typeof( a )
object.size( a )

a[1] <- 10
typeof( a )
object.size( a )

a <- 1:10
a[1] <- 10L
typeof( a )
object.size( a )

##############

a <- 1:10
tracemem( a )
a[1] <- 2

a <- 1:10
tracemem( a )
a[1] <- 2L

##############

system.time( replicate( 1e5, { a <- (1:100); a[1] <- 12  } ) )
system.time( replicate( 1e5, { a <- (1:100); a[1] <- 12L } ) )

Lectores míos, no seáis perezosos y haced, cuando menos, ?tracemem en vuestra consola. Una vez leída la página de ayuda, ¿se os ocurre algún truco para ahorrar mucha memoria cuando trabajáis con objetos (p.e., matrices) grandes de enteros?

Previamente he hablado en este blog de las ventajas que ofrece PROC SQL en SAS sobre otros métodos más propiamente SAS de realizar ciertas manipulaciones de datos. Existen no obstante cierto tipo de manipulaciones que exigen pasos data: gran parte de las que hacen uso de la variable automática n.

No obstante, existe una función no documentada de SAS que permite implementar con SQL muchas operaciones de este tipo: monotonic.

La verdad, me gustaría, me gustaría volver atrás y modificar algunas docenas de líneas de código en R que malescribí como un diletante por no estar al tanto de una función de R cuya verdadera utilidad descubrí recientemente (gracias le sean dadas, de nuevo, a Jorge Iván Vélez).

La verdad, no tengo excusa. Incluso se habló de ella en nuestro blog hermano.

Y es que nunca me había percatado de la potencia de la función mapply. He aquí el problema: se tienen dos listas de la misma longitud y se quieren transformar los objetos de la primera en función de datos extraídos de los objetos correspondientes de la segunda. En los tiempos oscuros que duraron hasta anteayer, me veía abocado a utilizar un bucle que llevase la contabilidad del índice para poder recorrer ambas listas simultáneamente: