Vectorization benchmarks

When to read this

This vignette assumes you’ve already read the Get started vignette and you now have a specific performance question: is it worth vectorizing my R integrand?

cubature exposes two calling conventions for the same underlying C routine:

  • Scalar interface (the default) — your R function receives one point at a time and returns one scalar (or length-fDim vector).
  • Vectorized interface (opt-in, vectorInterface = TRUE for hcubature/pcubature or nVec > 1 for Cuba methods) — your R function receives a matrix of points and returns a matrix of values, amortizing R’s per-call overhead over many integrand evaluations at once.

The vectorized interface almost always wins for non-trivial problems, sometimes by a factor of 10–50×, because the dominant cost is R’s function-call overhead rather than the arithmetic inside the integrand. But the speedup depends on your specific integrand, the method you pick, and the dimension. This vignette runs ten representative integrands through every combination and reports timings, so you can make an informed decision rather than guess.

A timing harness

Our harness will provide timing results for hcubature, pcubature (where appropriate), and Cuba cuhre calls — scalar and vectorized variants of each.

library(bench)
library(cubature)

harness <- function(which = NULL,
                    f, fv, lowerLimit, upperLimit, tol = 1e-3, iterations = 20, ...) {

  fns <- c(hc = "Non-vectorized Hcubature",
           hc.v = "Vectorized Hcubature",
           pc = "Non-vectorized Pcubature",
           pc.v = "Vectorized Pcubature",
           cc = "Non-vectorized cubature::cuhre",
           cc_v = "Vectorized cubature::cuhre")
  cc <- function() cubature::cuhre(f = f,
                                   lowerLimit = lowerLimit, upperLimit = upperLimit,
                                   relTol = tol,
                                   ...)
  cc_v <- function() cubature::cuhre(f = fv,
                                     lowerLimit = lowerLimit, upperLimit = upperLimit,
                                     relTol = tol,
                                     nVec = 1024L,
                                     ...)
  hc <- function() cubature::hcubature(f = f,
                                       lowerLimit = lowerLimit,
                                       upperLimit = upperLimit,
                                       tol = tol,
                                       ...)
  hc.v <- function() cubature::hcubature(f = fv,
                                         lowerLimit = lowerLimit,
                                         upperLimit = upperLimit,
                                         tol = tol,
                                         vectorInterface = TRUE,
                                         ...)
  pc <- function() cubature::pcubature(f = f,
                                       lowerLimit = lowerLimit,
                                       upperLimit = upperLimit,
                                       tol = tol,
                                       ...)
  pc.v <- function() cubature::pcubature(f = fv,
                                         lowerLimit = lowerLimit,
                                         upperLimit = upperLimit,
                                         tol = tol,
                                         vectorInterface = TRUE,
                                         ...)

  ndim <- length(lowerLimit)

  if (is.null(which)) {
    fnIndices <- seq_along(fns)
  } else {
    fnIndices <- na.omit(match(which, names(fns)))
  }
  fnList <- lapply(names(fns)[fnIndices], function(x) call(x))

  argList <- c(fnList, iterations = iterations, check = FALSE)
  result <- do.call(bench::mark, args = argList)
  d <- result[seq_along(fnIndices), 1:9]
  d$expression <- fns[fnIndices]
  d
}

We reel off the timing runs.

Example 1

func <- function(x) sin(x[1]) * cos(x[2]) * exp(x[3])
func.v <- function(x) {
    matrix(apply(x, 2, function(z) sin(z[1]) * cos(z[2]) * exp(z[3])), ncol = ncol(x))
}

d <- harness(f = func, fv = func.v,
             lowerLimit = rep(0, 3),
             upperLimit = rep(1, 3),
             tol = 1e-5,
             iterations = 100)[, 1:9]

knitr::kable(d, digits = 3, row.names = FALSE)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 263.35µs 288.6µs 3394.130 23.9KB 34.284 99 1 29.2ms
Vectorized Hcubature 357.61µs 384.7µs 2569.833 54.5KB 25.958 99 1 38.5ms
Non-vectorized Pcubature 851.34µs 921.6µs 1077.716 0B 56.722 95 5 88.1ms
Vectorized Pcubature 1.08ms 1.15ms 851.070 58.4KB 35.461 96 4 112.8ms
Non-vectorized cubature::cuhre 573.71µs 607.83µs 1607.243 0B 49.709 97 3 60.4ms
Vectorized cubature::cuhre 545.49µs 596.65µs 1642.665 39.8KB 33.524 98 2 59.7ms

Multivariate normal

Using cubature, we evaluate \[ \int_R\phi(x)dx \] where \(\phi(x)\) is the three-dimensional multivariate normal density with mean 0, and variance \[ \Sigma = \left(\begin{array}{rrr} 1 &\frac{3}{5} &\frac{1}{3}\\ \frac{3}{5} &1 &\frac{11}{15}\\ \frac{1}{3} &\frac{11}{15} & 1 \end{array} \right) \] and \(R\) is \([-\frac{1}{2}, 1] \times [-\frac{1}{2}, 4] \times [-\frac{1}{2}, 2].\)

We construct a scalar function (my_dmvnorm) and a vector analogue (my_dmvnorm_v). First the functions.

m <- 3
sigma <- diag(3)
sigma[2,1] <- sigma[1, 2] <- 3/5 ; sigma[3,1] <- sigma[1, 3] <- 1/3
sigma[3,2] <- sigma[2, 3] <- 11/15
logdet <- sum(log(eigen(sigma, symmetric = TRUE, only.values = TRUE)$values))
my_dmvnorm <- function (x, mean, sigma, logdet) {
    x <- matrix(x, ncol = length(x))
    distval <- stats::mahalanobis(x, center = mean, cov = sigma)
    exp(-(3 * log(2 * pi) + logdet + distval)/2)
}

my_dmvnorm_v <- function (x, mean, sigma, logdet) {
    distval <- stats::mahalanobis(t(x), center = mean, cov = sigma)
    exp(matrix(-(3 * log(2 * pi) + logdet + distval)/2, ncol = ncol(x)))
}

Now the timing.

d <- harness(f = my_dmvnorm, fv = my_dmvnorm_v,
             lowerLimit = rep(-0.5, 3),
             upperLimit = c(1, 4, 2),
             tol = 1e-5,
             iterations = 10,
             mean = rep(0, m), sigma = sigma, logdet = logdet)
knitr::kable(d, digits = 3)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 665.86ms 671.97ms 1.457 154.45KB 16.612 10 114 6.86s
Vectorized Hcubature 2.29ms 2.4ms 412.462 1.89MB 0.000 10 0 24.25ms
Non-vectorized Pcubature 279.02ms 291.31ms 3.377 0B 15.199 10 45 2.96s
Vectorized Pcubature 1.09ms 1.18ms 848.261 810.26KB 0.000 10 0 11.79ms
Non-vectorized cubature::cuhre 275.63ms 278.91ms 3.584 0B 15.051 10 42 2.79s
Vectorized cubature::cuhre 2.61ms 2.64ms 341.280 898.41KB 34.128 10 1 29.3ms

The effect of vectorization is huge. So it makes sense for users to vectorize their integrands as much as possible for efficiency.

Furthermore, for this particular example, we expect mvtnorm::pmvnorm to do pretty well since it is specialized for the multivariate normal. The vectorized versions of hcubature and pcubature seem competitive and in some cases better, as the table below shows.

library(mvtnorm)
g1 <- function() pmvnorm(lower = rep(-0.5, m),
                                  upper = c(1, 4, 2), mean = rep(0, m), corr = sigma,
                                  alg = Miwa(), abseps = 1e-5, releps = 1e-5)
g2 <- function() pmvnorm(lower = rep(-0.5, m),
                         upper = c(1, 4, 2), mean = rep(0, m), corr = sigma,
                         alg = GenzBretz(), abseps = 1e-5, releps = 1e-5)
g3 <- function() pmvnorm(lower = rep(-0.5, m),
                         upper = c(1, 4, 2), mean = rep(0, m), corr = sigma,
                         alg = TVPACK(), abseps = 1e-5, releps = 1e-5)

knitr::kable(bench::mark(g1(), g2(), g3(), iterations = 20, check = FALSE)[, 1:9],
             digits = 3, row.names = FALSE)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
g1() 697µs 1.27ms 798.719 355.34KB 0 20 0 25ms
g2() 691µs 1.28ms 816.896 2.49KB 0 20 0 24.5ms
g3() 694µs 1.27ms 811.329 2.49KB 0 20 0 24.7ms

Product of cosines

testFn0 <- function(x) prod(cos(x))
testFn0_v <- function(x) matrix(apply(x, 2, function(z) prod(cos(z))), ncol = ncol(x))

d <- harness(f = testFn0, fv = testFn0_v,
             lowerLimit = rep(0, 2), upperLimit = rep(1, 2), iterations = 1000)
knitr::kable(d, digits = 3)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 32µs 35.4µs 27391.853 7.66KB 27.419 999 1 36.5ms
Vectorized Hcubature 53.7µs 58.5µs 16692.688 1.16KB 16.709 999 1 59.8ms
Non-vectorized Pcubature 43.7µs 48.7µs 20214.521 0B 20.235 999 1 49.4ms
Vectorized Pcubature 96.1µs 106.2µs 9316.591 18.68KB 18.671 998 2 107.1ms
Non-vectorized cubature::cuhre 297.1µs 332.5µs 2974.396 0B 17.954 994 6 334.2ms
Vectorized cubature::cuhre 323.1µs 358µs 2783.601 16.38KB 19.623 993 7 356.7ms

Gaussian function

testFn1 <- function(x) {
    val <- sum(((1 - x) / x)^2)
    scale <- prod((2 / sqrt(pi)) / x^2)
    exp(-val) * scale
}

testFn1_v <- function(x) {
    val <- matrix(apply(x, 2, function(z) sum(((1 - z) / z)^2)), ncol(x))
    scale <- matrix(apply(x, 2, function(z) prod((2 / sqrt(pi)) / z^2)), ncol(x))
    exp(-val) * scale
}

d <- harness(f = testFn1, fv = testFn1_v,
             lowerLimit = rep(0, 3), upperLimit = rep(1, 3), iterations = 10)

knitr::kable(d, digits = 3)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 2.78ms 2.91ms 343.638 65.2KB 0.000 10 0 29.1ms
Vectorized Hcubature 4.51ms 4.58ms 217.039 290.5KB 24.115 9 1 41.47ms
Non-vectorized Pcubature 87.36µs 91.53µs 10155.636 0B 0.000 10 0 984.67µs
Vectorized Pcubature 147.38µs 157.68µs 6031.946 4.1KB 0.000 10 0 1.66ms
Non-vectorized cubature::cuhre 13.21ms 14.16ms 72.461 0B 31.055 7 3 96.6ms
Vectorized cubature::cuhre 17.85ms 18.37ms 54.381 971.5KB 23.306 7 3 128.72ms

Discontinuous function

testFn2 <- function(x) {
    radius <- 0.50124145262344534123412
    ifelse(sum(x * x) < radius * radius, 1, 0)
}

testFn2_v <- function(x) {
    radius <- 0.50124145262344534123412
    matrix(apply(x, 2, function(z) ifelse(sum(z * z) < radius * radius, 1, 0)), ncol = ncol(x))
}

d <- harness(which = c("hc", "hc.v", "cc", "cc_v"),
             f = testFn2, fv = testFn2_v,
             lowerLimit = rep(0, 2), upperLimit = rep(1, 2), iterations = 10)
knitr::kable(d, digits = 3)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 39.8ms 40.2ms 23.486 17.7KB 25.834 10 11 425.8ms
Vectorized Hcubature 45.1ms 45.5ms 21.830 1011.8KB 24.013 10 11 458.08ms
Non-vectorized cubature::cuhre 763.5ms 779.1ms 1.276 0B 22.331 10 175 7.84s
Vectorized cubature::cuhre 826.5ms 851.5ms 1.166 21.2MB 17.483 10 150 8.58s

A simple polynomial (product of coordinates)

testFn3 <- function(x) prod(2 * x)
testFn3_v <- function(x) matrix(apply(x, 2, function(z) prod(2 * z)), ncol = ncol(x))

d <- harness(f = testFn3, fv = testFn3_v,
             lowerLimit = rep(0, 3), upperLimit = rep(1, 3), iterations = 50)
knitr::kable(d, digits = 3)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 52.7µs 58.6µs 16475.944 6.75KB 0.000 50 0 3.04ms
Vectorized Hcubature 75.6µs 82.3µs 11602.134 2.91KB 0.000 50 0 4.31ms
Non-vectorized Pcubature 47.4µs 51.8µs 18624.843 0B 0.000 50 0 2.69ms
Vectorized Pcubature 66.9µs 76.1µs 12516.332 19.12KB 255.435 49 1 3.92ms
Non-vectorized cubature::cuhre 596.3µs 645.2µs 1541.859 0B 0.000 50 0 32.43ms
Vectorized cubature::cuhre 546µs 600.4µs 1663.893 39.84KB 33.957 49 1 29.45ms

Gaussian centered at \(\frac{1}{2}\)

testFn4 <- function(x) {
    a <- 0.1
    s <- sum((x - 0.5)^2)
    ((2 / sqrt(pi)) / (2. * a))^length(x) * exp (-s / (a * a))
}

testFn4_v <- function(x) {
    a <- 0.1
    r <- apply(x, 2, function(z) {
        s <- sum((z - 0.5)^2)
        ((2 / sqrt(pi)) / (2. * a))^length(z) * exp (-s / (a * a))
    })
    matrix(r, ncol = ncol(x))
}

d <- harness(f = testFn4, fv = testFn4_v,
             lowerLimit = rep(0, 2), upperLimit = rep(1, 2), iterations = 20)
knitr::kable(d, digits = 3)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 1.24ms 1.37ms 730.977 85.2KB 38.472 19 1 26ms
Vectorized Hcubature 1.7ms 1.76ms 567.239 147.2KB 0.000 20 0 35.3ms
Non-vectorized Pcubature 1.86ms 2.02ms 499.650 0B 26.297 19 1 38ms
Vectorized Pcubature 2.45ms 2.62ms 385.730 68.9KB 20.302 19 1 49.3ms
Non-vectorized cubature::cuhre 3.19ms 3.25ms 300.738 0B 15.828 19 1 63.2ms
Vectorized cubature::cuhre 3.51ms 3.74ms 271.536 125.6KB 14.291 19 1 70ms

Double Gaussian

testFn5 <- function(x) {
    a <- 0.1
    s1 <- sum((x - 1 / 3)^2)
    s2 <- sum((x - 2 / 3)^2)
    0.5 * ((2 / sqrt(pi)) / (2. * a))^length(x) * (exp(-s1 / (a * a)) + exp(-s2 / (a * a)))
}
testFn5_v <- function(x) {
    a <- 0.1
    r <- apply(x, 2, function(z) {
        s1 <- sum((z - 1 / 3)^2)
        s2 <- sum((z - 2 / 3)^2)
        0.5 * ((2 / sqrt(pi)) / (2. * a))^length(z) * (exp(-s1 / (a * a)) + exp(-s2 / (a * a)))
    })
    matrix(r, ncol = ncol(x))
}

d <- harness(f = testFn5, fv = testFn5_v,
             lowerLimit = rep(0, 2), upperLimit = rep(1, 2), iterations = 20)
knitr::kable(d, digits = 3)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 3.34ms 3.54ms 277.818 133KB 30.869 18 2 64.8ms
Vectorized Hcubature 4.38ms 4.46ms 222.767 249KB 11.725 19 1 85.3ms
Non-vectorized Pcubature 2.32ms 2.4ms 414.274 0B 21.804 19 1 45.9ms
Vectorized Pcubature 3.08ms 3.12ms 318.681 69KB 16.773 19 1 59.6ms
Non-vectorized cubature::cuhre 6.82ms 6.86ms 145.260 0B 25.634 17 3 117ms
Vectorized cubature::cuhre 7.72ms 7.88ms 126.432 224KB 22.312 17 3 134.5ms

Tsuda’s example

testFn6 <- function(x) {
    a <- (1 + sqrt(10.0)) / 9.0
    prod( a / (a + 1) * ((a + 1) / (a + x))^2)
}

testFn6_v <- function(x) {
    a <- (1 + sqrt(10.0)) / 9.0
    r <- apply(x, 2, function(z) prod( a / (a + 1) * ((a + 1) / (a + z))^2))
    matrix(r, ncol = ncol(x))
}

d <- harness(f = testFn6, fv = testFn6_v,
             lowerLimit = rep(0, 3), upperLimit = rep(1, 3), iterations = 20)
knitr::kable(d, digits = 3)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 1.46ms 1.53ms 651.086 64.6KB 34.268 19 1 29.2ms
Vectorized Hcubature 1.87ms 1.91ms 522.714 156KB 0.000 20 0 38.3ms
Non-vectorized Pcubature 7.48ms 7.83ms 127.964 0B 31.991 16 4 125ms
Vectorized Pcubature 9.14ms 9.34ms 107.317 386.2KB 18.938 17 3 158.4ms
Non-vectorized cubature::cuhre 4.22ms 4.26ms 234.723 0B 12.354 19 1 80.9ms
Vectorized cubature::cuhre 4.14ms 4.21ms 236.570 225.8KB 26.286 18 2 76.1ms

Morokoff & Caflisch example

testFn7 <- function(x) {
    n <- length(x)
    p <- 1/n
    (1 + p)^n * prod(x^p)
}
testFn7_v <- function(x) {
    matrix(apply(x, 2, function(z) {
        n <- length(z)
        p <- 1/n
        (1 + p)^n * prod(z^p)
    }), ncol = ncol(x))
}

d <- harness(f = testFn7, fv = testFn7_v,
             lowerLimit = rep(0, 3), upperLimit = rep(1, 3), iterations = 20)
knitr::kable(d, digits = 3)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 3.02ms 3.33ms 304.037 32.89KB 16.002 19 1 62.5ms
Vectorized Hcubature 3.79ms 4.1ms 248.882 205.61KB 27.654 18 2 72.3ms
Non-vectorized Pcubature 7.57ms 8.16ms 123.059 0B 21.716 17 3 138.1ms
Vectorized Pcubature 8.96ms 9.35ms 106.659 386.24KB 18.822 17 3 159.4ms
Non-vectorized cubature::cuhre 40.86ms 40.99ms 24.414 0B 73.243 5 15 204.8ms
Vectorized cubature::cuhre 38.74ms 39.03ms 25.577 2.04MB 59.679 6 14 234.6ms

Wang-Landau sampling 1d, 2d examples

I.1d <- function(x) {
    sin(4 * x) *
        x * ((x * ( x * (x * x - 4) + 1) - 1))
}
I.1d_v <- function(x) {
    matrix(apply(x, 2, function(z)
        sin(4 * z) *
        z * ((z * ( z * (z * z - 4) + 1) - 1))),
        ncol = ncol(x))
}
d <- harness(f = I.1d, fv = I.1d_v,
             lowerLimit = -2, upperLimit = 2, iterations = 100)
knitr::kable(d, digits = 3)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 120µs 126µs 7738.623 53.7KB 0.000 100 0 12.92ms
Vectorized Hcubature 190µs 206µs 4688.602 68.5KB 47.360 99 1 21.11ms
Non-vectorized Pcubature 49µs 51µs 18494.670 0B 0.000 100 0 5.41ms
Vectorized Pcubature 131µs 138µs 6959.891 0B 0.000 100 0 14.37ms
Non-vectorized cubature::cuhre 202µs 217µs 4538.873 0B 0.000 100 0 22.03ms
Vectorized cubature::cuhre 440µs 480µs 2011.360 0B 20.317 99 1 49.22ms
I.2d <- function(x) {
    x1 <- x[1]; x2 <- x[2]
    sin(4 * x1 + 1) * cos(4 * x2) * x1 * (x1 * (x1 * x1)^2 - x2 * (x2 * x2 - x1) +2)
}
I.2d_v <- function(x) {
    matrix(apply(x, 2,
                 function(z) {
                     x1 <- z[1]; x2 <- z[2]
                     sin(4 * x1 + 1) * cos(4 * x2) * x1 * (x1 * (x1 * x1)^2 - x2 * (x2 * x2 - x1) +2)
                 }),
           ncol = ncol(x))
}
d <- harness(f = I.2d, fv = I.2d_v,
             lowerLimit = rep(-1, 2), upperLimit = rep(1, 2), iterations = 100)
knitr::kable(d, digits = 3)
expression min median itr/sec mem_alloc gc/sec n_itr n_gc total_time
Non-vectorized Hcubature 4.37ms 4.67ms 215.674 78.4KB 21.330 91 9 421.9ms
Vectorized Hcubature 5.46ms 5.63ms 177.594 304.7KB 17.564 91 9 512.4ms
Non-vectorized Pcubature 379.7µs 418.51µs 2343.493 0B 23.672 99 1 42.2ms
Vectorized Pcubature 579.49µs 615.68µs 1608.101 18.3KB 16.243 99 1 61.6ms
Non-vectorized cubature::cuhre 1.16ms 1.25ms 796.641 0B 16.258 98 2 123ms
Vectorized cubature::cuhre 1.29ms 1.34ms 736.951 60.1KB 15.040 98 2 133ms

Summary

The recommendations are:

  1. Vectorize your integrand. The time spent in so doing pays back enormously on all but the most trivial problems. This is easy to do and the examples above show how.

  2. Vectorized hcubature is a good default starting point. It handles the widest range of problems well.

  3. For smooth integrands in low dimensions (\(\leq 3\)), try pcubature. It can be substantially faster than hcubature when its assumptions hold. Experiment before committing in a production setting, and be aware of the sampling-density cliff documented in the Get Started vignette — when in doubt, cross-check with cuhre.

  4. For non-smooth or localized integrands, prefer cubintegrate(method = "cuhre") or at least hcubature(..., robust = TRUE). See the Robustness section of the Get Started vignette.

Session info

sessionInfo()
## R version 4.6.2 (2026-10-29)
## Platform: x86_64-pc-linux-gnu
## Running under: Ubuntu 26.04.1 LTS
## 
## Matrix products: default
## BLAS:   /usr/lib/x86_64-linux-gnu/openblas-pthread/libblas.so.3 
## LAPACK: /usr/lib/x86_64-linux-gnu/openblas-pthread/libopenblasp-r0.3.32.so;  LAPACK version 3.12.0
## 
## locale:
##  [1] LC_CTYPE=en_US.UTF-8       LC_NUMERIC=C              
##  [3] LC_TIME=en_US.UTF-8        LC_COLLATE=en_US.UTF-8    
##  [5] LC_MONETARY=en_US.UTF-8    LC_MESSAGES=en_US.UTF-8   
##  [7] LC_PAPER=en_US.UTF-8       LC_NAME=C                 
##  [9] LC_ADDRESS=C               LC_TELEPHONE=C            
## [11] LC_MEASUREMENT=en_US.UTF-8 LC_IDENTIFICATION=C       
## 
## time zone: Etc/UTC
## tzcode source: system (glibc)
## 
## attached base packages:
## [1] stats     graphics  grDevices utils     datasets  methods   base     
## 
## other attached packages:
## [1] mvtnorm_1.4-2  bench_1.1.4    cubature_2.2.0
## 
## loaded via a namespace (and not attached):
##  [1] vctrs_0.7.3      cli_3.6.6        knitr_1.52       rlang_1.3.0     
##  [5] xfun_0.62        otel_0.3.0       jsonlite_2.0.0   glue_1.8.1      
##  [9] buildtools_1.0.0 htmltools_0.5.9  maketools_1.3.2  sys_3.4.3       
## [13] sass_0.4.10      rmarkdown_2.32   tibble_3.3.1     evaluate_1.0.5  
## [17] jquerylib_0.1.4  fastmap_1.2.0    yaml_2.3.12      profmem_0.7.0   
## [21] lifecycle_1.0.5  compiler_4.6.2   pkgconfig_2.0.3  Rcpp_1.1.2      
## [25] digest_0.6.39    R6_2.6.1         pillar_1.11.1    magrittr_2.0.5  
## [29] bslib_0.12.0     tools_4.6.2      cachem_1.1.0