Pi: Unterschied zwischen den Versionen
Sn (Diskussion | Beiträge) (Graph ist noch fehlerhaft D:) |
Sn (Diskussion | Beiträge) |
||
(2 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) | |||
Zeile 3: | Zeile 3: | ||
== Algorithmische Berechnung == | == Algorithmische Berechnung == | ||
[[Datei:Pi gitterpunkte2.svg|mini|Viertelkreis, mit Flächenraster 10×10 angenähert, innerhalb 79 Punkte (rot), außerhalb 21 Punkte (blau)]] | [[Datei:Pi gitterpunkte2.svg|mini|Viertelkreis, mit Flächenraster 10×10 angenähert, innerhalb 79 Punkte (rot), außerhalb 21 Punkte (blau)]] | ||
<math>\pi</math> lässt sich algorithmisch wie folgt berechnen: Man nimmt ein Quadrat der Seitenlänge 1 und zeichnet dort hinein einen Viertelkreis mit dem Radius 1. Dieser Viertelkreis hat die Fläche <math>\frac{\pi}{4}</math>. Über dieses Quadrat legt man nun ein Raster aus Punkten und prüft für jeden dieser Punkte, ob er in dem Viertelkreis liegt oder nicht. Die Anzahl der Punkte im Viertelkreis geteilt durch die Gesamtzahl der Punkte im Quadrat ergibt dann eine Näherung für <math>\frac{\pi}{4}</math>. Je engmaschiger dabei das Gitter ist, desto genauer wird auch die Näherung für <math>\pi</math>. | <math>\pi</math> lässt sich [[Algorithmus|algorithmisch]] wie folgt berechnen: Man nimmt ein Quadrat der Seitenlänge 1 und zeichnet dort hinein einen Viertelkreis mit dem Radius 1. Dieser Viertelkreis hat die Fläche <math>\frac{\pi}{4}</math>. Über dieses Quadrat legt man nun ein Raster aus Punkten und prüft für jeden dieser Punkte, ob er in dem Viertelkreis liegt oder nicht. Die Anzahl der Punkte im Viertelkreis geteilt durch die Gesamtzahl der Punkte im Quadrat ergibt dann eine Näherung für <math>\frac{\pi}{4}</math>. Je engmaschiger dabei das Gitter ist, desto genauer wird auch die Näherung für <math>\pi</math>. | ||
{{Beispiel|Das rechts abgebildete Quadrat ist von einem Raster von 10×10 Punkten überzogen. Davon liegen 79 im Kreis (rot eingezeichnet). Als Näherung für <math>\frac{\pi}{4}</math> ergibt sich der Wert <math>\frac{79}{100} = 0,79</math>, multipliziert mit 4 die Näherung <math>3,16</math> für <math>\pi</math>.}} | {{Beispiel|Das rechts abgebildete Quadrat ist von einem Raster von 10×10 Punkten überzogen. Davon liegen 79 im Kreis (rot eingezeichnet). Als Näherung für <math>\frac{\pi}{4}</math> ergibt sich der Wert <math>\frac{79}{100} = 0,79</math>, multipliziert mit 4 die Näherung <math>3,16</math> für <math>\pi</math>.}} | ||
Als [[Programmablaufplan]] kann man diesen Algorithmus folgendermaßen darstellen: | Als [[Programmablaufplan]] kann man diesen Algorithmus folgendermaßen darstellen: | ||
{{#tag:mermaid| | {{#tag:mermaid| | ||
graph TD | graph TD | ||
start(("Start")) --> s1["Setze <code>x</code> auf 0"] --> s2["Setze <code>points_total</code> auf 0"] --> s3["Setze <code>points_circle</code> auf 0"] --> s4["Setze <code>STEP</code> auf 0.001"] --> wx{"<code>x</code> < 1?"} --ja--> s5["Setze <code>y</code> auf 0"] --> wy{"<code>y</code> < 1?"} --ja--> if{"<code>x</code>² + <code>y</code>² ≤ 1?"} --ja--> s6["Erhöhe <code>points_circle</code> um 1"] --> s7["Erhöhe <code>points_total</code> um 1"] --> s8 ["Erhöhe <code>y</code> um <code>STEP</code>"] --> wy | start(("Start")) --> s1["Setze <code>x</code> auf 0"] --> s2["Setze <code>points_total</code> auf 0"] --> s3["Setze <code>points_circle</code> auf 0"] --> s4["Setze <code>STEP</code> auf 0.001"] --> wx{"<code>x</code> < 1?"} --ja--> s5["Setze <code>y</code> auf 0"] --> wy{"<code>y</code> < 1?"} --ja--> if{"<code>x</code>² + <code>y</code>² ≤ 1?"} --ja--> s6["Erhöhe <code>points_circle</code> um 1"] --> s7["Erhöhe <code>points_total</code> um 1"] --> s8["Erhöhe <code>y</code> um <code>STEP</code>"] --> wy | ||
wy --nein--> wx | wy --nein--> s10["Erhöhe <code>x</code> um <code>STEP</code>"] --> wx | ||
if --nein--> s7 | if --nein--> s7 | ||
wx --nein--> s9["Setze <code>pi</code> auf <code>points_circle</code> / <code>points_total</code> * 4"] --> out[/"Gib <code>pi</code> aus"/] --> | wx --nein--> s9["Setze <code>pi</code> auf <code>points_circle</code> / <code>points_total</code> * 4"] --> out[/"Gib <code>pi</code> aus"/] --> ende(("Ende")) | ||
}} | }} | ||
Die [[Konstante]] <code>STEP</code> gibt dabei an, wie engmaschig das Gitter sein soll, und kann beliebig angepasst werden. Der Wert für <code>STEP</code> muss dabei zwischen 0 und 1 liegen. | |||
=== Laufzeit dieses Algorithmus === | |||
Die [[Laufzeit]] dieses Algorithmus hängt davon ab, wie viele Punkte betrachtet werden müssen. Bei einem Gitter von <math>n \times n</math> Punkten beträgt die Laufzeit darum {{O|n^2}}. | |||
== Berechnung mit Monte-Carlo-Algorithmus == | |||
[[Datei:Pi monte carlo all.svg|thumb|Viertelkreis, dessen Fläche durch die Monte-Carlo-Methode angenähert wird]] | |||
Alternativ kann man auch einen [[Monte-Carlo-Algorithmus]], d.h. einen Algorithmus mit einem zufallsbasierten Anteil, verwenden, um <math>\pi</math> zu berechnen. Hier wird das Quadrat nicht mit einem systematischen Gitter, sondern einem zufälligen Hagel aus Punkten überzogen. | |||
Als [[Programmablaufplan]] kann man diesen Algorithmus folgendermaßen darstellen: | |||
{{#tag:mermaid| | |||
graph TD | |||
start(("Start")) --> s1["Setze <code>ZIEL</code> auf 10000"] --> s2["Setze <code>points_total</code> auf 0"] --> s3["Setze <code>points_circle</code> auf 0"] --> w{"<code>points_total</code> < <code>ZIEL</code>?"} --ja--> s4["Setze <code>x</code> auf eine Zufallszahl zwischen 0 und 1"] --> s5["Setze <code>y</code> auf eine Zufallszahl zwischen 0 und 1"] --> if{"<code>x</code>² + <code>y</code>² ≤ 1?"} --ja--> s6["Erhöhe <code>points_circle</code> um 1"] --> s7["Erhöhe <code>points_total</code> um 1"] --> w | |||
if --nein--> s7 | |||
w --nein--> s9["Setze <code>pi</code> auf <code>points_circle</code> / <code>points_total</code> * 4"] --> out[/"Gib <code>pi</code> aus"/] --> ende(("Ende")) | |||
}} | |||
Die Konstante <code>ZIEL</code> gibt dabei an, wie viele zufällige Punkte in dem Quadrat verteilt werden sollen und kann beliebig angepasst werden. Je mehr Punkte gestreut werden, desto länger benötigt der Algorithmus, desto genauer ist aber auch das Ergebnis. | |||
=== Laufzeit dieses Algorithmus === | |||
Die [[Laufzeit]] dieses Algorithmus hängt davon ab, wie viele Punkte betrachtet werden müssen. Bei <math>n</math> zufällig gestreuten Punkten ergibt sich dabei eine Laufzeit von {{O|n}}. | |||
== Verwendung in verschiedenen Programmiersprachen == | |||
{| class="wikitable" | |||
|+ Verwendung von <math>\pi</math> in verschiedenen [[Programmiersprache]]n | |||
! Programmiersprache | |||
! [[Ausdruck]] für <math>\pi</math> | |||
! ggf. nötige Import-[[Anweisung]] | |||
|- | |||
| [[NEPO]] | |||
| [[Datei:NEPO Pi.svg|einfach]] | |||
| ☆-Blockset | |||
|- | |||
| [[Python (Programmiersprache)|Python]] | |||
| {{Python|math.pi}} | |||
| {{Python|import math}} | |||
|- | |||
| [[JavaScript]] | |||
| <syntaxhighlight lang="js" inline>Math.PI</syntaxhighlight> | |||
| – | |||
|- | |||
| [[Java (Programmiersprache)|Java]] | |||
| {{Java|Math.PI}} | |||
| {{Java|import java.lang.Math;}} | |||
|- | |||
|} |
Aktuelle Version vom 12. September 2024, 10:30 Uhr
Pi () ist eine Zahl, die das Verhältnis zwischen dem Durchmesser eines Kreises und seinem Umfang beschreibt.
Algorithmische Berechnung
lässt sich algorithmisch wie folgt berechnen: Man nimmt ein Quadrat der Seitenlänge 1 und zeichnet dort hinein einen Viertelkreis mit dem Radius 1. Dieser Viertelkreis hat die Fläche . Über dieses Quadrat legt man nun ein Raster aus Punkten und prüft für jeden dieser Punkte, ob er in dem Viertelkreis liegt oder nicht. Die Anzahl der Punkte im Viertelkreis geteilt durch die Gesamtzahl der Punkte im Quadrat ergibt dann eine Näherung für . Je engmaschiger dabei das Gitter ist, desto genauer wird auch die Näherung für .
Das rechts abgebildete Quadrat ist von einem Raster von 10×10 Punkten überzogen. Davon liegen 79 im Kreis (rot eingezeichnet). Als Näherung für ergibt sich der Wert , multipliziert mit 4 die Näherung für .
Als Programmablaufplan kann man diesen Algorithmus folgendermaßen darstellen:
Die Konstante STEP
gibt dabei an, wie engmaschig das Gitter sein soll, und kann beliebig angepasst werden. Der Wert für STEP
muss dabei zwischen 0 und 1 liegen.
Laufzeit dieses Algorithmus
Die Laufzeit dieses Algorithmus hängt davon ab, wie viele Punkte betrachtet werden müssen. Bei einem Gitter von Punkten beträgt die Laufzeit darum .
Berechnung mit Monte-Carlo-Algorithmus
Alternativ kann man auch einen Monte-Carlo-Algorithmus, d.h. einen Algorithmus mit einem zufallsbasierten Anteil, verwenden, um zu berechnen. Hier wird das Quadrat nicht mit einem systematischen Gitter, sondern einem zufälligen Hagel aus Punkten überzogen. Als Programmablaufplan kann man diesen Algorithmus folgendermaßen darstellen:
Die Konstante ZIEL
gibt dabei an, wie viele zufällige Punkte in dem Quadrat verteilt werden sollen und kann beliebig angepasst werden. Je mehr Punkte gestreut werden, desto länger benötigt der Algorithmus, desto genauer ist aber auch das Ergebnis.
Laufzeit dieses Algorithmus
Die Laufzeit dieses Algorithmus hängt davon ab, wie viele Punkte betrachtet werden müssen. Bei zufällig gestreuten Punkten ergibt sich dabei eine Laufzeit von .
Verwendung in verschiedenen Programmiersprachen
Programmiersprache | Ausdruck für | ggf. nötige Import-Anweisung |
---|---|---|
NEPO | ☆-Blockset | |
Python | math.pi
|
import math
|
JavaScript | Math.PI
|
– |
Java | Math.PI
|
import java.lang.Math;
|