Il ya beaucoup d'outils de profilage en R, comme Dirk mentionné. Si vous voulez la simplicité de tic/toc, alors vous pouvez le faire en R.

EDIT: j'ai cannibalisé la fonctionnalité de collecte des ordures du paquet MATLAB, et tic vous permet maintenant de choisir si vous êtes intéressé par le temps total écoulé ou juste le temps de l'utilisateur.

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)
}

Utilisation est, par exemple, tic(); invisible(qr(matrix(runif(1e6), nrow=1e3))); toc()

il existe un paquet émulateur MATLAB matlab sur CRAN. Il a des implémentations de tic et toc (mais elles ressemblent beaucoup aux fonctions dans la réponse de Richie cotons;" écoulé "est utilisé à la place de" UTILISATEUR.auto " in 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>

les équivalents directs de tic et toc n'existent pas.

s'il vous Plaît voir help(system.time) ainsi que les Extensions de R manuel sur le profilage. Les Discussions sur les outils de profilage et de profilage se trouvent également dans L'Introduction au HPC avec des diapositives R référencées sur le High Performance Computing avec R taskview

une équivalence très simple avec tic et toc que vous pourriez avoir:

tic=proc.time()[3]

...code...

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

où le [3] est parce que nous sommes intéressés par le troisième élément dans le vecteur retourné par proc.time(), qui est le temps écoulé.

il existe un paquet tictoc relativement nouveau qui reproduit les caractéristiques exactement comme vous les utiliseriez dans 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

Une Fermeture De L'Approche

Une façon très simple et très propre de le faire est d'utiliser une fermeture (ce qui signifie simplement avoir une fonction à l'intérieur d'une fonction):

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

Vous démarrez le chronomètre de la sorte:

toc <- tic()

Et puis, vous obtenez le temps de retour comme ceci:

toc()

qui affiche un vecteur nommé qui est imprimé comme ceci:

 user  system elapsed 
0.008   0.004   2.055 

Même avec la simplicité de cette version, vous obtenez également toutes les fonctionnalités des versions de Matlab et Richie Cotton plus la fonctionnalité supplémentaire d'être en mesure d'exécuter plusieurs minuteries:

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

en date du 2015-03-25, et peut-être plus tôt, le pracma paquet contient les fonctions tic() et toc() .

exemple:

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

Non, Mais voici une solution d'une ligne.

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

et un exemple d'usage:

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 

sinon, microbenchmark est mon préféré en termes de paquets.

juste pour l'exhaustivité: vous pouvez réellement "simuler" tic et toc en R, pour que vous puissiez écrire

tic
## do something
toc

sans parenthèses. L'astuce est d'abuser du print fonction, comme démontré dans Fun: tic et toc dans 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)
}

ainsi dactylographié

tic
Sys.sleep(2)
toc

devrait donner quelque chose comme ceci:

   user  system elapsed 
  0.000   0.000   2.002 

Comme je l'ai dit, c'est un truc; system.time , Rprof et les paquets tels que rbenchmark sont la façon de mesurer temps de calcul en R.

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

le paquet tictoc implémente les fonctionnalités décrites par les réponses précédentes - merci pour l'inspiration! Le paquet ajoute également le timing imbriqué, collectant les timings dans les variables définies par l'utilisateur, les messages personnalisés et les callbacks.