¿La forma más rápida y flexible de trazar más de 2 millones de filas de datos de archivos planos?

Aquí hay un código R para jugar con 8000000 números en 4 columnas de 2000000 filas:

> d=matrix(runif(8000000),ncol=4)
> dim(d)
[1] 2000000       4
> plot(d[1:1000,1])
> plot(d[1:1000,1],type='l')
> plot(d[1:10000,1],type='l')

Ahora empieza a ser un poco lento:

> plot(d[1:100000,1],type='l')

¿Qué pasa con la correlación de dos columnas:

> cor(d[,1],d[,2])
[1] 0.001708502

Instant instantáneo. ¿Transformada de Fourier?

> f=fft(d[,1])

También instantáneo. Sin embargo, no intentes tramarlo.

Vamos a trazar una versión reducida de una de las columnas:

> plot(d[seq(1,2000000,len=1000),1],type='l')

Instant instantáneo.

Lo que realmente falta es una trama interactiva donde se puede hacer zoom y pan alrededor de todo el conjunto de datos.

Aquí hay un ejemplo a lo largo de las líneas de los datos que tiene, como cargados en R, agregados, etc...

Primero, algunos datos ficticios para escribir en un archivo:

stime <- as.POSIXct("2011-01-01-00:00:00", format = "%Y-%d-%m-%H:%M:%S")
## dummy data
dat <- data.frame(Timestamp = seq(from = stime, by = 5, length = 2000000),
                  DD1 = sample(1:1000, replace = TRUE),
                  DD2 = sample(1:1000, replace = TRUE),
                  DD3 = sample(1:1000, replace = TRUE),
                  DD4 = sample(1:1000, replace = TRUE))
## write it out
write.csv(dat, file = "timestamp_data.txt", row.names = FALSE)

Entonces podemos cronometrar la lectura en los 2 millones de filas. Para acelerar esto, le decimos a R las clases de las columnas en el archivo: "POSIXct" es una forma en R de almacenar el tipo de marcas de tiempo que tiene.

## read it in:
system.time({
             tsdat <- read.csv("timestamp_data.txt", header = TRUE,
                                 colClasses = c("POSIXct",rep("integer", 4)))
            })

Que, toma alrededor de 13 segundos para leer y formatear en tiempos internos de unix en mi modesta laptop.

   user  system elapsed 
 13.698   5.827  19.643 

La agregación se puede hacer de muchas maneras, una es usar aggregate(). Decir agregado a la hora media/media:

## Generate some indexes that we'll use the aggregate over
tsdat <- transform(tsdat,
                   hours   = factor(strftime(tsdat$Timestamp, format = "%H")),
                   jday    = factor(strftime(tsdat$Timestamp, format = "%j")))
## compute the mean of the 4 variables for each minute
out <- aggregate(cbind(Timestamp, DD1, DD2, DD3, DD4) ~ hours + jday, 
                 data = tsdat, FUN = mean)
## convert average Timestamp to a POSIX time
out <- transform(out,
                 Timestamp = as.POSIXct(Timestamp, 
                                        origin = ISOdatetime(1970,1,1,0,0,0)))

Que (la línea que crea out) toma ~16 segundos en mi computadora portátil, y da la siguiente salida:

> head(out)
  hours jday           Timestamp      DD1      DD2      DD3      DD4
1    00  001 2010-12-31 23:29:57 500.2125 491.4333 510.7181 500.4833
2    01  001 2011-01-01 00:29:57 516.0472 506.1264 519.0931 494.2847
3    02  001 2011-01-01 01:29:57 507.5653 499.4972 498.9653 509.1389
4    03  001 2011-01-01 02:29:57 520.4111 500.8708 514.1514 491.0236
5    04  001 2011-01-01 03:29:57 498.3222 500.9139 513.3194 502.6514
6    05  001 2011-01-01 04:29:57 515.5792 497.1194 510.2431 496.8056

El trazado simple se puede lograr usando la función plot():

plot(DD1 ~ Timestamp, data = out, type = "l")

Podemos superponer más variables a través de, por ejemplo:

ylim <- with(out, range(DD1, DD2))
plot(DD1 ~ Timestamp, data = out, type = "l", ylim = ylim)
lines(DD2 ~ Timestamp, data = out, type = "l", col = "red")

O a través de múltiples paneles:

layout(1:2)
plot(DD1 ~ Timestamp, data = out, type = "l", col = "blue")
plot(DD2 ~ Timestamp, data = out, type = "l", col = "red")
layout(1)

Todo esto se ha hecho con la funcionalidad base R. Otros han mostrado cómo los paquetes de complementos pueden hacer que trabajar con fechas sea más fácil.