Ich habe mir kürzlich die Monte-Carlo-Simulation angesehen und sie verwendet, um Konstanten wie (Kreis in einem Rechteck, proportionale Fläche) anzunähern.$\pi$

Ich kann mir jedoch keine entsprechende Methode vorstellen, um den Wert von [Eulers Zahl] mithilfe der Monte-Carlo-Integration zu approximieren .$e$

Haben Sie Hinweise, wie dies getan werden kann?

Die einfache und elegante Art, nach Monte Carlo zu schätzen, wird in diesem Artikel beschrieben . In der Arbeit geht es eigentlich um das Unterrichten von . Daher scheint der Ansatz perfekt zu Ihrem Ziel zu passen. Die Idee basiert auf einer Übung aus einem beliebten russischen Lehrbuch zur Wahrscheinlichkeitstheorie von Gnedenko. Siehe Beispiel 22 auf S.183$e$$e$

Es passiert also, dass , wobei eine Zufallsvariable ist, die wie folgt definiert ist. Es ist die minimale Anzahl von so dass und Zufallszahlen aus der Gleichverteilung von . Schön, nicht wahr ?!ξ n ∑ n i = 1 r i > 1 r i [ 0 , 1 $E[\xi]=e$$\xi$$n$$\sum_{i=1}^n r_i>1$$r_i$$[0,1]$

Da es sich um eine Übung handelt, bin ich mir nicht sicher, ob es für mich cool ist, die Lösung (Beweis) hier zu posten :) Wenn Sie es selbst beweisen möchten, hier ein Tipp: Das Kapitel heißt "Momente", was darauf hindeuten sollte Sie in die richtige Richtung.

Wenn Sie es selbst implementieren möchten, lesen Sie nicht weiter!

Dies ist ein einfacher Algorithmus für die Monte-Carlo-Simulation. Ziehe einen einheitlichen Zufallsgenerator, dann einen weiteren und so weiter, bis die Summe 1 übersteigt. Die Anzahl der gezogenen Zufälle ist dein erster Versuch. Angenommen, Sie haben:

 0.0180
 0.4596
 0.7920

Dann wurde Ihre erste Testversion gerendert. 3. Führen Sie diese Testversionen weiter aus, und Sie werden feststellen, dass Sie im Durchschnitt .$e$

MATLAB-Code, Simulationsergebnis und das Histogramm folgen.

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)

Das Ergebnis und das Histogramm:

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

UPDATE: Ich habe meinen Code aktualisiert, um die Reihe der Testergebnisse zu entfernen, sodass kein RAM benötigt wird. Ich habe auch die PMF-Schätzung ausgedruckt.

Update 2: Hier ist meine Excel-Lösung. Fügen Sie eine Schaltfläche in Excel ein und verknüpfen Sie sie mit dem folgenden VBA-Makro:

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

Geben Sie die Anzahl der Versuche (z. B. 1000) in die Zelle D1 ein und klicken Sie auf die Schaltfläche. So sollte der Bildschirm nach dem ersten Lauf aussehen:

UPDATE 3: Silverfish hat mich auf eine andere Art inspiriert, nicht so elegant wie die erste, aber trotzdem cool. Es berechnete das Volumen von n-Simplexen unter Verwendung von Sobol- Sequenzen.

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

Zufällig schrieb er das erste Buch über die Monte-Carlo-Methode, das ich in der High School gelesen hatte. Meiner Meinung nach ist dies die beste Einführung in die Methode.

UPDATE 4:

Silverfish schlug in Kommentaren eine einfache Implementierung von Excel-Formeln vor. Dies ist die Art von Ergebnis, die Sie mit seiner Herangehensweise nach insgesamt 1 Million Zufallszahlen und 185K-Versuchen erhalten:

Dies ist offensichtlich viel langsamer als die Implementierung von Excel VBA. Insbesondere, wenn Sie meinen VBA-Code so ändern, dass die Zellenwerte in der Schleife nicht aktualisiert werden und erst dann aktualisiert werden, wenn alle Statistiken erfasst wurden.

UPDATE 5

Xi'ans Lösung Nr. 3 ist eng miteinander verwandt (oder in gewisser Weise sogar mit jwgs Kommentar im Thread identisch). Es ist schwer zu sagen, wer zuerst Forsythe oder Gnedenko auf die Idee kam. Gnedenkos Originalausgabe von 1950 in russischer Sprache enthält keine Abschnitte mit Problemen in Kapiteln. So konnte ich dieses Problem auf den ersten Blick nicht finden, wo es in späteren Ausgaben ist. Vielleicht wurde es später hinzugefügt oder im Text vergraben.

Wie ich in Xi'ans Antwort bemerkte, ist Forsythes Ansatz mit einem anderen interessanten Bereich verbunden: der Verteilung der Abstände zwischen Spitzen (Extrema) in zufälligen (IID) Sequenzen. Der mittlere Abstand ist zufällig 3. Die Abwärtssequenz in Forsythes Ansatz endet mit einem Boden. Wenn Sie also mit dem Abtasten fortfahren, erhalten Sie irgendwann einen anderen Boden, dann einen anderen usw. Sie könnten den Abstand zwischen ihnen verfolgen und die Verteilung aufbauen.

Ich schlage vor, Aksakals Antwort zu unterstützen. Es ist unvoreingenommen und stützt sich nur auf ein Verfahren zur Erzeugung einheitlicher Abweichungen.

Meine Antwort kann willkürlich präzisiert werden, ist aber immer noch vom wahren Wert von .$e$

Xi'ans Antwort ist richtig, aber ich denke, dass seine Abhängigkeit von der Funktion oder einer Methode zur Erzeugung von Poisson-Zufallsabweichungen ein wenig kreisförmig ist, wenn der Zweck darin besteht, e anzunähern .$\log$$e$

Schätzung von durch Bootstrapping$e$

Betrachten Sie stattdessen das Bootstrapping-Verfahren. Man hat eine große Anzahl von Objekten die beim Ersetzen auf eine Stichprobengröße von n gezeichnet werden . Bei jeder Ziehung beträgt die Wahrscheinlichkeit , ein bestimmtes Objekt i nicht zu zeichnen, 1 - n - 1 , und es gibt n solche Ziehungen. Die Wahrscheinlichkeit, dass ein bestimmtes Objekt in allen Ziehungen weggelassen wird, ist p = ( 1 - $n$$n$$i$$1-n^{-1}$$n$$p=(1-\frac{1}{n})^n.$

so können wir auch schreiben

Das heißt, unsere Schätzung von ergibt sich aus der Schätzung der Wahrscheinlichkeit, dass eine bestimmte Beobachtung in Bootstrap-Replikaten über viele solcher Replikate hinweg unterbleibt - dh dem Anteil des Auftretens von Objekt in den Bootstraps.m B j$p$$m$$B_j$$i$

Bei dieser Annäherung gibt es zwei Fehlerquellen. Endliches immer, dass die Ergebnisse ungefähr sind, dh die Schätzung ist verzerrt. Außerdem schwankt um den wahren Wert, da dies eine Simulation ist.$n$$\hat{p}$

Ich finde diesen Ansatz etwas charmant , weil ein Student oder eine andere Person mit ausreichend wenig zu tun annähern könnte mit einem Deck von Karten, einen Haufen von kleinen Steinen oder andere Gegenständen in der Hand, in der gleichen Richtung wie eine Person schätzen , könnte mit einem Kompass, einer geraden Kante und ein paar Sandkörnern. Ich finde es gut, wenn Mathematik von modernen Annehmlichkeiten wie Computern getrennt werden kann.$e$$\pi$

Ergebnisse

Ich habe mehrere Simulationen für verschiedene Anzahl von Bootstrap-Replikationen durchgeführt. Standardfehler werden in normalen Intervallen geschätzt.

Beachten Sie, dass die Auswahl von die Anzahl der Objekte, die gebootet werden, eine absolute Obergrenze für die Genauigkeit der Ergebnisse darstellt, da die Monte-Carlo-Prozedur schätzt und nur von abhängt . Wenn Sie unnötig groß einstellen, belastet dies nur Ihren Computer, entweder weil Sie nur eine "grobe" Annäherung an benötigen oder weil die Abweichung aufgrund des Monte-Carlo-Effekts überlastet wird. Diese Ergebnisse sind für und auf die dritte Dezimalstelle genau.p p n n e n = 10 3 p - 1 ≈ $n$$p$$p$$n$$n$$e$$n=10^3$$p^{-1}\approx e$

Diese Darstellung zeigt, dass die Wahl von direkte und tiefgreifende Konsequenzen für die Stabilität in . Die blaue gestrichelte Linie zeigt und die rote Linie zeigt . Wie erwartet, erzeugt die Probengröße zu erhöhen immer genauere Schätzungen . p p e $m$$\hat{p}$$p$$e$$\hat{p}$

Ich habe dafür ein peinlich langes R-Skript geschrieben. Verbesserungsvorschläge können auf der Rückseite einer 20-Dollar-Rechnung eingereicht werden.

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

Lösung 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$

Lösung 2:

$e$

Lösung 3:

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

$1/n!$$n$

Eine schnelle R-Implementierung der Forsythe-Methode besteht darin, die Reihenfolge der Uniformen zugunsten größerer Blöcke genau einzuhalten, was eine parallele Verarbeitung ermöglicht:

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)

Keine Lösung ... nur ein kurzer Kommentar, der für das Kommentarfeld zu lang ist.

Aksakal

Aksakal veröffentlichte eine Lösung, in der wir die erwartete Anzahl der zu erstellenden einheitlichen Standardzeichnungen so berechnen, dass ihre Summe 1 übersteigt. In Mathematica lautete meine erste Formulierung:

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

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

EDIT: Hatte gerade ein schnelles Spiel damit und der folgende Code (gleiche Methode - auch in Mma - nur anderer Code) ist ungefähr 10-mal schneller:

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

Xian / Whuber

Whuber hat schnellen coolen Code vorgeschlagen, um Xians Lösung 1 zu simulieren:

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

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

was er feststellt, ist 20 mal schneller als der erste Code (oder etwa doppelt so schnell wie der neue Code oben).

Nur zum Spaß dachte ich, es wäre interessant zu sehen, ob beide Ansätze (im statistischen Sinne) so effizient sind. Zu diesem Zweck habe ich 2000 Schätzungen für e erstellt, in denen Folgendes verwendet wurde:

• Aksakals Methode: dataA
• Xians Methode 1 unter Verwendung des Whuber-Codes: dataB

... beides in Mathematica . Das folgende Diagramm stellt eine nichtparametrische Schätzung der Kerneldichte der resultierenden Datensätze dataA und dataB gegenüber.

Obwohl Whubers Code (rote Kurve) etwa doppelt so schnell ist, scheint die Methode nicht so zuverlässig zu sein.

Methode, die eine gottlose Menge an Proben erfordert

$f(x) = e^x$$\frac{ \bar x \sqrt{12}}{ \sqrt{n}} \dot \sim N(0,1)$$e$$\infty$$\infty$

$N(0,1)$$e^{x}$

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

Wenn Sie total verrückt werden wollen, können Sie sogar schätzen$\sqrt{2}$$\sqrt{2\pi}$

Methode, die nur sehr wenige Stichproben erfordert, aber eine gottlose Menge an numerischen Fehlern verursacht

Eine völlig dumme, aber sehr effiziente Antwort, die auf einem Kommentar basiert, den ich abgegeben habe:

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

Dies wird sehr schnell konvergieren , aber auch auf extreme numerische Fehler stoßen.

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

Hier ist eine andere Möglichkeit, es zu tun, obwohl es ziemlich langsam ist. Ich mache keinen Anspruch auf Effizienz, biete diese Alternative aber im Sinne der Vollständigkeit an.

$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$

Implementierung in R: Die Methode kann implementiert werden, Rindem runifeinheitliche Werte generiert werden. Der Code lautet wie folgt:

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$