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 ptso noch in LATEXForm
| Binär | dec | hex | bcd | dec(bcd) | aiken | dec(aiken) |
| 0 | 0 | |||||
| pt | pt | |||||
| pt | pt | |||||
| pt | pt | |||||
| pt | pt | |||||
| pt | pt | |||||
| pt | pt | pt | pt | |||
| pt | pt | |||||
| pt | pt | |||||
| pt | pt | |||||
| pt | pt | |||||
| pt | pt |
\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}
circuitikz
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
seed b m
D. Lehmer (1951) D. E. Knuthok, zur besseren einteilung:
seed b m
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.
|
|
|||||||
| 0 |
|
||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
|||||||
|
|
## (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.
gut, das macht insofern einen sinn, die zufallszahlen durch zu rechnen, weil sie im widerspruch zu fletcher,s checksum/hashtable stehen. allerdings: der unterschied:
// 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;
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.
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:~$