BALKEN- UND PUNKTPLOTS



 

Häufigkeitsdiagram
 

Bei einer Datenübertragung wird ein Zeichen (Bit) mit der Wahrscheinlichkeit p = 0.1 fehlerhaft übertragen. Eine Computerwort (Byte) besteht aus acht Bits. Mit welcher Wahrscheinlichkeit werden bei einem Byte höchstens zwei Bits falsch übertragen?

Die Aufgabe kann mit einer Simulation gelöst werden: Man erzeugt Blocks aus jeweils 8 Zufallszahlen. Dabei bedeutet eine Zufallszahl kleiner als 0.1 ein fehlerhaftes Zeichen. Gezählt wird, wie häufig ein fehlerhaftes Zeichen in n 8er Blocks vorkommt.

Für die Darstellung wird ein Häufigkeitsdiagramm verwendet.

 

  

Programm: [►]

#DiagEx1.py

from gpanel import *
from random import random

n = 1000

makeGPanel(-2, 10, -0.1 * n / 2, 1.1 * n / 2)
drawGrid(-1, 9, 0, n // 2, 10, 10)
setColor("red")

histo = [0] * 8 

for i in range(n):
    nbErrors = 0
    for k in range(8):
        if random() < 0.1:
            nbErrors += 1
    histo[nbErrors] += 1

lineWidth(5)
for i in range(0, 8):
    if histo[i] != 0:
        fillRectangle(i - 1/3, 0, i + 1/3, histo[i])
print "W'keit, höchstens 2 Zeichen falsch =",(histo[0] + histo[1] + histo[2])/n
keep()
Progammcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

  ► Erklärungen zum Programmcode
 

Die Lösung durch Simulation erfordert keine weiterführende mathematische Vorkenntnisse. Wenn man n noch grösser wählt, so stimmt das Ergebniss fast mit der theoretischen Wahrscheinlichkeit überein, die sich mit Hilfe der Binomialverteilung berechnen lässt:

 

 

Statistik des radioaktiven Zerfalls
 

Für den radioaktiven Zerfall ist die Wahrscheinlichkeit dp, dass ein bestimmtes Isotop während der Zeit dt zerfällt

dp = λ * dt

λ ist die Zerfallskonstante. Diese ist unabhängig davon, wie lange das Isotop bereits gelebt hat.

Für die Simulation unterwirft man in regelmässigen Zeitschritten jedes einzelne Isotop gemäss der Zerfallswahrscheinlichkeit einem möglichen Zerfall.

Die Population wird in einer Liste z mit den Werten 0 für ein zerfallenes und 1 für ein noch nicht zerfallenes Isotop modelliert. In der Zerfallsstatistik wird gezählt, wie viele Isotope in einer festen Zeit, beispielsweise 1 Sekunde zerfallen. In der Simulation wird die Häufigkeitsverteilung laufend aufgezeichnet.

 

  

Programm: [►]

# DiagEx2.py

import random
import time
from gpanel import *

def decay():
    for i in range(N0):
        if z[i] == 1:
            if random.random() < k * dt:
                z[i] = 0

def updateDistribution():
    global N
    decayed = N - sum(z)
    if decayed <= 100:
        h[decayed] += 1
    for i in range(11):
        line(i, 0, i, h[i]) 
    N = sum(z)
      
makeGPanel(-1, 11, -5, 55)
drawGrid(0, 10, 0, 50, "gray")
lineWidth(10)
title("Number of decays in 1 sec")
k = 0.005     # Decay constant (/s) 
N0 = 1000     # Starting number of isotopes
N = N0        # Current number of isotopes
z = [1] * N0  # Population
dt = 0.01     # Time interval for population check (s)
t = 0         # Current time 
tSec = 0      # Current seconds
h = [0] * 101 # Decay distribution

while t < 100:
    currentTime = time.clock()
    decay()
    tSecNew = int(t)            
    if tSecNew != tSec: # every second
        updateDistribution()
        tSec = tSecNew
    while time.clock() - currentTime < dt:
        pass          
    t += dt
title("All done") 
keep()
Progammcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

  ► Erklärungen zum Programmcode
 

Da die Population hier klein ist, spielt es eine grosse Rolle, dass die Zahl der Individuen im Laufe der Zeit abnimmt. Bei einer grossen Zahl der Individuen und entprechend kleiner Zerfallswahrscheinlichkeit ergibt sich eine Poisson-Verteilung.

Weiterführende Python-Programme zum radioaktiven Zerfall finden Sie unter
http://www.tigerjython.ch/download/computational_physics.pdf.

 

 

Wolkendiagramm (Scatter Plot)
 

Abhängigkeiten zwischen x- und y-Werten kann man so simulieren, dass y eine Funktion von x ist, die aber statistischen Schwankungen unterworfen ist. Solche Schwankungen nennt man in der Physik auch Rauschen.

Gezeichnet wird das Wolkendiagramm im Bereich x = 0..10 mit einer Schrittweite von 0.01für eine Parabel y = -x * (0.2 * x - 2) und normalverteiltem Rauschen.

 

 

 

  

Programm: [►]

#DiagEx3.py

import random
from gpanel import *
import math

z = 1000
a = 0.2
b = 2

def f(x):
    y = -x * (a * x - b)
    return y

makeGPanel(-1, 11, -1, 11)
title("y = -x * (0.2 * x - 2) with normally distributed noise")
drawGrid(0, 10, 0, 10, "gray")

xval = [0] * z
yval = [0] * z

for i in range(z):
    x = i / 100
    xval[i] = x
    yval[i] = f(x) + random.gauss(0, 0.5)
    move(xval[i], yval[i])
    fillCircle(0.03)
keep()
Progammcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

  ► Erklärungen zum Programmcode
  yval[i] = f(x) + random.gauss(0, 0.5)
Mit der Funktion random.gauss(mittelwert, streuung)
kann man sehr einfach normalverteilte Zufallszahlen erzeugen.