<jupyter_start><jupyter_text>Materialien zu zufallAutor: <NAME> - <EMAIL> Aufgaben 4 - Mehrere Listen Siehe dazuElemente der MathematikLeistungskurs StochastikSchroedel 2003S. 87 Aufgabe 9a<jupyter_code>%run zufall/start<jupyter_output><empty_output><jupyter_text>1. Augensumme beim gemeinsamen Werfen von Tetraeder und OktaederEs wird die Zufallsgröße $X$ = "Augensumme beim gemeinsamen Werfen eines regu-lären Tetraeders und Oktaeders" betrachtet. Gesucht ist ihre Verteilung Das Zufallsexperiment kann mit den beiden Listen<jupyter_code>L4 = [1, 2, 3, 4]; L8 = list(range(1, 9)); L4, L8<jupyter_output><empty_output><jupyter_text>beschrieben werden; $X\,$ wird mittels einer ZG-Funktion definiert<jupyter_code>X = ZE(L4, L8, f=summe)
X.vert
X.hist<jupyter_output><jupyter_text>2. Mehrkampfleistung eines SportlersDie Aufgabe wurde entnommen ausSIGMA Grundkurs StochastikErnst Klett Verlag 1982S. 76  Aufgabe 9Aus jeder der abgebildeten Urnen wird eine Kugel entnommen. Man interessiert sich für die Summe der darauf stehenden Zahlen(Über die Leistungen des Sportlers in den Einzeldisziplinen liegt statistischesMaterial vor. Eine Kugel mit der Nummer $i$ bedeutet, dass der Sportler für die entsprechende Leistung $90+i$ Punkte erhält ) Die Routine zur Herstellung der Grafik befindet sich am Ende des Notebooks)Ein Versuch erbringt 4 Kugeln, $X_i\,$ sei die Zufallsgröße, die der $i$. Kugel  ihre Punktzahl zuordnet ($i = 1,2,3,4$). Die Verteilungen dieser Zufallsgrößen sind bekannt. Gesucht ist die Verteilung von $S = X_1+X_2+X_3+X_4$Folgende dict's beschreiben die Urnen<jupyter_code>L1 = {1:1, 2:1, 3:2, 4:5, 5:1}
L2 = {1:4, 2:3, 3:2, 4:1}     
L3 ={1:2, 2:3, 3:1, 4:1, 5:3}      
L4 = {1:3, 2:1, 3:2, 4:1, 5:3}<jupyter_output><empty_output><jupyter_text>Die ZufallsGroesse wird aus dem 4-stufigen ZufallsExperiment erzeugt,dasauf diesen Listen basiert. Zur Addition der Einzelpunkte wird die Funktionsumme benutzt<jupyter_code>S = ZE( L1, L2, L3, L4, f=summe)<jupyter_output>Erzeugung eines ZufallsGroesse-Objektes<jupyter_text>$S$ hat die Verteilung und das Histogramm<jupyter_code>S.vert<jupyter_output><empty_output><jupyter_text>Interessant ist auch der Vergleich mit der Normalverteilung, die mit dem (zwecksbesserer Einpassung mittels Versuch/Irrtum korrigierten) Erwartungswert und der Varianz von $S$ definiert wird (die betrachtete Zufallsgröße ist die Summe von vierZufallsgrößen)<jupyter_code>S.hist
S.hist_(NV(S.erw-3, S.sigma))   # -3 - Verschiebung<jupyter_output><jupyter_text>2. Zwei GlücksräderDie Aufgabe wurde entnommen aus Fischers AbiturwissenMathematikFischer Taschenbuch Verlag 2004S.327 Wir betrachten zwei Glücksräder Jemand bietet Ihnen zwei Spiele zur Auswahl an: Entweder dürfen Sie gegen ei-nen Einsatz von 3.50 € beide Glücksräder drehen und die Summe der Augenzahlen in € als Gewinn behalten, oder Sie dürfen gegen einen Einsatz von 3.50 € beideGlücksräder drehen und das Produkt der Augenzahlen in € als Gewinn behalten. Welches Spiel würden Sie wählen? Die beiden Glücksräder werden durch die Listen<jupyter_code>L1 = {0:90, 1:90, 2:60, 3:60, 4:60}
L2 = {1:180, 2:60, 3:120}<jupyter_output><empty_output><jupyter_text>beschrieben (die rechten Zahlen sind die Öffnungswinkel der einzelnen Sekto-ren). Das zugrunde liegende ZufallsExperiment ist<jupyter_code>GlücksRad(L1, L2)<jupyter_output><empty_output><jupyter_text>Die interessierende ZufallsGroesse $Summe$ = "Summe der Augenzahlen" kannauf der Grundlage dieses ZufallsExperimentes mit Hilfe der ZG-Funktion summeberechnet werden<jupyter_code>Summe = GlücksRad(L1, L2, f=summe)<jupyter_output>Erzeugung eines ZufallsGroesse-Objektes<jupyter_text>Für die ZufallsGroesse $Produkt$ = "Produkt der Augenzahlen" wird eine eigeneZG-Funktion  benutztDazu dient hier eine sogenannte anonyme (unbenannte) lambda-Funktion; ihr  Argument ist ein Element der Ergebnismenge in Listenform, berechnet wirddas Produkt der beiden Listenelemente<jupyter_code>Produkt = GlücksRad(L1, L2, f=lambda x: x[0]*x[1])<jupyter_output>Erzeugung eines ZufallsGroesse-Objektes<jupyter_text>Die Histogramme der Wahrscheinlichkeitsverteilungen für die beiden Zufallsgrö-ßen sind<jupyter_code>Summe.hist; Produkt.hist<jupyter_output><jupyter_text>Die Wahrscheinlichkeitsverteilungen selbst sind<jupyter_code>Summe.vert
Produkt.vert<jupyter_output><empty_output><jupyter_text>Die Erwartungswerte der beiden ZufallsGrößen sowie die Erwartungswertedes Gewinnes pro Spiel sind dann (in €)<jupyter_code>Summe.erw,     Summe.erw - 3.50
Produkt.erw,     Produkt.erw - 3.50<jupyter_output><empty_output><jupyter_text>Damit ist das Spiel um die  Summe der Augenzahlen mit einem durchschnitt-lichen Gewinn von mehr als 8 cent günstig, während das Spiel um das Produktdurchschnittlich etwa 29 cent Verlust einbringt  Grafik zu MehrkampfleistungHerstellung und Speicherung in einer Datei:<jupyter_code>import matplotlib.pyplot as plt
import matplotlib.patches as patches

def line(x, y):
    return plt.plot(x, y, color='blue', lw=1)    

r = 0.038
def kreis(x, y, n):
    k = patches.Circle((x, y+0.006), r, fill=None, edgecolor=(0,0,0), alpha=0.5)
    ax.add_patch(k)
    ax.text(x, y, str(n), fontsize=9, alpha=0.9, horizontalalignment='center',
    verticalalignment='center', fontname='Times new Roman')

def urne(x, y):
    d = 0.4
    line([x, x+d], [y, y])
    line([x, x], [y, y+0.7*d])
    line([x+d, x+d], [y, y+0.7*d])

plt.close('all')    
fig = plt.figure(figsize=(4, 2.5))
ax = fig.add_subplot(1, 1, 1, aspect='equal')
ax.axis('off')
plt.xlim(0.01, 1.3)
plt.ylim(0.09, 1.01)

d1 = 0.2
urne(0.096, 0.6)
urne(d1+0.547, 0.6)
urne(0.096, 0.15)
urne(d1+0.547, 0.15)

ax.text(0.3, 0.55, 'Urne 1', fontsize=10, alpha=0.9, horizontalalignment='center',
    verticalalignment='center', fontname='Times New Roman')
kreis(0.3-4*r, 0.6+r, 1)
kreis(0.3-2*r, 0.6+r, 2)
for i in (1, 3):
    kreis(0.3, 0.6+i*r, 3)
for i in (1, 3, 5, 7, 9):
    kreis(0.3+2*r, 0.6+i*r, 4)
kreis(0.3+4*r, 0.6+r, 5)
      
ax.text(d1+0.75, 0.55, 'Urne 2', fontsize=10, alpha=0.9, horizontalalignment='center',
    verticalalignment='center', fontname='Times New Roman')    
for i in (1, 3, 5, 7):
    kreis(d1+0.75-4*r, 0.6+i*r, 1)    
for i in (1, 3, 5):
    kreis(d1+0.75-2*r, 0.6+i*r, 2) 
for i in (1, 3):
    kreis(d1+0.75, 0.6+i*r, 3)      
kreis(d1+0.75+2*r, 0.6+r, 4) 

ax.text(0.3, 0.1, 'Urne 3', fontsize=10, alpha=0.9, horizontalalignment='center',
    verticalalignment='center', fontname='Times New Roman')
for i in (1, 3):
    kreis(0.3-4*r, 0.15+i*r, 1) 
for i in (1, 3, 5):
    kreis(0.3-2*r, 0.15+i*r, 2)     
kreis(0.3, 0.15+r, 3)    
kreis(0.3+2*r, 0.15+r, 4)   
for i in (1, 3, 5):
    kreis(0.3+4*r, 0.15+i*r, 5) 

ax.text(d1+0.75, 0.1, 'Urne 4', fontsize=10, alpha=0.9, horizontalalignment='center',
    verticalalignment='center', fontname='Times New Roman')
for i in (1, 3, 5):
    kreis(d1+0.75-4*r, 0.15+i*r, 1) 
kreis(d1+0.75-2*r, 0.15+r, 2)    
for i in (1, 3):
    kreis(d1+0.75, 0.15+i*r, 3)         
kreis(d1+0.75+2*r, 0.15+r, 4)   
for i in (1, 3, 5):
    kreis(d1+0.75+4*r, 0.15+i*r, 5) 
  
#plt.savefig('mehrkampf.png')   # ist bereits gespeichert

#plt.show()<jupyter_output><empty_output><jupyter_text>Kontrollausgabe (in Markdown-Zelle)   Grafik zu Glücksrädern<jupyter_code>import matplotlib.pyplot as plt
import matplotlib.patches as patches

r = 1.1
gl1 = [1+r*cos(x), 1+r*sin(x)]
gl2 = [4+r*cos(x), 1+r*sin(x)]

def p1(w):
    return [el.subs(x, w) for el in gl1]

def p2(wi):
    return [el.subs(x, wi) for el in gl2]

def line(x, y):
    return plt.plot(x, y, color='black', lw=0.8)   

def text(x, y, n):
    ax.text(x, y, str(n), fontsize=9, alpha=0.9, horizontalalignment='center',
    verticalalignment='center', fontname='Times new Roman')
    
plt.close('all')    
fig = plt.figure(figsize=(4, 2))
ax = fig.add_subplot(1, 1, 1, aspect='equal')
ax.axis('off')
plt.xlim(-0.2, 5.5)
plt.ylim(-0.2, 2.2)

kreis1 = patches.Circle((1, 1), 1.1, fill=None, 
                 edgecolor=(0,0,0), alpha=0.5)
kreis2 = patches.Circle((4, 1), 1.1, fill=None, 
                 edgecolor=(0,0,0), alpha=0.5)
ax.add_patch(kreis1)
ax.add_patch(kreis2)

for w in (0, pi/3, 2/3*pi, pi, 3/2*pi):
    p = [float(p1(w)[0]), float(p1(w)[1])]
    line([1, p[0]], [1, p[1]])
for w in (pi/2, 5/6*pi, 3/2*pi):
    p = [float(p2(w)[0]), float(p2(w)[1])]
    line([4, p[0]], [1, p[1]])    
    
ax.arrow(0.85, 0.2, 0.335, 1.6, head_width=0.085, head_length=0.25, fc='b', ec='b')
ax.arrow(3.85, 0.2, 0.335, 1.6, head_width=0.085, head_length=0.25, fc='b', ec='b')

for t in [(0.5, 0.5, 0), (1.5, 0.5, 1), (1.6, 1.4, 2), (1, 1.7, 3), (0.4, 1.4, 4), \
         (4.5, 1, 0), (3.7, 1.6, 1), (3.5, 0.5, 2)]:
    text(*t)
    
#plt.savefig('gluecksraeder.png')   # ist bereits gespeichert

#plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14805105994985185, 'fraction_numerical': 0.066560291771142, 'mean_word_length': 4.822826808228268, 'pattern_counts': {'":': 0, '<': 61, '<?xml version=': 0, '>': 61, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '16', 'dir': 'jupyter-structured-clean-dedup', 'id': '375229', 'license': 'Apache-2.0', 'n_tokens_mistral': 4133, 'n_tokens_neox': 3942, 'n_words': 918, 'path': 'zufall/mat/aufgaben4.ipynb', 'repo_name': 'HBOMAT/AglaUndZufall', 'size': '8792'}