function in R that also returns the execution time itself

Question

I know there is Rprof(), but it seems to me rather inaccurate compared to microbenchmark(). However, if I want to use the microbenchmark() I have to call the function 2 times, once to have her output and another to run her time (which seems quite impractical)

I do not know how to call the function only 1 time and have as response the normal output of it and also the execution time quite accurate.

That’s not the function, but follow an example of my problem:

teste <- function(x){

  Rprof()
  x <- x+2
  Rprof(NULL)

  return(summaryRprof())
}
guarda_x_e_tempo <- teste(2)

or

teste <- function(x){
  x <- x+2
  return(x)
}
guarda_x <- teste(2)
guarda_tempo <- teste(2)

Answer 1

Adenilson, all right?

I believe that the system.time function meets your need:

funcao_exemplo <- function(x) {
  print(x)
}

system.time(funcao_exemplo("Hello World"))

Answer 2

The accuracy of microbenchmark is in running several times the functions thus avoiding being influenced by possible computer crashes that could affect the running time. When you spin the microbenchmark it runs by default 100x the function to be able to calculate average, median , echo of the running times.

That said, microbenchmark is not suitable for what you want to do.

I believe that the other answers already have good solutions, but I think an elegant way to do that would be to create a function as follows:

crono <- function(f) {
  function(...) {
    exec_time <- system.time({res <- f(...)})
    list(
      exec_time = exec_time,
      res = res
    )
  }
}

We call this kind of function Function Operators.

With it you can create versions of your functions that are timed, for example:

crono_mean <- crono(mean)
crono_mean(1:10000000)

That would result in:

$exec_time
   user  system elapsed 
  0.034   0.018   0.061 

$res
[1] 5e+06

Answer 3

See if the following is what you want.
The result of the base R function proc.time is obtained in the first function instruction teste and then subtracted from proc.time in the end.

teste <- function(x){
  ini <- proc.time()
  x <- x + 2
  list(result = x, tempo = proc.time() - ini)
}

guarda_x_e_tempo <- teste(2)

guarda_x_e_tempo
#$`result`
#[1] 4
#
#$tempo
#   user  system elapsed 
#      0       0       0

Now another function, longer.

teste2 <- function(x, n = 1e6){
  ini <- proc.time()
  for(i in seq_len(n)) x <- x + 2
  list(result = x, tempo = proc.time() - ini)
}

teste2(2)
#$`result`
#[1] 2000002
#
#$tempo
#   user  system elapsed 
#   0.08    0.00    0.08 
#

Another way is to put the expression to time on system.time. This allows you to time the execution without modifying the functions.

teste3 <- function(x, n = 1e6){
  for(i in seq_len(n)) x <- x + 2
  x
}

system.time(teste3(2))
# usuário   sistema decorrido 
#   0.048     0.000     0.049