Які переваги експоненціального генератора випадкових випадків використовують метод Аренса і Дітера (1972), а не шляхом зворотного перетворення?

Моє питання надихає вбудований генератор експоненціальних випадкових чисел R , функція rexp(). Намагаючись генерувати експоненціально розподілені випадкові числа, багато підручників рекомендують метод зворотного перетворення, як описано на цій сторінці Вікіпедії . Я усвідомлюю, що є інші методи для виконання цього завдання. Зокрема, у вихідному коді R використовується алгоритм, викладений у статті Ahrens & Dieter (1972) .

Я переконав себе, що метод Аренса-Дітера (AD) є правильним. Проте я не бачу вигоди від використання їх методу порівняно з методом зворотного перетворення (ІТ). AD не тільки складніший для впровадження, ніж ІТ. Зрозуміло, що також немає переваги швидкості. Ось мій код R для порівняння обох методів з результатами.

invTrans <- function(n)
    -log(runif(n))
print("For the inverse transform:")
print(system.time(invTrans(1e8)))
print("For the Ahrens-Dieter algorithm:")
print(system.time(rexp(1e8)))

Результати:

[1] "For the inverse transform:" 
user     system     elapsed
4.227    0.266      4.597 
[1] "For the Ahrens-Dieter algorithm:"
user     system     elapsed
4.919    0.265      5.213

Порівнюючи код для двох методів, AD малює щонайменше два рівномірних випадкових числа (з функцією Cunif_rand() ), щоб отримати одне експоненціальне випадкове число. ІТ потрібно лише одне єдине випадкове число. Імовірно, основна команда R вирішила проти впровадження ІТ, оскільки передбачала, що прийняття логарифму може бути повільніше, ніж генерування більш рівномірних випадкових чисел. Я розумію, що швидкість прийому логарифмів може бути машинно залежною, але принаймні для мене це навпаки. Можливо, є проблеми навколо чисельної точності ІТ, пов'язаних із особливістю логарифму при 0? Але тоді, вихідний код R sexp.cпоказує, що реалізація AD також втрачає деяку числову точність, оскільки наступна частина коду С видаляє провідні біти з рівномірного випадкового числа u .

double u = unif_rand();
while(u <= 0. || u >= 1.) u = unif_rand();
for (;;) {
    u += u;
    if (u > 1.)
        break;
    a += q[0];
}
u -= 1.;

U пізніше перероблені в вигляді однорідного випадкового числа в іншій частині sexp.c . Поки що, здається, ніби

• ІТ простіше кодувати,
• ІТ швидше, і
• І IT, і AD можливо втрачають числову точність.

Я дуже вдячний, якби хтось міг пояснити, чому R все ще реалізує AD як єдиний доступний варіант для rexp().

На моєму комп’ютері (пробачте мою французьку!):

> print(system.time(rexp(1e8)))
utilisateur     système      écoulé 
      4.617       0.320       4.935 
> print(system.time(rexp(1e8)))
utilisateur     système      écoulé 
      4.589       2.045       6.629 
> print(system.time(-log(runif(1e8))))
utilisateur     système      écoulé 
      7.455       1.080       8.528 
> print(system.time(-log(runif(1e8))))
utilisateur     système      écoulé 
      9.140       1.489      10.623

обернене перетворення робить гірше. Але слід стежити за мінливістю. Введення параметра швидкості призводить до ще більшої мінливості для зворотного перетворення:

> print(system.time(rexp(1e8,rate=.01)))
utilisateur     système      écoulé 
      4.594       0.456       5.047 
> print(system.time(rexp(1e8,rate=.01)))
utilisateur     système      écoulé 
      4.661       1.319       5.976 
> print(system.time(-log(runif(1e8))/.01))
utilisateur     système      écoulé 
     15.675       2.139      17.803 
> print(system.time(-log(runif(1e8))/.01))
utilisateur     système      écoulé 
      7.863       1.122       8.977 
> print(system.time(rexp(1e8,rate=101.01)))
utilisateur     système      écoulé 
      4.610       0.220       4.826 
> print(system.time(rexp(1e8,rate=101.01)))
utilisateur     système      écoulé 
      4.621       0.156       4.774 
> print(system.time(-log(runif(1e8))/101.01))
utilisateur     système      écoulé 
      7.858       0.965       8.819 > 
> print(system.time(-log(runif(1e8))/101.01))
utilisateur     système      écoulé 
     13.924       1.345      15.262 

Ось порівняння з використанням rbenchmark:

> benchmark(x=rexp(1e6,rate=101.01))
  elapsed user.self sys.self
  4.617     4.564    0.056
> benchmark(x=-log(runif(1e6))/101.01)
  elapsed user.self sys.self
  14.749   14.571    0.184
> benchmark(x=rgamma(1e6,shape=1,rate=101.01))
  elapsed user.self sys.self
  14.421   14.362    0.063
> benchmark(x=rexp(1e6,rate=.01))
  elapsed user.self sys.self
  9.414     9.281    0.136
> benchmark(x=-log(runif(1e6))/.01)
  elapsed user.self sys.self
  7.953     7.866    0.092
> benchmark(x=rgamma(1e6,shape=1,rate=.01))
  elapsed user.self sys.self
  26.69    26.649    0.056

Тож пробіг все ще змінюється, залежно від масштабу!

Це лише цитування статті в розділі "Алгоритм LG: (метод логарифму)":

$X=-ALOG(REGOL(IR))$$\mu$$\mu$$\mu$$u$

Так виглядає, що автори обрали інші методи, щоб уникнути цього «виробника» обмеження повільних логарифмів. Можливо, тоді це питання найкраще перенести на stackoverflow, де хтось, хто має знання про кишки R, може прокоментувати.

Просто запустивши це microbenchmark; На моїй машині рідний підхід R рівномірно швидший:

library(microbenchmark)
microbenchmark(times = 10L,
               R_native = rexp(1e8),
               dir_inv = -log(runif(1e8)))
# Unit: seconds
#      expr      min       lq     mean   median       uq      max neval
#  R_native 3.643980 3.655015 3.687062 3.677351 3.699971 3.783529    10
#   dir_inv 5.780103 5.783707 5.888088 5.912384 5.946964 6.050098    10

$\lambda = 1$

lambdas = seq(0, 10, length.out = 25L)[-1L]
png("~/Desktop/micro.png")
matplot(lambdas, 
        ts <- 
          t(sapply(lambdas, function(ll)
            print(microbenchmark(times = 50L,
                                 R_native = rexp(5e5, rate = ll),
                                 dir_inv = -log(runif(5e5))/ll),
                  unit = "relative")[ , "median"])),
        type = "l", lwd = 3L, xlab = expression(lambda),
        ylab = "Relative Timing", lty = 1L,
        col = c("black", "red"), las = 1L,
        main = paste0("Direct Computation of Exponential Variates\n",
                      "vs. R Native Generator (Ahrens-Dieter)"))
text(lambdas[1L], ts[1L, ], c("A-D", "Direct"), pos = 3L)
dev.off()