Di recente ho osservato la simulazione Monte Carlo e l'ho usata per approssimare costanti come $\pi$ (cerchio all'interno di un rettangolo, area proporzionata).

Tuttavia, non riesco a pensare a un metodo corrispondente per approssimare il valore di $e$ [numero di Eulero] usando l'integrazione di Monte Carlo.

Hai qualche suggerimento su come farlo?

Il modo semplice ed elegante per stimare di Monte Carlo è descritto in questo documento . Il documento riguarda in realtà l'insegnamento e . Quindi, l'approccio sembra perfettamente adatto al tuo obiettivo. L'idea si basa su un esercizio tratto da un popolare libro di testo russo sulla teoria della probabilità di Gnedenko. Vedi ex.22 a p.183$e$$e$

Succede in modo che , dove ξ è una variabile casuale definita come segue. È il numero minimo di n tale che Σ n i = 1 r i > 1 e r i sono numeri casuali da una distribuzione uniforme su [ 0 , 1 ] . Bello, no ?!$E[\xi]=e$$\xi$$n$$\sum_{i=1}^n r_i>1$$r_i$$[0,1]$

Dal momento che è un esercizio, non sono sicuro che sia bello per me pubblicare la soluzione (prova) qui :) Se desideri dimostrarlo tu stesso, ecco un suggerimento: il capitolo si chiama "Momenti", che dovrebbe indicare tu nella giusta direzione.

Se vuoi implementarlo da solo, allora non leggere oltre!

Questo è un semplice algoritmo per la simulazione Monte Carlo. Disegna un casuale uniforme, quindi un altro e così via fino a quando la somma non supera 1. Il numero di random estratti è la tua prima prova. Diciamo che hai:

 0.0180
 0.4596
 0.7920

Quindi viene eseguito il rendering della tua prima prova 3. Continua a fare queste prove e noterai che in media ottieni .$e$

Seguono il codice MATLAB, il risultato della simulazione e l'istogramma.

N = 10000000;
n = N;
s = 0;
i = 0;
maxl = 0;
f = 0;
while n > 0
    s = s + rand;
    i = i + 1;
    if s > 1
        if i > maxl
            f(i) = 1;
            maxl = i;
        else
            f(i) = f(i) + 1;
        end
        i = 0;
        s = 0;
        n = n - 1;
    end
end

disp ((1:maxl)*f'/sum(f))
bar(f/sum(f))
grid on

f/sum(f)

Il risultato e l'istogramma:

2.7183


ans =

  Columns 1 through 8

         0    0.5000    0.3332    0.1250    0.0334    0.0070    0.0012    0.0002

  Columns 9 through 11

    0.0000    0.0000    0.0000

AGGIORNAMENTO: ho aggiornato il mio codice per eliminare la matrice dei risultati della prova in modo che non richieda RAM. Ho anche stampato la stima del PMF.

Aggiornamento 2: ecco la mia soluzione Excel. Inserisci un pulsante in Excel e collegalo alla seguente macro VBA:

Private Sub CommandButton1_Click()
n = Cells(1, 4).Value
Range("A:B").Value = ""
n = n
s = 0
i = 0
maxl = 0
Cells(1, 2).Value = "Frequency"
Cells(1, 1).Value = "n"
Cells(1, 3).Value = "# of trials"
Cells(2, 3).Value = "simulated e"
While n > 0
    s = s + Rnd()
    i = i + 1
    If s > 1 Then
        If i > maxl Then
            Cells(i, 1).Value = i
            Cells(i, 2).Value = 1
            maxl = i
        Else
            Cells(i, 1).Value = i
            Cells(i, 2).Value = Cells(i, 2).Value + 1
        End If
        i = 0
        s = 0
        n = n - 1
    End If
Wend


s = 0
For i = 2 To maxl
    s = s + Cells(i, 1) * Cells(i, 2)
Next


Cells(2, 4).Value = s / Cells(1, 4).Value

Rem bar (f / Sum(f))
Rem grid on

Rem f/sum(f)

End Sub

Immettere il numero di prove, ad esempio 1000, nella cella D1 e fare clic sul pulsante. Ecco come dovrebbe apparire lo schermo dopo la prima esecuzione:

AGGIORNAMENTO 3: Silverfish mi ha ispirato in un altro modo, non elegante come il primo ma comunque bello. Ha calcolato i volumi di n-simplex usando sequenze di Sobol .

s = 2;
for i=2:10
    p=sobolset(i);
    N = 10000;
    X=net(p,N)';
    s = s + (sum(sum(X)<1)/N);
end
disp(s)

2.712800000000001

Per coincidenza ha scritto il primo libro sul metodo Monte Carlo che ho letto al liceo. Secondo me è la migliore introduzione al metodo.

AGGIORNAMENTO 4:

Silverfish nei commenti ha suggerito una semplice implementazione della formula Excel. Questo è il tipo di risultato che ottieni con il suo approccio dopo circa 1 milione di numeri casuali e 185.000 prove:

Ovviamente, questo è molto più lento dell'implementazione VBA di Excel. In particolare, se modifichi il mio codice VBA per non aggiornare i valori della cella all'interno del ciclo e lo fai solo una volta raccolte tutte le statistiche.

AGGIORNAMENTO 5

La soluzione n. 3 di Xi'an è strettamente correlata (o anche la stessa in un certo senso come nel commento di jwg nel thread). È difficile dire chi abbia avuto l'idea prima di Forsythe o Gnedenko. L'edizione 1950 originale di Gnedenko in russo non ha sezioni Problemi nei Capitoli. Quindi, non riuscivo a trovare questo problema a prima vista dove si trova nelle edizioni successive. Forse è stato aggiunto in seguito o seppellito nel testo.

Come ho commentato nella risposta di Xi'an, l'approccio di Forsythe è collegato a un'altra area interessante: la distribuzione delle distanze tra picchi (estremi) in sequenze casuali (IID). La distanza media risulta essere 3. La sequenza discendente nell'approccio di Forsythe termina con un fondo, quindi se continui il campionamento otterrai un altro fondo in un punto, poi un altro ecc. Puoi tracciare la distanza tra loro e costruire la distribuzione.

Suggerisco di votare la risposta di Aksakal. È imparziale e si basa solo su un metodo per generare deviazioni uniformi dell'unità.

La mia risposta può essere resa arbitrariamente precisa, ma è ancora distorta dal vero valore di .$e$

La risposta di Xi'an è corretta, ma penso che la sua dipendenza dalla funzione o da un modo di generare deviate casuali di Poisson sia un po 'circolare quando lo scopo è di approssimare e .$\log$$e$

Stima tramite Bootstrapping$e$

Invece, considera la procedura di bootstrap. Uno ha un gran numero di oggetti che sono disegnati con la sostituzione di una dimensione del campione di n . Ad ogni pareggio, la probabilità di non disegnare un particolare oggetto i è 1 - n - 1 e non vi sono n tali pareggi. La probabilità che un particolare oggetto venga omesso da tutti i sorteggi è p = ( 1 - $n$$n$$i$$1-n^{-1}$$n$$p=(1-\frac{1}{n})^n.$

Perché presumo sappiamo che

così anche noi possiamo scrivere

Cioè, la nostra stima di si trova stimando la probabilità che una specifica osservazione sia omessa da m bootstrap replica B j attraverso molti di questi replicati - cioè la frazione di occorrenze dell'oggetto i nei bootstrap.$p$$m$$B_j$$i$

Ci sono due fonti di errore in questa approssimazione. finito significa sempre che i risultati sono approssimativi, ovvero che la stima è distorta. Inoltre, p fluttuerà intorno al vero valore, perché questa è una simulazione.$n$$\hat{p}$

Trovo che questo approccio un po 'affascinante perché uno studente o di un'altra persona con sufficiente poco a che fare potrebbe approssimare utilizzando un mazzo di carte, un mucchio di piccole pietre, o altri oggetti a portata di mano, nella stessa vena come una persona potrebbe stimare π utilizzando una bussola, una retta e alcuni granelli di sabbia. Penso che sia pulito quando la matematica può essere separata dalle comodità moderne come i computer.$e$$\pi$

risultati

Ho condotto diverse simulazioni per un numero diverso di repliche bootstrap. Gli errori standard sono stimati utilizzando intervalli normali.

Si noti che la scelta di il numero di oggetti sottoposti a bootstrap imposta un limite superiore assoluto sull'accuratezza dei risultati poiché la procedura Monte Carlo sta valutando p e p dipende solo da n . L'impostazione di n come inutilmente grande semplicemente ingombrerà il tuo computer, o perché hai solo bisogno di un'approssimazione "approssimativa" a e o perché il bias sarà sommerso dalla varianza dovuta al Monte Carlo. Questi risultati sono per n = 10 3 e p - 1 ≈ e è preciso al terzo decimale.$n$$p$$p$$n$$n$$e$$n=10^3$$p^{-1}\approx e$

Questo grafico mostra che la scelta di ha conseguenze dirette e profonde per la stabilità a p . La linea tratteggiata blu mostra p e la linea rossa indica e . Come previsto, aumentando la dimensione del campione produce stime sempre più accurate p . $m$$\hat{p}$$p$$e$$\hat{p}$

Ho scritto una sceneggiatura R imbarazzantemente lunga per questo. Suggerimenti per il miglioramento possono essere inviati sul retro di una fattura di $ 20.

library(boot)
library(plotrix)
n <- 1e3

## if p_hat is estimated with 0 variance (in the limit of infinite bootstraps), then the best estimate we can come up with is biased by exactly this much:
approx <- 1/((1-1/n)^n)

dat <- c("A", rep("B", n-1))
indicator <- function(x, ndx)   xor("A"%in%x[ndx], TRUE) ## Because we want to count when "A" is *not* in the bootstrap sample

p_hat <- function(dat, m=1e3){
    foo <- boot(data=dat, statistic=indicator, R=m) 
    1/mean(foo$t)
} 

reps <- replicate(100, p_hat(dat))

boxplot(reps)
abline(h=exp(1),col="red")

p_mean <- NULL
p_var <- NULL
for(i in 1:10){
    reps <- replicate(2^i, p_hat(dat))
    p_mean[i] <- mean(reps)
    p_var[i] <- sd(reps)
}
plotCI(2^(1:10), p_mean, uiw=qnorm(0.975)*p_var/sqrt(2^(1:10)),xlab="m", log="x", ylab=expression(hat(p)), main=expression(paste("Monte Carlo Estimates of ", tilde(e))))
abline(h=approx, col='red')

Soluzione 1:

$\mathcal{P}(\lambda)$

$U_{(i:n)}-U_{(i-1:n)}$$\mathfrak{B}(1,n)$

$$\mathbb{P}(n\{U_{(i:n)}-U_{(i-1:n)}\}\ge 1)=\left(1-\frac{1}{n}\right)^n$$ $e^{-1}$$n$

Soluzione 2:

$e$

Soluzione 3:

$u_1,u_2,...$$u_{n+1}>u_{n}$$N$$e$$N$$e^{-1}$$\exp G(x)$$e$$e^{-1}$

$1/n!$$n$

Una rapida implementazione R del metodo di Forsythe è quella di rinunciare a seguire precisamente la sequenza di uniformi a favore di blocchi più grandi, che consente l'elaborazione parallela:

use=runif(n)
band=max(diff((1:(n-1))[diff(use)>0]))+1
bends=apply(apply((apply(matrix(use[1:((n%/%band)*band)],nrow=band),
2,diff)<0),2,cumprod),2,sum)

Non una soluzione ... solo un breve commento che è troppo lungo per la casella dei commenti.

Aksakal

Aksakal ha pubblicato una soluzione in cui calcoliamo il numero previsto di disegni uniformi standard che devono essere presi, in modo che la loro somma superi 1. In Mathematica , la mia prima formulazione è stata:

mrM := NestWhileList[(Random[] + #) &, Random[], #<1 &]

Mean[Table[Length[mrM], {10^6}]] 

EDIT: ho appena avuto un gioco veloce con questo, e il seguente codice (stesso metodo - anche in Mma - solo codice diverso) è circa 10 volte più veloce:

Mean[Table[Module[{u=Random[], t=1},  While[u<1, u=Random[]+u; t++]; t] , {10^6}]]

Xian / Whuber

Whuber ha suggerito un codice cool veloce per simulare la soluzione di Xian 1:

Versione R: n <- 1e5; 1/mean(n*diff(sort(runif(n+1))) > 1)

Versione MMA: n=10^6; 1. / Mean[UnitStep[Differences[Sort[RandomReal[{0, n}, n + 1]]] - 1]]

che nota è 20 volte più veloce del primo codice (o circa due volte più veloce del nuovo codice sopra).

Solo per divertimento, ho pensato che sarebbe stato interessante vedere se entrambi gli approcci fossero altrettanto efficienti (in senso statistico). Per fare ciò, ho generato 2000 stime di e usando:

• Metodo di Aksakal: dataA
• Metodo 1 di Xian usando il codice whuber: dataB

... entrambi a Mathematica . Il diagramma seguente contrappone una stima della densità del kernel non parametrica dei set di dati risultanti A e dataB.

Quindi, mentre il codice di whuber (curva rossa) è circa due volte più veloce, il metodo non sembra essere "affidabile".

Metodo che richiede una quantità empia di campioni

$f(x) = e^x$$\frac{ \bar x \sqrt{12}}{ \sqrt{n}} \dot \sim N(0,1)$$e$$\infty$$\infty$ quando la dimensione del campione si avvicina all'infinito.

$N(0,1)$$e^{x}$ regola !). Per rendere coerenti le stime della densità, dovrai lasciare che il tuo df (numero di bin nell'istogramma, inverso della finestra per più uniforme) si avvicini all'infinito, ma più lentamente della dimensione del campione.

$N(0,1)$$\hat \phi(x)$$\phi(\sqrt(2) ) = (2 \pi)^{-1/2} e^{-1}$$e = \hat \phi(\sqrt{2}) \sqrt{2 \pi}$

$\sqrt{2}$$\sqrt{2\pi}$

Metodo che richiede pochissimi campioni, ma causa una quantità empia di errore numerico

Una risposta completamente stupida, ma molto efficiente, basata su un commento che ho fatto:

$X \sim \text{uniform}(-1, 1)$$Y_n = | (\bar x)^n|$$\hat e = (1 - Y_n)^{-1/Y_n}$

Questo converge molto velocemente, ma si imbatte anche in un errore numerico estremo.

$Y_n$$1/Y_n$$n \rightarrow \infty$$Y_n$$Y_n = 0$$e$

Ecco un altro modo in cui può essere fatto, anche se è piuttosto lento. Non pretendo di essere efficiente, ma offro questa alternativa nello spirito di completezza.

$n$$U_1, \cdots , U_n \sim \text{IID U}(0,1)$$e$$^\dagger$

$e$$u_{(1)} \geqslant \cdots \geqslant u_{(n)}$

$m \equiv \min \{ k | S(k) \geqslant 1 \}$$1/e$$e$

$1/e$$e$$e$

Implementazione in R: il metodo può essere implementato Rusando runifper generare valori uniformi. Il codice è il seguente:

EST_EULER <- function(n) { U <- sort(runif(n), decreasing = TRUE);
                           S <- cumsum(1/U)/n;
                           m <- min(which(S >= 1));
                           2/(U[m-1]+U[m]); }

$e$

set.seed(1234);

EST_EULER(10^3);
[1] 2.715426

EST_EULER(10^4);
[1] 2.678373

EST_EULER(10^5);
[1] 2.722868

EST_EULER(10^6); 
[1] 2.722207

EST_EULER(10^7);
[1] 2.718775

EST_EULER(10^8);
[1] 2.718434

> exp(1)
[1] 2.718282

$^\dagger$$e$