```python
import matplotlib.pyplot as plt
import scipy.stats as st
import seaborn as sns
import pandas as pd
from scipy.stats import norm, uniform, expon, t, probplot
import scipy.stats as st
from scipy.integrate import quad
from sympy.solvers import solve
from sympy import Symbol
import numpy as np
from pandas import Series, DataFrame
```


```python
np.random.seed(1)
methode_B = np.array([80.02, 79.94, 79.98, 79.97, 79.97, 80.03, 79.95,
79.97])
# Arithmetisches Mittel der Messreihe methode_B
print('Arithmetisches Mittel von Messreihe Methode B:', methode_B.mean())
# Länge n der Messreihe methode_B
n = methode_B.size
# Anzahl Bootstrap samples
nboot = 1
# Bootstrap Sample wird aus Messreihe durch zufälliges
# Ziehen mit Zurücklegen generiert
bootstrap_sample = np.random.choice(methode_B, n*nboot, replace=True)
bootstrap_sample
print('Bootstrap Sample : ' , bootstrap_sample)
# Arithmetisches Mittel des Bootstrap Sample
print('Arithmetisches Mittel von Bootstrap Sample:' , bootstrap_sample.mean())
```

    Arithmetisches Mittel von Messreihe Methode B: 79.97874999999999
    Bootstrap Sample :  [80.03 79.97 79.97 80.02 79.97 79.94 79.97 80.03]
    Arithmetisches Mittel von Bootstrap Sample: 79.9875



```python
methode_B = np.array([80.02, 79.94, 79.98, 79.97, 79.97, 80.03, 79.95,
79.97])
n = methode_B.size
nboot = 1
bootstrap_sample = np.random.choice(methode_B, n*nboot, replace=True)
bootstrap_sample
print('Bootstrap Sample : ' , bootstrap_sample)
```

    Bootstrap Sample :  [79.97 80.02 80.02 79.94 79.97 79.97 80.03 79.97]



```python
print('Bootstrap Sample : ' , bootstrap_sample.mean())
```

    Bootstrap Sample :  79.98625



```python
np.random.seed(1)
methode_B = np.array([80.02, 79.94, 79.98, 79.97, 79.97, 80.03,79.95, 79.97])
n = methode_B.size
nboot = 20
bootstrap_sample = np.random.choice(methode_B, n*nboot, replace=True)
bootstrap_sample_array = np.reshape(bootstrap_sample, (n, nboot))
bootstrap_sample_array
xbarstar = bootstrap_sample_array.mean(axis=0)
np.sort(xbarstar)
print(np.sort(xbarstar))
```

    [79.96375 79.965   79.96625 79.96875 79.97125 79.97375 79.97625 79.9775
     79.97875 79.98    79.98125 79.98125 79.9825  79.9825  79.98375 79.985
     79.985   79.9875  79.99    79.99375]



```python
xbarstar = bootstrap_sample_array.mean(axis=0)
d = np.percentile(xbarstar, q=[2.5, 97.5])
print('Vertrauensintervall: ',d)
```

    Vertrauensintervall:  [79.96434375 79.99196875]



```python
tempdata = np.random.choice(methode_B, n*nboot, replace=True)
bootstrap_sample_array = np.reshape(tempdata, (n, nboot))
xbarstar = bootstrap_sample_array.mean(axis=0)
xbar = methode_B.mean()
delta = np.sort(xbarstar - xbar)
print('Abweichungen: ',delta)
```

    Abweichungen:  [-1.87500000e-02 -1.50000000e-02 -8.75000000e-03 -6.25000000e-03
     -6.25000000e-03 -5.00000000e-03 -5.00000000e-03 -2.50000000e-03
     -1.25000000e-03 -1.25000000e-03  1.42108547e-14  1.42108547e-14
      1.42108547e-14  2.50000000e-03  2.50000000e-03  5.00000000e-03
      6.25000000e-03  1.00000000e-02  1.25000000e-02  1.37500000e-02]



```python
tempdata = np.random.choice(methode_B, n*nboot, replace=True)
bootstrap_sample_array = np.reshape(tempdata, (n, nboot))
xbarstar = bootstrap_sample_array.mean(axis=0)
delta = np.sort(xbarstar - xbar)
d = np.percentile(delta, q=[2.5, 97.5])
print('0.025 und 0.975 Quantilen der Abweichungen: ',d)
```

    0.025 und 0.975 Quantilen der Abweichungen:  [-0.01446875  0.01578125]



```python
np.random.seed(1)
methode_B = np.array([80.02, 79.94, 79.98, 79.97, 79.97, 80.03,
79.95, 79.97])
n = methode_B.size
nboot = 10000
bootstrap_sample = np.random.choice(methode_B, n*nboot, replace=True)
bootstrap_sample_array = np.reshape(bootstrap_sample, (n, nboot))
bootstrap_sample_array
xbarstar = bootstrap_sample_array.mean(axis=0)
d = np.percentile(xbarstar, q=[2.5, 97.5])
print('Vertrauensintervall: ',d)
```

    Vertrauensintervall:  [79.96    79.99875]



```python
x = np.array([80.02, 79.94, 79.98, 79.97, 79.97, 80.03, 79.95, 79.97])
n = x.size
np.random.seed(1)
xbar = x.mean()
nboot = 10000
tmpdata = np.random.choice(x, n*nboot, replace=True)
bootstrapsample = np.reshape(tmpdata, (n, nboot))
xbarstar = Series(bootstrapsample.mean(axis=0))
plt.subplot(121)
xbarstar.plot(kind="hist", edgecolor="black")
plt.subplot(122)
probplot(xbarstar, plot=plt)
```


```python
n = x.size
np.random.seed(1)
standardabweichung_der_messdaten = x.mean()
nboot = 10000
tmpdata = np.random.choice(x, n*nboot, replace=True)
bootstrapsample = np.reshape(tmpdata, (n, nboot))
xbarstar = Series(bootstrapsample.mean(axis=0))
d = xbar - 2*xbarstar.std() , xbar + 2*xbarstar.std()
print('Vertrauensintervall: ',d)
```

    Vertrauensintervall:  (79.95819874674378, 79.9993012532562)



```python
x = np.random.normal(loc=40,scale=5,size=100)
n = x.size
np.random.seed(4)
xbar = x.mean()
# Anzahl Bootstrap Stichproben
nboot = 20
# Erzeuge Bootstrap Stichproben
bootstrap_samples = np.random.choice(x, n*nboot, replace=True)
bootstrap_sample_array = np.reshape(bootstrap_samples, (n, nboot))
# Arithmetisches Mittel für jede Bootstrap Stichprobe
xbarstar = bootstrap_sample_array.mean(axis=0)
# 2.5% und 97.5% Quantilen der Mittelwerte
# der Bootstrap Samples
ci = np.percentile(xbarstar, q=[2.5, 97.5])
# Vertrauensintervalle
print("Vertrauensintervall: ",ci)
```

    Vertrauensintervall:  [39.59026732 41.39130025]



```python
# Wir erzeugen 100'000 normalverteilte Zufallszahlen
# mit Mittelwert 40 und Standardabweichung 5
x = np.random.normal(loc=40, scale=5, size=10000)
# Wir ordnen diese Zahlen in einem Array an, der aus 100 Zeilen
# und 100 Spalten besteht
measurement_array = np.reshape(x,(100,100))
print(measurement_array.shape)
```

    (100, 100)



```python
print(measurement_array[1].size)
# Anzahl Bootstrap Samples
nboot = 1000
# Länge von jeder Bootstrap Stichprobe
n = 100
# k zählt Anzahl Vertrauensintervalle, die das
# wahre mu=40 nicht enthalten
k=0
# Wir iterieren über alle 100 Testreihen und bestimmen für jede
# Testreihe ein Vertrauensintervall (mittels bootstrap)
for i in range(0,100):
    x = measurement_array[i]
    # Arithmetisches Mittel pro Zeile im Array wird berechnet
    xbar = x.mean()
    # für die Zeile x wird nun ein Vertrauensintervall
    # mittels Bootstrap konstruiert
    bootstrap_samples = np.random.choice(x, n*nboot, replace=True)
    bootstrap_sample_array = np.reshape(bootstrap_samples, (n, nboot))
    xbarstar = bootstrap_sample_array.mean(axis=0)
    d = np.percentile(xbarstar, q=[2.5, 97.5])
    # Falls 40 im Vertrauensintervall für Zeile i NICHT enthalten ist
    # wird k um 1 erhöht
    if d[0]<= 40 <= d[1]:
        k=k+1
print(k)
```

    100
    94



```python
#np.random.seed(8)
# Wir generieren 10'000 normalverteilte Zufallszahlen
# mit Mittelwert 40 und Standardabweichung 5
x = np.random.normal(loc=40, scale=5, size=10000)
# Wir ordnen die Zufallszahlen in einem array mit 100 Spalten
# und 100 Zeilen an
measurement_array = np.reshape(x,(100,100))
print(measurement_array.shape)
# Anzahl Bootstrap Samples
nboot = 10000
n = 100
# Wir iterieren über die 100 Testreihen
for i in range(0,100):
    # wir lesen die i-te Zeile aus dem measurement_array heraus
    y = measurement_array[i]
    # Bestimmung des Vertrauensintervalls der i-ten Testreihe
    tmpdata = np.random.choice(y, n*nboot, replace=True)
    bootstrapsample = np.reshape(tmpdata, (n, nboot))
    xbarstar = bootstrapsample.mean(axis=0)
    ci = np.percentile(xbarstar, q=[2.5, 97.5])
    plt.plot([i,i],[ci[0], ci[1]])
    if (ci[0]<= 40 <= ci[1])==False:
        plt.plot([i,i],[ci[0], ci[1]], c="black",linewidth=3)
        plt.plot([-5,105],[40,40])
plt.show()
```


```python

```


```python

```


```python

```

ddb8e4105ebf62108e9535acb848fd54c88527ee
ipynb
Jupyter Notebook
Lernphase/SW07/Skript.ipynb
florianbaer/STAT
7cb86406ed99b88055c92c1913b46e8995835cbb
MIT
Lernphase/SW07/Skript.ipynb
florianbaer/STAT
7cb86406ed99b88055c92c1913b46e8995835cbb
MIT
Lernphase/SW07/Skript.ipynb
florianbaer/STAT
7cb86406ed99b88055c92c1913b46e8995835cbb
MIT
Qwen/Qwen-72B
1. YES
2. YES