nächstes - ...

so, selbes problem. dann machen wir jetzt folgendes: ich uebe zunächst mit kaneda den schaltplan, mit transistoren, das ist das eine. und dann kommt mehr dazu, auch normale Reihen/Funktionen/Folgen und Codes. Z.B. erst eine rauchen. Also:
  1. erst die Transistoren bei TTL
  2. dann die Codes
  3. und noch etwas galasm syntax.
Image ttlexcersize10172026

ok, jetzt die codes. die erweiterung der TTL kommt beim nächsten mal, um den hinteren teil.

Binaer (Dezimal) Hexadezimal    BCD     Dec(BCD)  Aiken   Dec(Aiken)
0b0000  00              0x00    0b0000  0         0b0000        0
0b0001  01              0x01    0b0001  1         0b0001        1
0b0010  02              0x02    0b0010  2         0b0010        2
0b0011  03              0x03    0b0011  3         0b0011        3
0b0100  04              0x04    0b0100  4         0b0100        4
0b0101  05              0x05    0b0101  5         pt            pt
0b0110  06              0x06    0b0110  6         pt            pt
0b0111  07              0x07    0b0111  7         pt            pt
0b1000  08              0x08    0b1000  8         pt            pt
0b1001  09              0x09    0b1001  9         pt            pt
0b1010  10              0x0a    pt      pt        pt            pt
0b1011  11              0x0b    pt      pt        0b1011        5
0b1100  12              0x0c    pt      pt        0b1100        6
0b1101  13              0x0d    pt      pt        0b1101        7
0b1110  14              0x0e    pt      pt        0b1110        8
0b1111  15              0x0f    pt      pt        0b1111        9

dreiexcess

Binaer (Dezimal) Hexadezimal    Dreiexcess      Dec(Dreiexcess)
0b0000  00              0x00    pt              pt
0b0001  01              0x01    pt              pt
0b0010  02              0x02    pt              pt
0b0011  03              0x03    0b0011          0
0b0100  04              0x04    0b0100          1
0b0101  05              0x05    0b0101          2
0b0110  06              0x06    0b0110          3
0b0111  07              0x07    0b0111          4
0b1000  08              0x08    0b1000          5
0b1001  09              0x09    0b1001          6
0b1010  10              0x0a    0b1010          7
0b1011  11              0x0b    0b1011          8
0b1100  12              0x0c    0b1100          9
0b1101  13              0x0d    pt              pt
0b1110  14              0x0e    pt              pt
0b1111  15              0x0f    pt              pt

und jetzt kommt 1 aus 10, 2 aus 5 und 7 seg

Binaer (Dezimal)        1 aus 10                2 aus 5
0b0000  00              0b10.0000.0000          0b1.1000
0b0001  01              0b01.0000.0000          0b1.0100
0b0010  02              0b00.1000.0000          0b0.1100
0b0011  03              0b00.0100.0000          0b1.0010
0b0100  04              0b00.0010.0000          0b0.1010
0b0101  05              0b00.0001.0000          0b0.0110
0b0110  06              0b00.0000.1000          0b1.0001
0b0111  07              0b00.0000.0100          0b0.1001
0b1000  08              0b00.0000.0010          0b0.0101
0b1001  09              0b00.0000.0001          0b0.0011
0b1010  10              pt                      pt
0b1011  11              pt                      pt
0b1100  12              pt                      pt
0b1101  13              pt                      pt
0b1110  14              pt                      pt
0b1111  15              pt                      pt
so noch in LATEXForm

Binär dec hex bcd dec(bcd) aiken dec(aiken)
$0b0000$ $00$ $0x00$ $0b0000$ 0 $0b0000$ 0
$0b0001$ $01$ $0x01$ $0b0001$ $1$ $0b0001$ $1$
$0b0010$ $02$ $0x02$ $0b0010$ $2$ $0b0010$ $2$
$0b0011$ $03$ $0x03$ $0b0011$ $3$ $0b0011$ $3$
$0b0100$ $04$ $0x04$ $0b0100$ $4$ $0b0100$ $4$
$0b0101$ $05$ $0x05$ $0b0101$ $5$ pt pt
$0b0110$ $06$ $0x06$ $0b0110$ $6$ pt pt
$0b0111$ $07$ $0x07$ $0b0111$ $7$ pt pt
$0b1000$ $08$ $0x08$ $0b1000$ $8$ pt pt
$0b1001$ $09$ $0x09$ $0b1001$ $9$ pt pt
$0b1010$ $10$ $0x0a$ pt pt pt pt
$0b1011$ $11$ $0x0b$ pt pt $0b1011$ $5$
$0b1100$ $12$ $0x0c$ pt pt $0b1100$ $6$
$0b1101$ $13$ $0x0d$ pt pt $0b1101$ $7$
$0b1110$ $14$ $0x0e$ pt pt $0b1110$ $8$
$0b1111$ $15$ $0x0f$ pt pt $0b1111$ $9$
ok, diese uebung war gleichzeitig ein wenig stumpfsinnig, denn sie war eine LATEXTabelle, abgesehen, dass wir nachher bei den automaten gucken, hier weiter. jetzt erst was anderes, das schaltnetzt von oben mit kaneda.

\begin{tabular}{|c|c|c|c|c|c|c|}
\hline
Bin"ar & dec & hex & bcd & dec(bcd) & aiken  & dec(aiken)\\
\hline
$0b0000$ & $00$  & $0x00$  &  $0b0000$ & $0$  &       $0b0000$   &     $0$\\
$0b0001$ & $01$  & $0x01$  &  $0b0001$ & $1$  &       $0b0001$   &     $1$\\
$0b0010$ & $02$  & $0x02$  &  $0b0010$ & $2$  &       $0b0010$   &     $2$\\
$0b0011$ & $03$  & $0x03$  &  $0b0011$ & $3$  &       $0b0011$   &     $3$\\
$0b0100$ & $04$  & $0x04$  &  $0b0100$ & $4$  &       $0b0100$   &     $4$\\
$0b0101$ & $05$  & $0x05$  &  $0b0101$ & $5$  &       pt         &     pt\\
$0b0110$ & $06$  & $0x06$  &  $0b0110$ & $6$  &       pt         &     pt\\
$0b0111$ & $07$  & $0x07$  &  $0b0111$ & $7$  &       pt         &     pt\\
$0b1000$ & $08$  & $0x08$  &  $0b1000$ & $8$  &       pt         &     pt\\
$0b1001$ & $09$  & $0x09$  &  $0b1001$ & $9$  &       pt         &     pt\\
$0b1010$ & $10$  & $0x0a$  &  pt       & pt   &       pt         &     pt\\
$0b1011$ & $11$  & $0x0b$  &  pt       & pt   &       $0b1011$   &     $5$\\
$0b1100$ & $12$  & $0x0c$  &  pt       & pt   &       $0b1100$   &     $6$\\
$0b1101$ & $13$  & $0x0d$  &  pt       & pt   &       $0b1101$   &     $7$\\
$0b1110$ & $14$  & $0x0e$  &  pt       & pt   &       $0b1110$   &     $8$\\
$0b1111$ & $15$  & $0x0f$  &  pt       & pt   &       $0b1111$   &     $9$\\
\hline
\end{tabular}

erst zufallszahlen, robert Sedgewick, möglichst die nehmen, immer...
hände waschen.
hände waschen nicht möglich.
hände waschen halbwegs möglich.

robert sedgewick: methode der linearen kongruenz (D. lehmer - 1951).
Restmethode von Lehmer ::= lineare kongruenz

a [0] = seed;
for (i = 1;  i <= N;  i++)
    a [i] = (a [i-1]*b+1) % m;
ok, nun nehmen wir: bei robert Sedgewick, stehen folgene einschränkungen, immer wiederholen namen, nun:
D. Lehmer (1951)
D. E. Knuth
ok, zur besseren einteilung: wir versuchen es mit folgenden zahlen.
wir nehmen 16 bit, als computer wort, wir nehmen einer 2er potenz.
zunaechst kommt eine rechenaufgabe, dazwischen, da wir allerdings eine
2er potenz nehmen koennen, die kleiner sein darf, als das computer wort
selber (bedingung 2) - nehme ich folgende konstante:

0b1000.0000.0000.0000

vorher rechnen wir die zahl
0xffff
also:
0b1111.1111.1111.1111
aus nach der methode:

SUM_{i=0}^16 1*2^i =
1 + 2 + 4 + 8 + 16 + ... + 8192 + 8192*2 + 8192*4

ok:

8192*4 =
    32768  ... (3) ...
8192*2 =
    16384  ... (1) ...

 32768
+16384
+08192
+04096
+02048
+01024
+00512
+00256
+00128
+00064
+00032
+00016
+00008
+00004
+00002
+00001
------
ok, vielleicht nebeneinander mit klammern. um die einzelnen dezimalstellen zu zerlegen

(32768 +16384 +08192 +04096) +
(02048 +01024 +00512 +00256) +
(00128 +00064 +00032 +00016) +
(00008 +00004 +00002 +00001)

jetzt zerlegen:

(32760 + 8 + 16380 + 4 + 08190 + 2 + 04090 + 6) +
(02040 + 8 + 01020 + 4 + 00510 + 2 + 00250 + 6) +
(00120 + 8 + 00060 + 4 + 00030 + 2 + 00010 + 6)+
(00000 + 8 + 00000 + 4 + 00000 + 2 + 00000 + 1)

8+4+2+6 = 20
3*20 = 60 + 15 = 75

(32760 + 8 + 16380 + 4 + 08190 + 04090) +
(02040 + 8 + 01020 + 4 + 00510 + 00250) +
(00120 + 8 + 00060 + 4 + 00030 + 00010) +
(00000 + 8 + 00000 + 4 + 00000 + 2 + 00000) + 75

ob sich das so lohnt, weil man kann ja auch, dasselbe
an anderer stelle machen, weiss ich nicht, ich mache hier nicht weiter
und nehme jetzt als
b folgenden wert

b = 0b1000.0000.0000.0000 = 32768 ~ 32k

ok, weiter:
ok und fuer m gilt

1.) eine stelle weniger
also so ungefaehr 0000 ... 9999
2.) ohne besonderes muster (6789 z.B.)
3.) auf x21 enden, also:
0021 .. 9921 wobei ohne muster: 99 (aber wirklich ganze zahl?)

x sollte gerade sein, also. Z.B.

5821
(78 ist muster)
(98 ist muster)
58 sicher nicht, also 5821

und nun:

a [0] = seed;
for (i = 1;  i <= N;  i++)
    a [i] = (a [i-1]*b+1) % m;

seed nehmen wir 15. und fangen an.

m = 32768
b = 5821
seed = 15

tabelle nachher

i   a [i-1] m       b       (a [i-1]*b+1) % m       a [i]
1   15      32768   5821    (15*5821+1) % 32768     29106
2   29106   32768   5821    (29106*5821+1) % 32768


ok, nebenrechnungen wie auf schmierblatt:

5821 * 15 = 58210 +
5821 * 5 =
29105  (10, 40)
29105 + 1 = 29106
29106 % 32768 = 29106

(29106*5821+1) % 32768


29106*5821
145530               ,30,45
145530 * 1000 = 145530000
erste zeile:
29106*800 =
232848       48,72
ok: 232848 * 100 = 23284800
29106 * 21 =
58212   12, 18
582120

29106

    145530000
+    23284800
+      582120
+       29106
-------------
169406026

ok, mit diesen grossen zahlen, genug handschriftlich gerechnet geht es hier
nicht weiter, also python3. aber den algo nehmen und tabelle erzeugen, teil
der uebung.
$i$ $a_i$ $m$ $b$ $(a_{i-1}\cdot b+1)\mod m$ $a_{i-1}$    
0 $15$ $32768$ $5821$ $(32726 \cdot 5821 +1) \mod 32768$ $32726$    
$1$ $21780$ $32768$ $5821$ $(15 \cdot 5821 +1) \mod 32768$ $15$    
$2$ $1989$ $32768$ $5821$ $(21780 \cdot 5821 +1) \mod 32768$ $21780$    
$3$ $10866$ $32768$ $5821$ $(1989 \cdot 5821 +1) \mod 32768$ $1989$    
$4$ $8747$ $32768$ $5821$ $(10866 \cdot 5821 +1) \mod 32768$ $10866$    
$5$ $27584$ $32768$ $5821$ $(8747 \cdot 5821 +1) \mod 32768$ $8747$    
$6$ $3265$ $32768$ $5821$ $(27584 \cdot 5821 +1) \mod 32768$ $27584$    
$7$ $126$ $32768$ $5821$ $(3265 \cdot 5821 +1) \mod 32768$ $3265$    
$8$ $12551$ $32768$ $5821$ $(126 \cdot 5821 +1) \mod 32768$ $126$    
$9$ $19500$ $32768$ $5821$ $(12551 \cdot 5821 +1) \mod 32768$ $12551$    
$10$ $1149$ $32768$ $5821$ $(19500 \cdot 5821 +1) \mod 32768$ $19500$    
$11$ $3658$ $32768$ $5821$ $(1149 \cdot 5821 +1) \mod 32768$ $1149$    
$12$ $26787$ $32768$ $5821$ $(3658 \cdot 5821 +1) \mod 32768$ $3658$    
$13$ $16984$ $32768$ $5821$ $(26787 \cdot 5821 +1) \mod 32768$ $26787$    
$14$ $2809$ $32768$ $5821$ $(16984 \cdot 5821 +1) \mod 32768$ $16984$    
$15$ $32726$ $32768$ $5821$ $(2809 \cdot 5821 +1) \mod 32768$ $2809$    

## (c) david vajda
## 10/17/2026
## python3, zufallszahlen, generate
## with user interface table +
## user interface table (LaTeX)
## lineare Kongruenz (D. Lehmer) 195? 1wg. muss auf 21 enden?
## D. E. Knuth - Donald E. Knuth - aufstellen von regeln

m = 32768
b = 5821
seed = 15

## moegliche tests, ob zahlen in das schema passen, koennen
## folgen, aber nicht jetzt.

N = 16

a = [seed]
i = 1
while i < N:
    a.append((a [i-1]*b+1) % m)
    i = i + 1

i = 0
while i < len (a):
    print (a[i], end=",")
    i = i + 1
print ()
### Ergibt
### david@vajda-breadboard-0000:~$ python3 randomLinKon10172026.py
### 15,21780,1989,10866,8747,27584,3265,126,12551,19500,1149,3658,26787,16984,2809,32726,david@vajda-breadboard-0000:~$ python3
### randomLinKon10172026.py
### 15,21780,1989,10866,8747,27584,3265,126,12551,19500,1149,3658,26787,16984,2809,32726,david@vajda-breadboard-0000:~$

### ok und nun:
### test andere schleife fuer felder:

for r in a:
    print (r, end=",")
print ()

## noch mit modulo, damit die zufallszahlen in einem
## bestimmten zahlenbereich sind

for r in a:
    print (r%16, end=",")
print ()

## sieht ja nett aus
## david@vajda-breadboard-0000:~$ python3 randomLinKon10172026.py
## 15,21780,1989,10866,8747,27584,3265,126,12551,19500,1149,3658,26787,16984,2809,32726,
## 15,21780,1989,10866,8747,27584,3265,126,12551,19500,1149,3658,26787,16984,2809,32726,
## 15,4,5,2,11,0,1,14,7,12,13,10,3,8,9,6,
## david@vajda-breadboard-0000:~$

## jetzt machen wir eine ordentliche tabelle draus:

print ("\\begin{tabular}{|c|c|c|c|c|c|c|c}")
print ("\\hline")
print ("$i$ & $a_i$ & $m$ & $b$ & $(a_{i-1}\cdot b+1)\mod m$ & $a_{i-1}$\\\\")
print ("\\hline")
i = 0
while i < len (a):
    print (f"${i}$ & ${a[i]}$ & ${m}$ & ${b}$ & $({a [i-1]} \cdot {b} +1) \mod {m}$ & ${a [i-1]}$", end="\\\\\n")
    i = i + 1
print ("\\hline")
print ("\\end{tabular}")

ok, nachdem das passiert ist, zunächst kommt die normale menge der zufallszahlen hin, die wir nachher auch nutzen. im selben atemzug allerdings: mache ich die rechnung trotzdem selber auch, allerdings ein wenig anders. indem ich kleinere zahlen nehme, sollte die folge keinen sinn ergeben, in diesem sinne, dass sie sich zu schnell wiederholt ist das ja zunaechst egal.

$\displaystyle E_G = \{15,4,5,2,11,0,1,14,7,12,13,10,3,8,9,6\}$

bzw. das ist ja eher, dann auch als Liste zu gebrauchen - tupel, paare, ...

$\displaystyle L_G = (15,4,5,2,11,0,1,14,7,12,13,10,3,8,9,6)$

gut, das macht insofern einen sinn, die zufallszahlen durch zu rechnen, weil sie im widerspruch zu fletcher,s checksum/hashtable stehen. allerdings: der unterschied:

  1. fletcher's checksum - hashtable - wie auch immer, erhaltn quasi einen input
    zwei zahlenreihen werden gleichzeitig behandelt - ähnlich dem durchlauf eines mischers in der zementindustrie
  2. random: usw. lineare kongruenz: ist eine folge, die sich durch die anfangszahl erreichnet - seed - und: wir vergleichen
hashtable, nach Robert Sedgewick
// hashtable
for (h = 0;  *v != '\0';  v++)
    h = (64*h + *v) % M;

// lineare kongruenz - zufall - D. Lehmer
a [0] = seed;
for (i = 1;  i <= N;  i++)
    a [i] = (a [i-1]*b+1) % m;

// ersteres koennte man umformulieren als:

for (a [0] = 0;  b[i] != '\0';  i++)
    a [i] = (64*a [i-1] + b[i]) % M;

// damit stehen wir vor dem problem

for (a [0] = 0;  c[i] != '\0';  i++)
    a [i] = (a [i-1]*b + c[i]) % m;

// die sache unterscheidet sich nicht wesentlich, durch:

a [i] = (a [i-1]*b + c[i]) % m;
a [i] = (a [i-1]*b + 1) % m;

$\displaystyle (a_i) := (a_{i-1}\cdot b + 1)\mod m$

$\displaystyle (a_i) := (a_{i-1}\cdot b + c_i)\mod m$

ok: vielleicht koennte man eine zweite zufallszahlenfolge erzeugen, indem man genau das tut, und hier einfliessen laesst? das pruefen wir nicht jetzt! ok, erst mal pause!

naechste schritte:
    klavier und gitarre muss heute folgen
    der ordnung keits halber: folgt destillieren von wasser

    wichtig:
        das langrage wird vollzogen und zwar ohne
        tabellen und ohne tabellen per hand
        sondern ueber ausprobieren per array

        eine matrizenmultiplikation fehlt

        bash programmierung muss statt finden

        wichtig: hash/fletcher's checksum \dots

        moeglich: eine lange reihe, der erstellten
        zufallszahlen in einer datenbank von 0 .. 15
        wert
        und varianz und standardabweichung, erwartungswert
        errechnen, statt xi im quadrat test, alternative

        weitere dinge, die zu tun sind: dringend:
            rsa algorithmus fuer verschluesselung und
            entschluesselung sorgen probieren ...
            mit kleinen zahlen
        weitere dinge:
            netzwerkkarte:
                /etc/networks/interfaces
            weiteres:
                gpg...
            ueben
        und standard:
            atmega8: viele programme
            python3 viele programme
        und weiteres:
            handschriftlich kurrentschrift ueben
            garfield
            hieroglyphen
            arabisch
    weiter geht es mit:
        zunaechst mit langrage, ein test.

    spaeter noch:
        timing diagramm latex
        riemann auch mit latex tikz

    automaten spaeter bitte auch
        kaneda.
    schriftliche division binaer
        und umrechnen deswegen in eine bcd zahl, mal sehen ob klappt...

so, weiter bin ich nicht gekommen, leider, was langrage betrifft, na ja immerhin sache ausgelotet

## (c) david vajda
## 10/17/2026
## langrage, interpolation,
## use: integration: riemann
##      einzeichnen....

## X = (1, 2, 3, 4, 5)
X = [[[1,1],[0,-1]],[[1,1],[0,-2]],[[1,1],[0,-3]],[[1,1],[0,-4]],[[1,1],[0,-5]]]

## in der form
## (x-1)/(2-1) + (x-3)/(2-3) + (x-4)/(2-4) + (x-5)/(2-5)

## als [e_1,a_1],[e_2,a_2]
## a_1 * x^e_1 + a_2 * x^e_2
## 1*x^1 + (-1)*x^0
## [...] * [...] polynom,quotient mal dem anderen
## exponenten addieren
## 1+1 und koeffizienten, faktoren multiplizieren


for q in X:
    print (q)
## test
## ok

# test and real
def polmul (X, Y):
    print (X)
    print (Y)
    print ()
    return

i = len(X)-1
while i > 0:
    polmul (X[i], X[i-1])
    i = i - 1


# es entsteht ein neues element,
# die beiden alten werden mit
# pop jeweils abgenommen
# das neue ist rueckgabewert
# und wird hinten dran gehaengt
def polmul (X, Y):
    Z = []
    i = 0
    while i < len (X):
        # print (X[i])
        j = 0
        while j < len (Y):
            Z.append ([X[i][1]+Y[j][1],X[i][0]*Y[j][0]])
            j = j + 1
        i = i + 1
    # print ()
    print (Z)
    return

i = len(X)-1
while i > 0:
    polmul (X[i], X[i-1])
    i = i - 1
das ergebnis:
david@vajda-breadboard-0000:~$ python3 pyLangrageInterpolation10172026II.py
[[1, 1], [0, -1]]
[[1, 1], [0, -2]]
[[1, 1], [0, -3]]
[[1, 1], [0, -4]]
[[1, 1], [0, -5]]
[[1, 1], [0, -5]]
[[1, 1], [0, -4]]

[[1, 1], [0, -4]]
[[1, 1], [0, -3]]

[[1, 1], [0, -3]]
[[1, 1], [0, -2]]

[[1, 1], [0, -2]]
[[1, 1], [0, -1]]

[[2, 1], [-3, 0], [-4, 0], [-9, 0]]
[[2, 1], [-2, 0], [-3, 0], [-7, 0]]
[[2, 1], [-1, 0], [-2, 0], [-5, 0]]
[[2, 1], [0, 0], [-1, 0], [-3, 0]]
david@vajda-breadboard-0000:~$
als naechstes probiere ich die netzwerkkarte zu schreiben
# auto inet iface

auto enp2s0
inet enp2s0 iface dhcp

auto eth0
inet eth0 iface static
    address 192.168.0.128/24
    netmask 255.255.255.0
    dns-server
    gateway 4.4.4.4

auto lo0
inet lo0 iface loopback
ok, das scheint zu funktionieren, nachher kontrollieren.

im naechsten testen wir die zufallszahlen. wie gerade eben.

aber mit python3. hier das erste programm

## (c) david vajda
## 10/17/2026
## python3, zufallszahlen, generate
## with user interface table +
## user interface table (LaTeX)
## lineare Kongruenz (D. Lehmer) 195? 1wg. muss auf 21 enden?
## D. E. Knuth - Donald E. Knuth - aufstellen von regeln

m = 32768
b = 5821
seed = 15

## moegliche tests, ob zahlen in das schema passen, koennen
## folgen, aber nicht jetzt.

N = 2024

a = [seed]
i = 1
while i < N:
    a.append((a [i-1]*b+1) % m)
    i = i + 1

i = 0
while i < len (a):
    print (a[i], end=",")
    i = i + 1
print (f"stichprobenumfang n = {i}")

R = []
for r in a:
    R.append(r%16)


relHaeuf = [[0,0],[1,0],[2,0],[3,0],[4,0],[5,0],[6,0],[7,0],[8,0],[9,0],[10,0],[11,0],[12,0],[13,0],[14,0],[15,0]]

for r in R:
    relHaeuf [r][1] = relHaeuf [r][1] + 1

i = 0
while i < len (relHaeuf):
    print (relHaeuf [i][1]/len(relHaeuf))
    i = i + 1

Das sieht gut aus:

benumfang n = 2024
7.9375
7.9375
7.9375
7.875
7.9375
7.9375
7.875
7.875
7.875
7.875
7.875
7.9375
7.875
7.875
7.9375
7.9375
david@vajda-breadboard-0000:~$
nun noch der erwartungswert.
## (c) david vajda
## 10/17/2026
## python3, zufallszahlen, generate
## with user interface table +
## user interface table (LaTeX)
## lineare Kongruenz (D. Lehmer) 195? 1wg. muss auf 21 enden?
## D. E. Knuth - Donald E. Knuth - aufstellen von regeln

m = 32768
b = 5821
seed = 15

## moegliche tests, ob zahlen in das schema passen, koennen
## folgen, aber nicht jetzt.

N = 2024

a = [seed]
i = 1
while i < N:
    a.append((a [i-1]*b+1) % m)
    i = i + 1

i = 0
while i < len (a):
    print (a[i], end=",")
    i = i + 1
print (f"stichprobenumfang n = {i}")

R = []
for r in a:
    R.append(r%16)


relHaeuf = [[0,0],[1,0],[2,0],[3,0],[4,0],[5,0],[6,0],[7,0],[8,0],[9,0],[10,0],[11,0],[12,0],[13,0],[14,0],[15,0]]

for r in R:
    relHaeuf [r][1] = relHaeuf [r][1] + 1

i = 0
while i < len (relHaeuf):
    print (relHaeuf [i][1]/len(relHaeuf))
    i = i + 1

## erwartungswert:

i = 0
E_x = 0
while i < len (relHaeuf):
    E_x = E_x + ((relHaeuf [i][1]/len(relHaeuf) * relHaeuf [i][0]))
    i = i + 1

## der hier entstandene reale? "erwartungswert"
## die formel entspricht die des erwartungswert
## unter der vorraussetzung, dass der wert selber
## das zu erwartende kapital ist was ungewoehnlich
## beim wuerfel sein koennte.
## und dem damit real entstandenen wert, z.B. bei
## aktien
## unterscheidet sich insofern von dem
## erwartungswert an sich

i = 0
Er_x = 0
while i < len (relHaeuf):
    Er_x = Er_x + (i)*(1/16)
    i = i + 1

print (f"{E_x},{Er_x}")

## ok man sieht, die laenge ist falsch, an der stelle mit relhaeuf
## stimmt was nicht, genuegt aber. jetzt erst mal
ergebnis
1803,9504,10401,21726,15335,5004,30301,24746,31107,30648,13017,12342,15327,23972,14869,12162,16123,4432,10257,2702,32471,7868,22733,11610,14195,20968,26697,17382,25807,14036,12933,14898,17131,6528,21377,15422,19911,1516,10045,13834,16739,18456,18873,21398,6591,27652,5877,226,4827,15792,10993,27118,10423,18716,25005,31418,5971,23112,22313,24390,23215,32052,26469,914,11979,32224,11873,5022,4007,26700,2077,31594,14659,2168,4249,26358,10143,27236,9173,16962,5819,23056,24017,14670,663,25468,6797,14362,10035,21160,30217,27302,143,13204,19525,15602,19115,21056,14657,23294,391,15020,6397,12490,24867,14552,1913,27222,25983,22724,24757,29602,19099,26224,16561,30894,3191,28124,877,25978,26387,15112,17641,26118,22127,23028,24869,26194,5771,5792,29729,4702,9063,32012,23005,22058,14595,22840,11865,23990,21343,14116,19861,5378,11899,25296,21393,10254,18007,26684,7245,730,22259,4968,17353,20838,23631,28756,9733,32690,4715,19200,24321,14782,30023,12140,19133,27530,16611,27032,1337,16662,28991,1412,27253,9826,16987,20272,5745,18286,12343,21148,25901,4154,30419,23496,29353,11462,4655,30388,6885,2322,15947,28512,31201,20766,stichprobenumfang n = 2024
7.9375
7.9375
7.9375
7.875
7.9375
7.9375
7.875
7.875
7.875
7.875
7.875
7.9375
7.875
7.875
7.9375
7.9375
948.25,7.5
david@vajda-breadboard-0000:~$