Pi: Unterschied zwischen den Versionen

Aus KGS-Wiki
(Graph ist noch fehlerhaft D:)
 
 
(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"/] --> end(("Ende"))
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

Viertelkreis, mit Flächenraster 10×10 angenähert, innerhalb 79 Punkte (rot), außerhalb 21 Punkte (blau)

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 .

💬
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 ergibt sich der Wert , multipliziert mit 4 die Näherung für .

Als Programmablaufplan kann man diesen Algorithmus folgendermaßen darstellen:

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 wy --nein--> s10["Erhöhe <code>x</code> um <code>STEP</code>"] --> wx 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"/] --> ende(("Ende"))

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

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

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

Verwendung von in verschiedenen Programmiersprachen
Programmiersprache Ausdruck für ggf. nötige Import-Anweisung
NEPO einfach ☆-Blockset
Python math.pi import math
JavaScript Math.PI
Java Math.PI import java.lang.Math;