[Harlem] Es gibt zu viele zur Auswahl! 13 Möglichkeiten zur Berechnung des Umfangs π in Python
Hallo aus dem Abgrund des Universums!
\displaystyle\int {\rm d}\boldsymbol{r}\hat{\psi}^{\dagger}(\boldsymbol{r})Poppin Freunde\hat{\psi}(\boldsymbol{r})
ist! Dieses Mal möchte ich ** 13 Möglichkeiten ** vorstellen, wie das Umfangsverhältnis $ \ pi $ mit Python ** berechnet wird!
Zuvor habe ich einen Artikel gelesen (berühmt im Bereich des Umfangsverhältnisses) mit dem Titel "Mach dir keine Sorgen mehr um das Umfangsverhältnis! 10 Möglichkeiten, π zu finden". Der Wunsch, π zu suchen, hat zugenommen, deshalb habe ich beschlossen, diesen Artikel zu schreiben. Und dieses Mal habe ich fast alle Methoden zum Auffinden von $ \ pi $ im Artikel ** in Python implementiert!
Als ich es ausprobierte, war ** Grundkenntnisse in Python ** (Funktionen, Numpy, für Anweisungen, während Anweisungen, wenn Anweisungen, Klassen usw.) ** reichlich ** enthalten, also Programmierung (wie ich) Ich kann es Anfängern nur empfehlen, Python zu üben!
Die Umgebung ist wie folgt.
- PC: MacBook Pro (15 Zoll, 2018)
- CPU: 2,2 GHz 6 Core Intel Core i7
- Speicher: 16 GB 2400 MHz DDR4
- Python-Umgebung: Anaconda, Jupyter Notebook (6.0.1), Python 3.7.4
Dann genießen Sie bitte das Harlem **, das mit den Methoden zur Berechnung des Umfangsverhältnisses gewebt wurde!
Verwenden Sie die Grundfunktionen von Numpy
Python hat eine Bibliothek namens Numpy (mit der Anaconda von Anfang an geliefert wird) und einige sehr nützliche Funktionen für Vektor-, Matrix- und andere mathematische Berechnungen. Im Folgenden zeigen wir Ihnen, wie Sie das Umfangsverhältnis mit den Grundfunktionen von Numpy berechnen!
- numpy.pi Das erste ist, ** numpy.pi ** zu verwenden. In Numpy gibt es einen Mann, der den Wert des Umfangsverhältnisses mit dem Namen "numpy.pi" angibt, und dies ist am schnellsten zu verwenden. Ich berechne es nicht einmal mehr w
import numpy as np #Numpy importieren
pi = np.pi #Np zur Variablen pi.Ersatz pi
print(pi) #Ausgabe
Die Ausgabe sieht folgendermaßen aus:
3.141592653589793
2. Inverse Funktion von tan
Angenommen, Sie werden plötzlich von ** "einem Fluch getroffen, den nur numpy.pi nicht unter Numpys Funktionen verwenden kann" **.
Jetzt ist es schwer! Sie können das Umfangsverhältnis nicht mit der ersten Methode erhalten! Andere Funktionen von Numpy sind jedoch noch verfügbar. Lassen Sie uns also andere Möglichkeiten untersuchen. Übrigens gibt es eine legendäre Methode, die seit prähistorischen Zeiten weitergegeben wurde. Es ist eine Möglichkeit, die Umkehrfunktion von ** tan ** zu verwenden.
\tan\left(\frac{\pi}{4}\right)=1\Longleftrightarrow\arctan(1)=\frac{\pi}{4}\tag{1}
Wenn Sie das Sein ausnutzen
\pi = 4\arctan(1) \tag{2}
Kann gefragt werden. Machen wir das!
import numpy as np
pi = 4 * np.arctan(1) #Variable pi bis 4*tanh(1)Ersatz
print(pi) #Ausgabe
Die Ausgabe sieht folgendermaßen aus:
3.141592653589793
Ich habe genau das gleiche Ergebnis wie bei der ersten Methode! Diese Methode wurde übrigens aus der prähistorischen Zeit weitergegeben, als ** Fortran **, die erste "Sprache" der Menschheit, geboren wurde. Es ist die Weisheit unserer Vorgänger!
Aus der Gegend erhalten
** "Die Fläche eines Kreises mit einem Radius von $ r $ ist $ S = \ pi r ^ 2 $" ** Wie Sie alle wissen, ist es ein universeller gesunder Menschenverstand, der tief in die tiefe Psychologie der gesamten Menschheit eingraviert ist! Lassen Sie uns im Folgenden das Umfangsverhältnis anhand der Fläche dieses Kreises ermitteln, die jeder kennt!
3. Regelmäßige Polygonnäherung
Durch Erhöhen der Fläche des positiven $ n $ Quadrats, das in den Kreis eingeschrieben ist, kommt der Wert der Fläche des Kreises immer näher. Die Fläche eines positiven $ n $ Quadrats, das in einen Kreis mit einem Radius von $ r $ eingeschrieben ist, beträgt
S_n=n\times\frac{r^2}{2}\sin\left(\frac{360^\circ}{n}\right)\to\pi r^2\ (n\to\infty) \tag{3}
Wird benötigt bei. Implementieren wir es unter der Annahme, dass der Radius $ r = 1 $ ist!
import numpy as np
#Polygonale Approximation
def RegularPolygon(N):
theta = np.radians(360 / N) #Teilen Sie 360 ° in N gleiche Teile und konvertieren Sie von der Frequenzmethode zur Bogengradmethode
pi = N * np.sin(theta) / 2 #Berechnen Sie die Fläche einer regulären N-Seite
return pi
#Ausgabe
print("RegularPolygon(100) = " + str(RegularPolygon(100)))
print("RegularPolygon(1000) = " + str(RegularPolygon(1000)))
print("RegularPolygon(10000) = " + str(RegularPolygon(10000)))
print("RegularPolygon(100000) = " + str(RegularPolygon(100000)))
print("RegularPolygon(1000000) = " + str(RegularPolygon(1000000)))
Die im Code verwendete Funktion "np.radius ()" ist eine Funktion, die vom Wert des Umfangsverhältnisses abhängt, und es ist persönlich, die Funktion zu verwenden, die vom Umfangsverhältnis abhängt, um das Umfangsverhältnis zu ermitteln. Es ist unangenehm, aber ich konnte mir keinen anderen guten Weg vorstellen, also lasse ich es so wie es diesmal ist (bitte lassen Sie mich wissen, wenn Sie einen guten Weg kennen).
Das Ausgabeergebnis ist wie folgt. Es nähert sich allmählich dem Umfangsverhältnis!
RegularPolygon(100) = 3.1395259764656687
RegularPolygon(1000) = 3.141571982779475
RegularPolygon(10000) = 3.141592446881286
RegularPolygon(100000) = 3.141592651522708
RegularPolygon(1000000) = 3.1415926535691225
4. Numerische Integration (rechteckige Approximation)
Neben der polygonalen Approximation gibt es noch andere Möglichkeiten, die Fläche eines Kreises zu ermitteln. Verwenden wir dieses Mal die Idee der ** Integration ** (partitioniertes Produkt).
Betrachten Sie die Funktion $ y = f (x) $, die Gerade $ x = a, \ x = b \ (a <b) $ und die Fläche $ S $ des von der $ x $ -Achse eingeschlossenen Teils. $ x $ Achsenintervall $ [a, \ b] $ ist in $ n $ gleiche Teile unterteilt, und die gleichen Teile sind $ x_0, \ x_1, \ x_2, \ cdots, \ x_n \ (wobei \ x_0 = a, \ x_n = b) $. Das Intervall zwischen benachbarten Teilungspunkten sei außerdem $ \ Delta x = (b-a) / n $. Zu diesem Zeitpunkt ist der Bereich $ S_i $ des Teils des Intervalls $ [x_i, \ x_ {i + 1}] $ ** $ S_i = f (x_i) \ Delta x $ **, dh die Basis ist $ \ Delta x. Ungefähr ** als Rechteck mit $ und Höhe $ f (x_i) $. Suchen Sie danach $ S_i $ für alle Intervalle $ [x_i, \ x_ {i + 1}] \ (i = 0, \ 2, \ cdots, \ n-1) $ und addieren Sie sie, um eine Annäherung zu erhalten. Der Bereich $ S_n $ kann erhalten werden. Wenn Sie dann die Zahl $ n $ erhöhen, die das Intervall $ [a, \ b] $ in gleiche Teile teilt, nähert es sich schließlich dem wahren Bereich $ S $.
S_n = \sum_{i=0}^{n-1} f(x_i)\frac{b-a}{n}\to S\ (n\to\infty) \tag{4}
Wenden wir diese Methode auf die Fläche eines Kreises an. Die Gleichung für den Einheitskreis (Ursprungszentrum, Radius 1) in der $ x-y $ -Ebene lautet
x^2+y^2=1\Longleftrightarrow y=\pm\sqrt{1-x^2} \tag{5}
Das Plus repräsentiert jedoch die obere Hälfte und das Minus repräsentiert die untere Hälfte. Suchen Sie diesmal die Fläche des Teils (Viertelkreises) von $ x> = 0 $ in der oberen Hälfte. Das Intervall der zu berechnenden Fläche beträgt $ [a, \ b] = [0, \ 1] $.
S_n=\sum_{i=0}^{n-1} \frac{\sqrt{1-\left(\frac{i}{n}\right)^2}}{n}\to \frac{\pi}{4}\ (n\to\infty) \tag{6}
Es wird sein.
Lassen Sie es uns implementieren!
import numpy as np
#Eine Funktion der Rechtecknäherung. Sektion[0,1]Ist in N gleiche Teile geteilt.
def Rectangle(N):
x = np.arange(N) / N #0~(N-1)/N Elementarray bis N.
y = np.sqrt(1 - x**2) #y=root(1-x^2)Berechnung
pi = 4 * np.sum(y) / N #Fläche berechnen
return pi
#Ausgabe
print("Rectangle(100) = " + str(Rectangle(100)))
print("Rectangle(1000) = " + str(Rectangle(1000)))
print("Rectangle(10000) = " + str(Rectangle(10000)))
print("Rectangle(100000) = " + str(Rectangle(100000)))
print("Rectangle(1000000) = " + str(Rectangle(1000000)))
Das Ergebnis ist wie folgt
Rectangle(100) = 3.160417031779046
Rectangle(1000) = 3.1435554669110277
Rectangle(10000) = 3.141791477611322
Rectangle(100000) = 3.1416126164019866
Rectangle(1000000) = 3.141594652413813
Die Konvergenz ist langsamer als die polygonale Näherung, aber der Wert konvergiert gegen den Umfang, wenn die gleiche Division $ n $ zunimmt.
5. Numerische Integration (trapezförmige Approximation)
Die Genauigkeit ist erheblich höher als die rechteckige Näherung ** nur durch Hinzufügen ** einer Verdrehung zur vorherigen Teilungsberechnung. Früher wurde die Fläche des Minutenabschnitts durch ein Rechteck angenähert, aber es ist ** obere Basis $ f (x_i) $, untere Basis $ f (x_ {i + 1}) $, Höhe $ \ Delta x $ Ungefähr als Trapez **. Mit anderen Worten, verwenden Sie die folgende Formel.
S_n = \sum_{i=0}^{n-1} \frac{f(x_i)+f(x_{i+1})}{2}\cdot\frac{b-a}{n}\to S\ (n\to\infty) \tag{7}
Wie Sie in der folgenden Abbildung sehen können, weist die rechteckige Näherung oben viele zusätzliche oder fehlende Teile auf, die durch die Trapezform jedoch erheblich reduziert werden.
Lassen Sie es uns implementieren!
import numpy as np
#Trapeznäherung
def Trapezoid(N):
x = np.arange(N + 1) / N #0~N + 1 Elementarray bis zu 1
y = np.sqrt(1 - x**2) #y=root(1-x^2)Berechnung
z = (y[0:N] + y[1:N+1]) / 2 #Trapezförmig(Oberer Boden + unterer Boden)/Berechnen Sie 2
pi = 4 * np.sum(z) / N #Fläche berechnen
return pi
#Ausgabe
print("Trapezoid(100) = " + str(Trapezoid(100)))
print("Trapezoid(1000) = " + str(Trapezoid(1000)))
print("Trapezoid(10000) = " + str(Trapezoid(10000)))
print("Trapezoid(100000) = " + str(Trapezoid(100000)))
print("Trapezoid(1000000) = " + str(Trapezoid(1000000)))
Das Folgende ist das Ausführungsergebnis. Es ist der polygonalen Näherung etwas unterlegen, aber es ist ersichtlich, dass es schneller konvergiert als die rechteckige Näherung.
Trapezoid(100) = 3.1404170317790454
Trapezoid(1000) = 3.141555466911028
Trapezoid(10000) = 3.141591477611322
Trapezoid(100000) = 3.1415926164019865
Trapezoid(1000000) = 3.1415926524138094
Aus der Serie erhalten
Es gibt eine Möglichkeit, das Umfangsverhältnis mit einer unendlichen Reihe auszudrücken, die die Summe einer unendlichen Anzahl von Sequenzen ist. Verwenden wir es, um das Umfangsverhältnis zu finden! (Außerdem ist der Beweis für den Autor ziemlich mühsam oder unmöglich, deshalb werde ich ihn weglassen ...)
6. Basler Klasse
Es ist bekannt, dass das Umfangsverhältnis in den folgenden Klassen auftritt.
1+\frac{1}{2^2}+\frac{1}{3^2}+\dots+\frac{1}{n^2}+\dots=\sum_{n=1}^\infty\frac{1}{n^2}=\frac{\pi^2}{6} \tag{8}
Es ist eine Formel, die alle inversen Zahlen der Quadrate natürlicher Zahlen addiert, aber überraschenderweise enthält das Ergebnis das Umfangsverhältnis. Wenn ich Mathematik mache, ist es interessant, den Spaß an "Kommt $ \ pi $ da raus?" Zu genießen. Klicken Sie hier für Details zur Basler Serie
Wie bei der numerischen Integration ist es für einen Computer unmöglich, unendlich kontinuierliche Operationen auszuführen. Deshalb schneiden wir hier die Summe in der Mitte ab und finden einen ungefähren Wert. Lassen Sie es uns implementieren!
import numpy as np
#Basler Klasse. Berechnen Sie die Summe bis zum N-ten Term.
def Basel(N):
x = np.arange(1, N + 1) #1~Array natürlicher Zahlen bis zu N.
pi = np.sqrt(6 * np.sum(1 / x**2)) #Berechnen Sie die inverse Quadratsumme jedes Elements des Arrays und multiplizieren Sie sie mit 6 zu Quadrat.
return pi
#Ausgabe
print("Basel(100) = " + str(Basel(100)))
print("Basel(1000) = " + str(Basel(1000)))
print("Basel(10000) = " + str(Basel(10000)))
print("Basel(100000) = " + str(Basel(100000)))
print("Basel(1000000) = " + str(Basel(1000000)))
Unten sind die Ergebnisse. Sie können sehen, dass mit zunehmender Anzahl der zu summierenden Terme das Umfangsverhältnis konvergiert.
Basel(100) = 3.132076531809106
Basel(1000) = 3.1406380562059932
Basel(10000) = 3.14149716394721
Basel(100000) = 3.1415831043264415
Basel(1000000) = 3.1415916986604673
7. Leibniz-Klasse
Es gibt andere Klassen, in denen das Umfangsverhältnis herauskommt. Die folgende Leibniz-Klasse ist eine davon.
1-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+\dots+\frac{(-1)^{n-1}}{2n-1}+\dots=\sum_{n=1}^\infty\frac{(-1)^{n-1}}{2n-1}=\frac{\pi}{4} \tag{9}
Dieses Mal besteht die Berechnung darin, die inversen Zahlen von ungeraden Zahlen abwechselnd plus und minus zu addieren, aber das Umfangsverhältnis erscheint auch hier! Klicken Sie hier für Details zur Leibniz-Serie
Implementieren wir es genauso wie die Basler Reihe.
import numpy as np
#Leibniz-Klasse. Berechnen Sie die Summe bis zum N-ten Term.
def Leibniz(N):
x = np.arange(1, N + 1) #1~Array natürlicher Zahlen bis zu N.
y = 1 / (2 * x - 1) #Berechnen Sie ein Array von ungeraden Inversen
pm = (-1) ** (x - 1) #Berechnung einer Zahlenfolge, in der Pramai 1 abwechselnd angeordnet ist
pi = 4 * np.dot(y, pm) #Berechnen Sie die Summe der alternierenden Pramai mit dem inneren Produkt von y und pm und multiplizieren Sie sie am Ende mit 4.
return pi
#Ausgabe
print("Leibniz(100) = " + str(Leibniz(100)))
print("Leibniz(1000) = " + str(Leibniz(1000)))
print("Leibniz(10000) = " + str(Leibniz(10000)))
print("Leibniz(100000) = " + str(Leibniz(100000)))
print("Leibniz(1000000) = " + str(Leibniz(1000000)))
Das Folgende ist das Ausführungsergebnis. Es läuft reibungslos zusammen!
Leibniz(100) = 3.131592903558553
Leibniz(1000) = 3.140592653839795
Leibniz(10000) = 3.141492653590045
Leibniz(100000) = 3.141582653589825
Leibniz(1000000) = 3.141591653589752
8. Ramanujan-Klasse
Abschließend möchte ich die monsterähnliche Klasse ** "Ramanujan-Klasse" ** vorstellen. Das Folgende ist die Formel.
\begin{align}
\frac{1}{\pi} = \frac{2\sqrt{2}}{99^2}\sum_{n=0}^\infty\frac{(4n)!(1103+26390n)}{(396^{n}n!)^4} \tag{10}
\\
\frac{4}{\pi} = \sum_{n=0}^\infty\frac{(-1)^n(4n)!(1123+21460n)}{882^{2n+1}(4^n n!)^4} \tag{11}
\end{align}
Ich verstehe die Bedeutung nicht mehr. .. .. Ramanujan ist ein indischer Mathematiker, der eine Reihe unverständlicher Formeln wie die oben genannten hinterlassen hat. Auf die Frage "Wie bist du auf die Zeremonie gekommen?" Antwortete er: "Die Göttin wird dich in deinen Träumen lehren." Es ist pervers. Klicken Sie hier für Details zur Ramanujan-Klasse [Klicken Sie hier für Ramanujan](https://ja.wikipedia.org/wiki/%E3%82%B7%E3%83%A5%E3%83%AA%E3%83%8B%E3%83%B4% E3% 82% A1% E3% 83% BC% E3% 82% B5% E3% 83% BB% E3% 83% A9% E3% 83% 9E% E3% 83% 8C% E3% 82% B8% E3% 83% A3% E3% 83% B3)
Lassen Sie es uns implementieren! Dieses Mal werde ich Gleichung (11) in meiner Stimmung implementieren.
import numpy as np
#Ramanujan Klassennummer. Fassen Sie bis zum N-ten Term zusammen.
def Ramanujan(N):
sum = 0.0 #Der Wert der Summe. Anfangswert 0
for i in range(N): #i ist 0 bis N.-Mach weniger als 1
numerator = ((-1)**i) * np.math.factorial(4 * i) * (1123 + 21460 * i) #Berechnung des Moleküls von Punkt i
denominator = (882**(2 * i + 1)) * ((4**i) * np.math.factorial(i))**4 #Berechnung des Nenners von Absatz i
sum = sum + numerator / denominator #Addiere Term i zur Summe
pi = 4 / sum #Berechnung des Umfangsverhältnisses
return pi
#Ausgabe
print("Ramanujan(1) = " + str(Ramanujan(1)))
print("Ramanujan(2) = " + str(Ramanujan(2)))
print("Ramanujan(3) = " + str(Ramanujan(3)))
print("Ramanujan(4) = " + str(Ramanujan(4)))
print("Ramanujan(5) = " + str(Ramanujan(5)))
Da die Ramanujan-Klasse sehr schnell konvergiert und der in der Formel erscheinende Multiplikator ($ n! $) Eine schnelle Divergenz aufweist und bei Eingabe eines großen Werts überlaufen kann, ist der zu summierende Begriff die Basler Klasse oder Viel weniger als die Leibniz-Klasse.
Unten sind die Ergebnisse. Schon der erste Begriff entspricht der vierten Ziffer der Minderheit, und der dritte und die nachfolgenden Begriffe haben den gleichen Wert im Bereich der Anzahl der auf dem Personal Computer angezeigten Ziffern. Es ist überwältigend schnell!
Ramanujan(1) = 3.1415850400712375
Ramanujan(2) = 3.141592653597622
Ramanujan(3) = 3.1415926535897936
Ramanujan(4) = 3.1415926535897936
Ramanujan(5) = 3.1415926535897936
Verwenden Sie Zufallszahlen
Sie können $ \ pi $ auch anhand einer Zufallszahl finden. Zufallszahlen sind, wie der Name schon sagt, Zufallszahlen wie Würfelwürfe. Das Finden von $ \ pi $ mithilfe von Zufallszahlen erfordert jedoch eine große Anzahl von Stichproben ($ \ sim $ Millionen), und es ist zu langweilig für Menschen, eine Million Würfel zu werfen. Die mühsame Routinearbeit besteht darin, einen Computer einzuführen, um die Effizienz zu verbessern. Im Folgenden wird erläutert, wie Sie $ \ pi $ mithilfe von Zufallszahlen finden!
9. Monte-Carlo-Methode
Betrachten Sie ein $ 1 \ mal 1 $ Quadrat und einen Quadranten, der auf einem seiner Eckpunkte zentriert ist. Das Flächenverhältnis zwischen dem Quadrat und dem Quadranten beträgt $ 1: \ pi / 4 $. Punkte werden innerhalb dieses Quadrats völlig zufällig gemacht. Wenn die Anzahl der Punkte zunimmt, wird dies zu "Gesamtzahl der Punkte: Anzahl der im Quadranten $ \ simeq1: \ pi / 4 $ enthaltenen Punkte". Wenn beispielsweise $ n $ von $ N $ Punkten im Quadranten enthalten sind,
\frac{n}{N}\simeq\frac{\pi}{4} \tag{12}
Es wird sein. Verwenden Sie dies, um das Umfangsverhältnis zu ermitteln.
Lassen Sie es uns implementieren!
import numpy as np
#Monte-Carlo-Methode. N Proben entnehmen.
def MonteCarlo(N):
xy = np.random.rand(2, N) #Sektion[0,1)Gleichmäßige Verteilung von Zufallszahlen(2×N)Warteschlange. Jede Spalte entspricht den Koordinaten der Punkte in der Ebene.
r = np.sum(xy**2, axis = 0) #Berechnen Sie den Abstand vom Ursprung jedes Abtastpunkts. Quadrieren Sie jede Komponente und summieren Sie die Elemente in derselben Spalte.
r = r[r<=1] #Die Entfernung beträgt 1 oder weniger (=Nur Proben extrahieren (innerhalb des Quadranten)
n = r.size #Berechnen Sie die Anzahl der Punkte im Kreis#Berechnen Sie das Umfangsverhältnis
pi = 4 * n / N #Berechnen Sie das Umfangsverhältnis
return pi
np.random.seed(seed=0) #Zufällige Starteinstellung (dies führt jedes Mal zur gleichen Ausgabe)
#Ausgabe
print("MonteCarlo(100) = " + str(MonteCarlo(100)))
print("MonteCarlo(1000) = " + str(MonteCarlo(1000)))
print("MonteCarlo(10000) = " + str(MonteCarlo(10000)))
print("MonteCarlo(100000) = " + str(MonteCarlo(100000)))
print("MonteCarlo(1000000) = " + str(MonteCarlo(1000000)))
print("MonteCarlo(10000000) = " + str(MonteCarlo(10000000)))
Unten sind die Ergebnisse. Im Allgemeinen konvergiert der Fehler des Werts aufgrund der Zufallszahl in der Größenordnung von $ 1 / \ sqrt {N} $ für die Anzahl der Abtastwerte $ N $ (relativ langsam), so dass die Genauigkeit ziemlich gering ist.
MonteCarlo(100) = 3.24
MonteCarlo(1000) = 3.068
MonteCarlo(10000) = 3.1508
MonteCarlo(100000) = 3.13576
MonteCarlo(1000000) = 3.140048
MonteCarlo(10000000) = 3.1424264
10. Buffon Nadel
Lassen Sie viele Nadeln mit einer Länge von $ l $ auf viele parallele Linien fallen, die in Intervallen von $ t $ gezeichnet wurden. Sei $ n $ die Anzahl der $ N $ Nadeln, die die Linie schneiden. Wenn die Anzahl der Nadeln $ N $ groß genug ist
\frac{2lN}{tn}\sim\pi \tag{13}
Ist bekannt zu sein. Du bist wieder gekommen, es ist derjenige, der sagt: "Kommt $ \ pi $ hier raus!" W Es ist eine seltsam seltsame Sache, dass das Umfangsverhältnis in der Wahrscheinlichkeit erscheint, obwohl Sie einfach die Nadel auf die parallele Linie fallen lassen. geschehen. Klicken Sie hier für Details zu Buffons Nadel
Lassen Sie es uns implementieren! Der Abstand zwischen der Nadelmitte und der Linie ist bei $ 0 \ sim t / 2 $ gleichmäßig, und der Winkel zwischen der Nadel und der parallelen Linie ist bei $ 0 ^ \ circ \ sim 90 ^ \ circ $ gleichmäßig. Auch diesmal beträgt die Nadellänge $ l = 2 $ und der parallele Linienabstand $ t = 4 $.
Beim Abtasten des Nadelwinkels aus Zufallszahlen sind einige Dinge zu beachten. Es ist notwendig, die Gradmethode in die Bogengradmethode umzuwandeln, wenn der Winkel direkt abgetastet wird, aber der in diesem Fall verwendete np.radius () ist eine Funktion, die vom Wert des Umfangsverhältnisses abhängt. .. Sie können es für die Simulation verwenden, aber ich persönlich fühle mich unwohl, deshalb werde ich diesmal ein wenig darüber nachdenken. ** Abtasten Sie die Koordinaten der Punkte im Einheitsquadranten und ermitteln Sie den Wert von sin daraus **. Durch Beschränken des Bereichs von Abtastpunkten auf den Einheitsquadranten kann der Winkel zwischen dem Punkt und der $ x $ -Achse verringert werden.
Es hat eine gleichmäßige Verteilung von $ 0 ^ \ circ \ sim 90 ^ \ circ $.
import numpy as np
#Buffon Nadel. N Nadeln fallen lassen.
def Buffon(N):
n = 0; #Die Anzahl der Nadeln, die die Linie überlappen. Anfangswert 0.
for i in range(N): #i ist 0 bis N.-Wiederholen bis 1.
#Nadelwinkelabtastung. Beseitigen Sie die Wertabhängigkeit von pi, indem Sie Punkte innerhalb des Einheitskreises abtasten, anstatt den Winkel direkt abzutasten.
r = 2 #Der Abstand vom Ursprung des Abtastpunkts. Setzen Sie den Anfangswert auf 2, um die folgende while-Anweisung auszuführen.
while r > 1: #r<=Wiederholen Sie die Probe, bis sie 1 erreicht.
dx = np.random.rand() #x-Koordinate
dy = np.random.rand() #y-Koordinate
r = np.sqrt(dx ** 2 + dy ** 2) #Berechnung der Entfernung vom Ursprung
h = 2 * np.random.rand() + dy / r #Berechnung der Höhe (höher) der Büschelspitze
if h > 2: #Wenn die Höhe der Nadelspitze die Höhe der parallelen Linie erreicht hat
n += 1 #Fügen Sie die Anzahl der Nadeln hinzu, die die Linie überlappen
pi = N / n #Berechnung des Umfangsverhältnisses
return pi
np.random.seed(seed=0) #Zufällige Starteinstellung (dies führt jedes Mal zur gleichen Ausgabe)
#Ausgabe
print("Buffon(100) = " + str(Buffon(100)))
print("Buffon(1000) = " + str(Buffon(1000)))
print("Buffon(10000) = " + str(Buffon(10000)))
print("Buffon(100000) = " + str(Buffon(100000)))
print("Buffon(1000000) = " + str(Buffon(1000000)))
print("Buffon(10000000) = " + str(Buffon(10000000)))
Erzeugen Sie den Winkel von $ N $ Nadeln mit theta = np.radians (rand.rand (N) * 90). Da rand.rand () eine gleichmäßige Verteilung des Intervalls $ [0, 1) $ hat, ergibt das Multiplizieren mit 90 eine gleichmäßige Verteilung von $ [0, 90) $.
Berechnen Sie dann die $ y $ -Koordinaten der Nadelspitze mit y = 2 * rand.rand (N) + np.sin (Theta). 2 * rand.rand (N) wird verwendet, um die Koordinaten der Nadelmitte zu berechnen, und np.sin (Theta) wird verwendet, um den Höhenunterschied zwischen der Mitte und der Spitze der Nadel zu berechnen. Ob die Nadelspitze die parallele Linie schneidet oder nicht, wird durch [y> 2] bestimmt (wenn $ y> 2 $ schneidet, schneidet sie sich, andernfalls schneidet sie sich nicht). Berechnen Sie danach die Anzahl der Nadeln, die sich mit y.size schneiden, und wenn Sie es vermasseln, sind Sie fertig.
Das Folgende ist das Ausgabeergebnis. Das Ergebnis ist nicht stabil. .. .. (Schweiß)
Buffon(100) = 2.7777777777777777
Buffon(1000) = 2.881844380403458
Buffon(10000) = 3.1259768677711786
Buffon(100000) = 3.11284046692607
Buffon(1000000) = 3.1381705093564554
Buffon(10000000) = 3.1422055392056127
Verwenden Sie einen Algorithmus
Ein ** Algorithmus ** ist grob gesagt eine ** Zusammenfassung eines bestimmten Verfahrens **. Im Folgenden zeigen wir Ihnen, wie Sie das Umfangsverhältnis durch Wiederholen eines bestimmten Vorgangs ermitteln können!
11. Der Algorithmus von Gauss-Legendre
Der Gauß-Legendre-Algorithmus ist ein Verfahren zum Berechnen des Umfangsverhältnisses gemäß dem Verfahren des "Wiederholens der Terme einer Zahlenfolge gemäß der simultanen allmählichen Gleichung" wie folgt.
\begin{align}
&a_0=1,\quad b_0=\frac{1}{\sqrt{2}},\quad t_0=\frac{1}{4},\quad p_0=1\\
&a_{n+1}=\frac{a_n+b_n}{2}\\
&b_{n+1}=\sqrt{a_nb_n}\\
&t_{n+1}=t_n-p_n(a_n-a_{n+1})^2\\
&p_{n+1}=2p_n\\
\\
&\frac{a_n+b_n}{4t_n}\to\pi(n\to\infty)
\end{align}
\tag{14}
Es ist bekannt, dass dieser Algorithmus die Anzahl der Stellen, die mit dem genauen Wert im Verlauf der Berechnung übereinstimmen, ungefähr verdoppelt, wodurch es möglich wird, das Umfangsverhältnis einfach und mit hoher Genauigkeit zu erhalten. Gauss und Legendre, die diesen Algorithmus unabhängig voneinander entwickelt haben, sind beide Superstars in der Welt der Mathematik und Physik. Klicken Sie hier für Details zum Gauss-Legendre-Algorithmus [Klicken Sie hier für Details zu Gauß](https://ja.wikipedia.org/wiki/%E3%82%AB%E3%83%BC%E3%83%AB%E3%83%BB%E3%83%95 % E3% 83% AA% E3% 83% BC% E3% 83% 89% E3% 83% AA% E3% 83% 92% E3% 83% BB% E3% 82% AC% E3% 82% A6% E3 % 82% B9) [Klicken Sie hier für Details zu Legendre](https://ja.wikipedia.org/wiki/%E3%82%A2%E3%83%89%E3%83%AA%E3%82%A2%E3%83%B3 % EF% BC% 9D% E3% 83% 9E% E3% 83% AA% E3% 83% BB% E3% 83% AB% E3% 82% B8% E3% 83% A3% E3% 83% B3% E3 % 83% 89% E3% 83% AB)
Lassen Sie es uns implementieren!
import numpy as np
#Gauß=Legendres Algorithmus. N-mal wiederholen
def GaussRegendre(N):
#Erste Amtszeit
a = 1.0
b = np.sqrt(2) / 2
t = 1 / 4
p = 1
for i in range(N): #i ist 0 bis N.-Wiederholen Sie Folgendes bis 1
#Berechnen Sie die folgenden Terme nach der Graduierungsformel
a_new = (a + b) / 2
b_new = np.sqrt(a * b)
t_new = t - p * (a - a_new)**2
p_new = 2 * p
#Ersetzen Sie den alten Wert durch einen neuen Wert
a = a_new
b = b_new
t = t_new
p = p_new
pi = (a + b)**2 / (4 * t) #Berechnung des Umfangsverhältnisses
return pi
#Ausgabe
print("GaussRegendre(1) = " + str(GaussRegendre(1)))
print("GaussRegendre(2) = " + str(GaussRegendre(2)))
print("GaussRegendre(3) = " + str(GaussRegendre(3)))
Unten sind die Ergebnisse. Das erste Mal ist bis zur zweiten Ziffer des Bruchs, das zweite Mal bis zur siebten Ziffer des Bruchs und das dritte Mal bis zur letzten angezeigten Ziffer. Konvergenz ist ziemlich schnell!
GaussRegendre(1) = 3.1405792505221686
GaussRegendre(2) = 3.141592646213543
GaussRegendre(3) = 3.141592653589794
Verwenden Sie Physik
Das Umfangsverhältnis ist nicht nur in der Welt der Mathematik, sondern auch in der Natur verborgen. Im Folgenden zeige ich Ihnen, wie Sie das Umfangsverhältnis mithilfe der Physik berechnen!
12. Einfacher Vibrationszyklus
In der Physik wurden ** Vibration ** und andere Bewegungen aktiv untersucht, aber einfache Vibration ist die Grundlage aller periodischen Bewegungen. Einfache Vibration ist die Bewegung, wenn die Position $ x $ der folgenden Gleichung folgt.
\frac{d^2x}{dt^2}=-\omega^2x \tag{15}
Eine Gleichung, die die Differenzierung einer Funktion enthält, wie z. B. Gleichung (15), wird als ** Differentialgleichung ** bezeichnet. Viele Differentialgleichungen in der Welt können nicht genau gelöst werden, aber Gleichung (15) kann genau gelöst werden, und die Lösung lautet wie folgt.
x=A\sin(\omega t + \phi) \tag{16}
Sie können sehen, dass $ x $ über die Zeit schwingt, weil die Position $ x $ durch $ \ sin $ als Funktion der Zeit $ t $ dargestellt wird. $ A $ ist die Amplitude der Schwingung und $ \ phi $ ist eine Konstante, die als Anfangsphase bezeichnet wird und sich auf die Position des Objekts bei $ t = 0 $ bezieht. Und der Zyklus dieser Schwingung ist
T=\frac{2\pi}{\omega} \tag{17}
Es wird sein. Wenn $ \ omega = 1 $ ist, ist der halbe Schwingungszyklus das Umfangsverhältnis.
Dieses Mal berechnen wir die Schwingungsdauer, indem wir die Differentialgleichung numerisch simulieren. Die ** Runge ≡ Kutta-Methode ** wird verwendet, um die Differentialgleichung zu simulieren. Da die ausführliche Erklärung der Runge ≡ Kutta-Methode lang ist, werde ich sie hier weglassen, aber kurz: "Finden Sie den Positions- und Geschwindigkeitswert in der Zukunft aus dem Positions- und Geschwindigkeitswert zu einem bestimmten Zeitpunkt nach einem bestimmten Verfahren. Es ist eine Möglichkeit, das zu wiederholen.
\begin{align}
&Zeitintervall:h,\Quad-Differentialgleichung:\frac{dx}{dt}=f(x, t)\\
&{k}_1=h\times {f}(x_i, t)\\
&{k}_2=h\times {f}(x_i+\frac{k_1}{2}, t+\frac{h}{2})\\
&{k}_3=h\times {f}(x_i+\frac{k_2}{2}, t+\frac{h}{2})\\
&{k}_4=h\times {f}(x_i+k_3, t+h)\\
\\
&{k}=\frac{{k}_1+2{k}_2+2{k}_3+{k}_4}{6}\\
&x_{i+1}=x_i+{k}
\end{align}
\tag{18}
Klicken Sie hier für eine detaillierte Erklärung der Runge-Kutta-Methode
Ich habe auch einen anderen Artikel mit der Runge-Kutta-Methode geschrieben. Bitte lesen Sie ihn, wenn Sie möchten! Simulation des Chaos in der Einheit mit der Rungekutta-Methode
Lassen Sie es uns implementieren! Die Runge-Kutta-Methode von Gleichung (18) wird standardmäßig für die Differentialgleichung erster Ordnung verwendet, aber da die Differentialgleichung von Gleichung (15) die Differentialgleichung zweiter Ordnung ist, wird sie wie folgt in zwei Differentialgleichungen erster Ordnung unterteilt. Ich werde am Ende.
\begin{align}
&\frac{dx}{dt}=v\\
&\frac{dv}{dt}=-\omega^2x
\end{align}
\tag{19}
Die Anfangsposition und die Anfangsgeschwindigkeit sind $ (x_0, v_0) = (1,0) $. Dann beginnt die Bewegung des Objekts am höchsten Schwingungspunkt. Danach nimmt die Position für eine Weile ab, erreicht kurz nach einem halben Zyklus den niedrigsten Vibrationspunkt und steigt dann an. Dann kann durch Vorrücken der Zeit nur während die Position des Objekts abnimmt und angehalten wird, wenn die Position zunimmt, eine Halbzykluszeit (≈ Umfangsverhältnis) erhalten werden.
import numpy as np
#Differentialgleichung. r:Vektor, der Position und Geschwindigkeit zusammenfasst
def f(r):
x = r[0] #Nehmen Sie den Wert der Position heraus
v = r[1] #Nehmen Sie den Geschwindigkeitswert heraus
#Berechnen Sie die rechte Seite der Differentialgleichung
xdot = v
vdot = -x
return np.array([xdot, vdot])
#Runge=Kutta-Methode
def RungeKutta(r, h):
k1 = h * f(r)
k2 = h * f(r + k1 / 2)
k3 = h * f(r + k2 / 2)
k4 = h * f(r + k3)
k = (k1 + 2 * k2 + 2 * k3 + k4) / 6
return r + k
#Einfache Vibration. Zeitintervall h=10^(-N)Führen Sie die Runge-Kutta-Methode durch.
def Vibration(N):
h = 10**(-N) #Berechnung von h
t = 0 #Anfangswert der Ganzzahl entsprechend der Zeit
isDecrease = True #Kennzeichen, ob die Position abnimmt
r = np.array([1.0, 0.0]) #Anfangswert von Position / Geschwindigkeit
x_old = r[0] #Anfangswertersetzung an der alten Position. Wird verwendet, um die Zunahme / Abnahme der Position zu beurteilen.
while isDecrease == True and t * h < 4.0: #Wiederholen Sie den Vorgang, während die Position abnimmt und die Zeit 4 oder weniger beträgt
#※t*h<4.Das Auferlegen von 0 verhindert, dass Sie in eine Endlosschleife eintreten
r = RungeKutta(r, h) #Runge=Aktualisieren Sie Position und Geschwindigkeit mit der Kutta-Methode
x_new = r[0] #Neuer Positionswert
if x_old > x_new: #Die alte Position ist größer als die neue Position (=Wenn die Position abnimmt)
x_old = x_new #Ersetzen Sie den alten Positionswert
t += 1 #Stellen Sie die Zeit vor
else : #Andernfalls
isDecrease = False #Setzen Sie das Flag, das abnimmt, auf False → Die Schleife endet
pi = t / 10 ** N
return pi #Halbzyklus(≒π)Gib es zurück
#Ausgabe
print("Vibration(1) = " + str(Vibration(1)))
print("Vibration(2) = " + str(Vibration(2)))
print("Vibration(3) = " + str(Vibration(3)))
print("Vibration(4) = " + str(Vibration(4)))
print("Vibration(5) = " + str(Vibration(5)))
Unten sind die Ergebnisse. Sie können sehen, dass die Genauigkeit umso höher ist, je kleiner die Breite von $ h $ ist. Es wird jedoch einige Zeit dauern, da sich die Anzahl der erforderlichen Schleifen entsprechend erhöht.
Vibration(1) = 3.1
Vibration(2) = 3.14
Vibration(3) = 3.142
Vibration(4) = 3.1416
Vibration(5) = 3.14159
13. Anzahl der Kollisionen zwischen zwei Kugeln
Als dreizehnte, dh letzte Methode, werde ich die Schlagmethode zum Ermitteln des Umfangsverhältnisses einführen. Es wird gesagt, dass ** die Anzahl der Kollisionen zwischen zwei Kugeln und einer Wand das Umfangsverhältnis ** ist. Ich weiß nicht, wovon du sprichst, also werde ich ein Video und das Originalpapier veröffentlichen.
Video: 
Originalarbeit: POOL MIT π SPIELEN (DIE NUMMER π AUS EINER BILLARD-ANSICHT)
Bereiten Sie zwei Bälle mit einem Massenverhältnis von $ 1: 100 ^ N $ vor und schlagen Sie den Lichtball mit einer Geschwindigkeit von 1 gegen den Lichtball, während Sie den Lichtball stationär halten. Bereiten Sie nach der Kollision eine Wand vor dem Lichtball vor, damit dieser mit einem Abstoßungskoeffizienten von 1 abprallt. Nach wiederholten Kollisionen bewegt sich der schwere Ball in die entgegengesetzte Richtung der Wand, und der leichte Ball kollidiert nicht, wenn er den schweren Ball nicht einholen kann. Wenn Sie zählen, wie oft ein leichter Ball bisher mit einem schweren Ball und einer Wand kollidiert ist, entspricht dies der Anzahl der $ N $ -Ziffern des Umfangsverhältnisses.
Lassen Sie es uns implementieren! Berechnen Sie zunächst die Geschwindigkeitsänderung aufgrund einer Kollision im Voraus. Die Berechnungsmethode ist eine Kombination aus dem ** Gesetz zur Erhaltung der Ausübung ** und der ** Formel zur Definition des Abstoßungskoeffizienten **, die in der Physik der High School bekannt sind. Die Geschwindigkeiten der leichten und schweren Kugeln vor der Kollision seien $ v bzw. V $, und die Geschwindigkeiten nach der Kollision seien $ v'bzw. V '$. Das Massenverhältnis von leichten und schweren Kugeln sei $ 1: r $. Zu diesem Zeitpunkt gelten die folgenden zwei Gleichungen vor und nach der Kollision.
\begin{align}
&v+rV=v'+rV'\\
&e=-\frac{v'-V'}{v-V}
\end{align}
\tag{20}
Dieses Mal sind alle Kollisionen elastische Kollisionen, also $ e = 1 $. Lösen simultaner Gleichungen für $ v ', V' $
v'=\frac{(1-r)v+2rV}{1+r},\quad V'=\frac{2v+(r-1)V}{1+r} \tag{21}
Es wird sein. Lassen Sie es uns auf dieser Grundlage implementieren!
#Zwei-Ball-Kollision. Finden Sie bis zur N-ten Ziffer.
def BallCollision(N):
v = 0.0 #Anfangsgeschwindigkeit der Lichtkugel
V = -1.0 #Anfangsgeschwindigkeit des schweren Balls
r = 100 ** N #Massenverhältnis
count = 0 #Anfangswert der Anzahl der Kollisionen
while v > V: #Wiederholen Sie den folgenden Vorgang, während die Geschwindigkeit des leichten Balls größer ist als die Geschwindigkeit des schweren Balls
v_new = ((1 - r) * v + 2 * r * V) / (r + 1) #Leichte Ballgeschwindigkeit nach Kollision
V_new = (2 * v + (r - 1) * V) / (r + 1) #Schwere Ballgeschwindigkeit nach Kollision
count += 1 #Anzahl der Kollisionen hinzugefügt
if(v_new < 0.0): #Wenn die Geschwindigkeit des Lichtballs negativ ist
v_new = -v_new #Geschwindigkeitsumkehr aufgrund einer Kollision mit der Wand
count += 1 #Anzahl der Kollisionen hinzugefügt
v = v_new #Ersetzen der Geschwindigkeit einer leichten Kugel
V = V_new #Ersetzen der Geschwindigkeit eines schweren Balls
pi = count / (10 ** N) #Berechnung des Umfangsverhältnisses
return pi
#Ausgabe
for i in range(8):
print("BallCollision(" + str(i) + ") = " + str(BallCollision(i)))
Das Folgende ist das Ausführungsergebnis. Sie wollen wirklich das Umfangsverhältnis zur n-ten Ziffer! Der Rechenaufwand erhöht sich jedoch um das 100-fache, um die Genauigkeit um eine Ziffer zu erhöhen. Dies scheint daher unpraktisch zu sein.
BallCollision(0) = 3.0
BallCollision(1) = 3.1
BallCollision(2) = 3.14
BallCollision(3) = 3.141
BallCollision(4) = 3.1415
BallCollision(5) = 3.14159
BallCollision(6) = 3.141592
BallCollision(7) = 3.1415926
Ich habe versucht, alles in der Klasse zusammenzustellen
Schließlich habe ich eine Klasse aller Techniken zusammengestellt, die ich bisher implementiert habe! Wenn Sie alle auf diese Weise sammeln, ist es ein ziemliches Volumen. .. .. !!
#Klasse Pi_Beschreibung von Harem
#Harlem-Klasse auf 13 Arten gewebt, um das Umfangsverhältnis zu ermitteln.
#Finden Sie das Umfangsverhältnis nach Ihren Wünschen!
#* Importiere numpy, da np benötigt wird, um es zu verwenden.
#
#Bedienungsanleitung:
#Alle Funktionen haben einen Rückgabewert.
# 1. pi() :
# np.Gibt den Wert von pi zurück. Keine Argumente.
#
# 2. Arctan() :
# 4*np.arctan(1)Gibt den Wert von zurück. Keine Argumente.
#
# 3. RegularPokygon(N) :
#Ermitteln Sie das Umfangsverhältnis aus dem Bereich des regulären Polygons und geben Sie den Wert zurück. Argument N = Anzahl der Eckpunkte des regulären Polygons.
#
# 4. Rectangle(N) :
#Ermitteln Sie das Umfangsverhältnis aus der numerischen Integration (rechteckige Näherung) und geben Sie den Wert zurück. Argument N = gleiche Aufteilung des Integrationsintervalls.
#
# 5. Trapezoid(N) :
#Ermitteln Sie das Umfangsverhältnis aus der numerischen Integration (Trapoid-Approximation) und geben Sie den Wert zurück. Argument N = gleiche Aufteilung des Integrationsintervalls.
#
# 6. Basel(N) :
#Berechnen Sie das Umfangsverhältnis aus der Basler Klasse und geben Sie den Wert zurück. Argument N = Anzahl der Begriffe, die die Summe annehmen.
#
# 7. Leibniz(N) :
#Suchen Sie das Umfangsverhältnis aus der Leibniz-Klasse und geben Sie den Wert zurück. Argument N = Anzahl der Begriffe, die die Summe annehmen.
#
# 8. Ramanujan(N) :
#Berechnen Sie das Umfangsverhältnis aus der Ramanujan-Klasse und geben Sie den Wert zurück. Argument N = Anzahl der Begriffe, die die Summe annehmen.
#
# 9. MonteCarlo(N) :
#Ermitteln Sie das Umfangsverhältnis aus dem Monte-Carlo-Produkt des Quadranten und geben Sie den Wert zurück. Argument N = Anzahl der Proben.
#
# 10. Buffon(N) :
#Ermitteln Sie das Umfangsverhältnis aus der Simulation von Buffons Nadel und geben Sie den Wert zurück. Argument N = Anzahl der Proben.
#
# 11. GaussRegendre(N) :
#Gauß=Ermitteln Sie das Umfangsverhältnis anhand des Legendre-Algorithmus und geben Sie den Wert zurück. Argument N = Anzahl der Iterationen des Algorithmus.
#
# 12. Vibration(N) :
#Ermitteln Sie das Umfangsverhältnis aus der Simulation einfacher Schwingungen und geben Sie den Wert zurück. Argument N = Eine Variable, die die Zeitschrittbreite h bestimmt. h=10^(-N)
#
# 13. BallCollision(N) :
#Das Umfangsverhältnis ergibt sich aus der Simulation der Kollision zweier Kugeln, und der Wert wird zurückgegeben. Argument N = Anzahl der Stellen, die Sie suchen möchten.
import numpy as np
#Klassendefinition
class Pi_Harem():
#Grundfunktionen von Numpy
# 1.Genauer Wert von π(numpy.Verwenden Sie pi)
def pi(self):
return np.pi
# 2.Inverse Funktion von tan
def Arctan(self):
return 4 * np.arctan(1)
#Bereich
# 3.Polygonale Approximation
def RegularPolygon(self, N):
theta = np.radians(360 / N)
pi = N * np.sin(theta) / 2
return pi
# 4.Rechtecknäherung
def Rectangle(self, N):
x = np.arange(N) / N
y = np.sqrt(1 - x**2)
pi = 4 * np.sum(y) / N
return pi
# 5.Trapeznäherung
def Trapezoid(self, N):
x = np.arange(N + 1) / N
y = np.sqrt(1 - x**2)
z = (y[0:N] + y[1:N+1]) / 2
pi = 4 * np.sum(z) / N
return pi
#Serie
# 6.Basler Klasse
def Basel(self, N):
x = np.arange(1, N + 1)
pi = np.sqrt(6 * np.sum(1 / x**2))
return pi
# 7.Leibniz-Klasse
def Leibniz(self, N):
x = np.arange(1, N + 1)
y = 2 * x - 1
pi = 4 * np.dot(1 / y, (-1)**(x - 1))
return pi
# 8.Ramanujan Klasse
def Ramanujan(self, N):
sum = 0.0
for i in range(N):
numerator = ((-1)**i) * np.math.factorial(4 * i) * (1123 + 21460 * i)
denominator = (882**(2 * i + 1)) * ((4**i) * np.math.factorial(i))**4
sum = sum + np.sum(numerator / denominator)
pi = 4 / sum
return pi
#Zufallszahl
# 9.Monte-Carlo-Methode
def MonteCarlo(self, N):
xy = np.random.rand(2, N)
r = np.sum(xy**2, axis = 0)
r = r[r<=1]
n = r.size
pi = 4 * n / N
return pi
# 10.Buffon Nadel
def Buffon(self, N):
n = 0;
for i in range(N):
r = 2
while r > 1:
dx = np.random.rand()
dy = np.random.rand()
r = np.sqrt(dx ** 2 + dy ** 2)
h = 2 * np.random.rand() + dy / r
if h > 2:
n += 1
pi = N / n
return pi
#Algorithmus
# 11.Gauß=Legendres Algorithmus
def GaussRegendre(self, N):
a = 1.0
b = np.sqrt(2) / 2
t = 1 / 4
p = 1
for i in range(N):
a_new = (a + b) / 2
b_new = np.sqrt(a * b)
t_new = t - p * (a - a_new)**2
p_new = 2 * p
a = a_new
b = b_new
t = t_new
p = p_new
pi = (a + b)**2 / (4 * t)
return(pi)
#Physik
# 12.Einfache Vibration
#Differentialgleichung(Private Funktion)
def __f(self, r):
x = r[0]
v = r[1]
xdot = v
vdot = -x
return np.array([xdot, vdot])
#Rungekutta-Methode(Private Funktion)
def __RungeKutta(self, r, h):
k1 = h * self.__f(r)
k2 = h * self.__f(r + k1 / 2)
k3 = h * self.__f(r + k2 / 2)
k4 = h * self.__f(r + k3)
k = (k1 + 2 * k2 + 2 * k3 + k4) / 6
return r + k
#Zyklusberechnung
def Vibration(self, N):
h = 10 ** (-N)
t = 0
isDecrease = True
r = np.array([1.0, 0.0])
x_old = r[0]
while isDecrease == True and t * h < 4.0:
r = RungeKutta(r, h)
x_new = r[0]
if x_old > x_new:
x_old = x_new
t += 1
else :
isDecrease = False
pi = t / 10 ** (N)
return pi
# 13.Zwei-Ball-Kollision
def BallCollision(self, N):
v = 0.0
V = -1.0
r = 100 ** N
count = 0
while v > V:
v_new = ((1 - r) * v + 2 * r * V) / (r + 1)
V_new = (2 * v + (r - 1) * V) / (r + 1)
count += 1
if(v_new < 0.0):
v_new = -v_new
count += 1
v = v_new
V = V_new
pi = count / (10 ** N)
return pi
#das ist alles
Bei Jupyter-Notebooks können Sie den obigen Code in einer Zelle und dann den folgenden Code in einer anderen Zelle ausführen (wenn Sie die Funktion Basel () in der Klasse verwenden).
pi_harem = Pi_Harem() #Pi_Harem()Die Variable pi_Harem zuweisen (nur einmal ausführen)
pi = pi_harem.Basel(1000) #Die Funktion Barsel in der Klasse zur Variablen pi(1000)Ersetzen Sie den Wert von
print(pi) #Ausgabe
Zusammenfassung
Wie war es? Dieses Mal habe ich mich mit 13 Möglichkeiten zur Berechnung des Umfangsverhältnisses in Python befasst. Es war viel Volumen und es dauerte viel Zeit zu schreiben (Schweiß)
Es gab viele königliche, nicht triviale und skurrile Methoden! Ich wurde nie müde, alle Methoden zu sehen, und es war für mich persönlich schwierig. .. ..
Ich werde weiterhin Artikel veröffentlichen, die sich auf Physik und Programmierung konzentrieren. ** Wenn Sie ein Thema haben, das wir behandeln sollen, hinterlassen Sie es bitte in den Kommentaren! ** ** **
Recommended Posts