leer - matlab package in r

Función de cronómetro en R

Question

¿Hay un temporizador R o una función de cronómetro similar al tic/toc MATLAB?

Answer 1

Un enfoque de cierre

Una forma muy limpia y simple de hacer esto es usar un cierre (que solo significa tener una función dentro de una función):

tic <- function () { 
    now <- proc.time()
    function () { 
        proc.time() - now 
    }
}

Usted inicia el temporizador de esta manera:

toc <- tic()

Y luego tienes el tiempo de regreso así:

toc()

Que produce un vector nombrado que se imprime así:

 user  system elapsed 
0.008   0.004   2.055 

Incluso con la simplicidad de esta versión, también obtiene toda la funcionalidad de las versiones de Matlab y Richie Cotton, además de la característica adicional de poder ejecutar múltiples temporizadores:

toc1 <- tic()
toc2 <- tic()

Answer 2

A partir de la fecha 2015-03-25, y posiblemente antes, el paquete pracma contiene las funciones tic() y toc() .

Ejemplo:

> library(pracma)
> tic()
> for(i in 1:10000) mad(runif(10000))    # kill time
> toc()
elapsed time is 18.610000 seconds 

Answer 3

Hay muchas herramientas de creación de perfiles en R, como mencionó Dirk. Si quieres la simplicidad de tic / toc, entonces puedes hacerlo en R también.

EDITAR: he canibalizado la funcionalidad de recolección de basura del paquete MATLAB, y tic ahora te permite elegir si estás interesado en el tiempo total transcurrido o solo en el tiempo del usuario.

tic <- function(gcFirst = TRUE, type=c("elapsed", "user.self", "sys.self"))
{
   type <- match.arg(type)
   assign(".type", type, envir=baseenv())
   if(gcFirst) gc(FALSE)
   tic <- proc.time()[type]         
   assign(".tic", tic, envir=baseenv())
   invisible(tic)
}

toc <- function()
{
   type <- get(".type", envir=baseenv())
   toc <- proc.time()[type]
   tic <- get(".tic", envir=baseenv())
   print(toc - tic)
   invisible(toc)
}

El uso es, por ejemplo, tic(); invisible(qr(matrix(runif(1e6), nrow=1e3))); toc() tic(); invisible(qr(matrix(runif(1e6), nrow=1e3))); toc()

Answer 4

Hay un paquete de emulación MATLAB matlab en CRAN. Tiene implementaciones de tic y toc (pero se parecen mucho a las funciones en la respuesta de Richie Cottons; se usa "transcurrido" en lugar de "usuario.self" en proc.time() )

> tic
function (gcFirst = FALSE) 
{
    if (gcFirst == TRUE) {
        gc(verbose = FALSE)
    }
    assign("savedTime", proc.time()[3], envir = .MatlabNamespaceEnv)
    invisible()
}
<environment: namespace:matlab>
> toc
function (echo = TRUE) 
{
    prevTime <- get("savedTime", envir = .MatlabNamespaceEnv)
    diffTimeSecs <- proc.time()[3] - prevTime
    if (echo) {
        cat(sprintf("elapsed time is %f seconds", diffTimeSecs), 
            "/n")
        return(invisible())
    }
    else {
        return(diffTimeSecs)
    }
}
<environment: namespace:matlab>

Answer 5

Hay un tictoc de paquete relativamente nuevo que replica las características exactamente como las usarías en Matlab.

http://cran.r-project.org/web/packages/tictoc/index.html

## Basic use case
tic()
print("Do something...")
Sys.sleep(1)
toc()
# 1.034 sec elapsed

Answer 6

Los equivalentes directos de tic y toc no existen.

Consulte la help(system.time) y el manual de Extensiones R sobre creación de perfiles. Las discusiones sobre las herramientas de creación de perfiles y perfiles también se encuentran en las diapositivas ''Introducción a HPC con R'' a las que se hace referencia en la tarea de computación de alto rendimiento con R

Answer 7

No, pero aquí hay una solución de una línea.

time.it<-function(f) { a<-proc.time(); out<-f(); print(proc.time()-a); out }

Y un ejemplo de uso:

result<-time.it(function(){ A<-matrix(runif(5000^2),nrow=5000); b<-runif(5000); solve(A,b) } )
user  system elapsed 
12.788  12.268   8.623 

De lo contrario, microbenchmark es mi favorito en términos de paquetes.

Answer 8

Solo para completar: en realidad puedes ''simular'' tic y toc en R, para que puedas escribir

tic
## do something
toc

sin paréntesis El truco es abusar de la función de print , como se muestra en Fun: tic y toc en R :

tic <- 1
class(tic) <- "tic"

toc <- 1
class(toc) <- "toc"

print.tic <- function(x, ...) {
    if (!exists("proc.time"))
        stop("cannot measure time")
    gc(FALSE)
    assign(".temp.tictime", proc.time(), envir = .GlobalEnv)
}

print.toc <- function(x,...) {
    if (!exists(".temp.tictime", envir = .GlobalEnv))
        stop("did you tic?")
    time <- get(".temp.tictime", envir = .GlobalEnv)
    rm(".temp.tictime", envir = .GlobalEnv)
    print(res <- structure(proc.time() - time,
                           class = "proc_time"), ...)
    invisible(res)
}

Así que escribiendo

tic
Sys.sleep(2)
toc

debería resultar en algo como esto:

   user  system elapsed 
  0.000   0.000   2.002 

Como dije, es un truco; system.time , Rprof y paquetes como rbenchmark son la forma de medir el tiempo de computación en R.

Answer 9

Una equivalencia muy simple con tic y toc que podrías tener:

tic=proc.time()[3]

...code...

toc=proc.time()[3] - tic

Donde [3] es porque estamos interesados ​​en el tercer elemento en el vector devuelto por proc.time (), que es el tiempo transcurrido.

Answer 10

install.packages("tictoc")
library(tictoc)
# Timing nested code. 
# The string provided in the call to tic() becomes a prefix to the output of toc()
tic("outer")
    Sys.sleep(1)
    tic("middle")
        Sys.sleep(2)
        tic("inner")
            Sys.sleep(3)
        toc() # inner
# inner: 3.004 sec elapsed
    toc() # middle
# middle: 5.008 sec elapsed
toc() # outer
# outer: 6.016 sec elapsed

El paquete tictoc implementa la funcionalidad descrita en las respuestas anteriores. ¡Gracias por la inspiración! El paquete también agrega sincronización anidada, recopilando los tiempos en las variables definidas por el usuario, mensajes personalizados y devoluciones de llamadas.