Re: random Statistik

Aktuelles Skript: ==================================================================== ARITH_FMT='%.6Lf' set r:025 r0:025 z:025 n:020 e:020 s:025 m:025 m0:025 sa:025 dp:025 dm:025 d0:025 s=0 m=0.0 m0=-1.0 sa=0.0 d=00 i=0000000000 array 1 6 Z $i $i $i $i $i $i

echo Anzahl Zufallszahl SummeZ Mittelwert Abweichungen

for n from 1 to 1000000 repeat do let "r= random(6)+1" "d=r-r0, r0=r" "d>=0" run? "let 'dp+=d'" "let 'dm-=d'" let "s+=r" "m=s/$n.0" "sa+=m-3.5" "++Z[r]" "d==0" && let "++d0" echo "$n $r $s $m $((llround(sa)))" done

let "r=($n-1)/6" echo "%n$Z1 $Z2 $Z3 $Z4 $Z5 $Z6 " Anzahlen von 1 2 3 4 5 6 echo "$((Z1-r)) $((Z2-r)) $((Z3-r)) $((Z4-r)) $((Z5-r)) $((Z6-r)) " % Differenzen zum Erwartungswert echo "$dp $dm $d0 " Summen der pos. und neg. Differenzen und Gleichheiten Z-Z0 ====================================================================

Das Skript enthält nun neben neuen Berechnungen Zahlenbeschriftungen.

Chatgpt:

------- The script appears to be written in a Unix shell scripting language, specifically using syntax and constructs typical of bash or sh.

--------

Laeuft allerdings bei mir nicht:

------ bash: line 4: array: command not found Anzahl Zufallszahl SummeZ Mittelwert Abweichungen bash: line 8: syntax error near unexpected token `from' bash: line 8: `for n from 1 to 1000000 repeat'

------ Ich vermute mal das ist fuer deine selbstgeschriebene Spezial-shell.

Es ist auch keine gute Idee sowas als shell script zu programmieren... Gluecklicherweise gibts chatgpt um das ganze in C zu uebersetzen:

--------- #include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include <math.h>

int main() { long double ARITH_FMT = 0.0; long long r = 0, r0 = 0, z = 0, n = 0, e = 0, s = 0, m = 0, m0 = 0; long double sa = 0.0, dp = 0.0, dm = 0.0; int d0 = 0, d = 0, i = 0; long long Z[7] = {0}; // Array to store counts of dice rolls from 1 to 6 long long count = 1000000;

printf("Anzahl Zufallszahl SummeZ Mittelwert Abweichungen\n");

// Initialize random number generator srand(time(NULL));

for (n = 1; n <= count; n++) { r = (rand() % 6) + 1; // Generate random number between 1 and 6 d = r - r0; r0 = r;

if (d >= 0) { dp += d; } else { dm -= d; }

s += r; m = s / (long double)n; sa += m - 3.5; Z[r]++;

if (d == 0) { d0++; }

printf("%lld %lld %lld %.6Lf %lld\n", n, r, s, m, llround(sa)); }

r = (count - 1) / 6;

printf("%lld %lld %lld %lld %lld %lld Anzahlen von 1 2 3 4 5 6\n", Z[1], Z[2], Z[3], Z[4], Z[5], Z[6]);

printf("%lld %lld %lld %lld %lld %lld %% Differenzen zum Erwartungswert\n", Z[1] - r, Z[2] - r, Z[3] - r, Z[4] - r, Z[5] - r, Z[6] - r);

printf("%.6Lf %.6Lf %d Summen der pos. und neg. Differenzen und Gleichheiten Z-Z0\n", dp, dm, d0);

return 0; }

-----------

Wenn man aufs ausdrucken der count Zeilen verzichtet laeuft es sogar richtig schnell:

Anzahl Zufallszahl SummeZ Mittelwert Abweichungen

-452 -148 -137 -83 394 430 % Differenzen zum Erwartungswert

Mit count=1000000000 (100*100 Mio) dauert es 4 Minuten:

bash-5.2# date; ./script2 ; date Fri Jun 14 12:19:19 CEST 2024 Anzahl Zufallszahl SummeZ Mittelwert Abweichungen

Man sieht schoen dass die Differenzen wie erwartet etwa 100 mal so gross geworden sind. Wenn man eine Statistik ueber die Differenzen machen will sollte man das ganze aber oefter rechnen, also statt 10Mrd lieber 10000 mal eine Mio.

Nochmal das 100fache waeren mit dann 400Minuten auch kein Problem und an einem Tag machbar.

Selbstverständlich. Ich wäre ja ein Vollidiot, würde ich nicht so wählen. Nur in dieser Shell ist ein random-Spritz-Algorithmus implementiert.

Mindestens 90% der Möglichkeiten dieser Shell sind in keiner anderen Shell vorhanden. Simple Beispiele: [ for Name ] [ from a ] [ by i ] [ to b ] repeat for 5 a b c - e in .....

Es ist schlicht optimal, solch eine kleine Untersuchung per Skript zu implementieren.

Ich wollte doch gezielt den kryptographischen Algorithmus Spritz untersuchen.

ChatGPT hat nachfolgend gewiß nicht mein bloßes Skript übersetzt, ohne weitere Informationen (und Nacharbeiten).

Ich sehe keinen Sinn darin, mehr als 100000 random-Zahlen zu untersuchen. Eigentlich reicht eine Generierung von 10000 Zahlen, um die Qualität zu beurteilen. Genau deshalb habe ich _meine_ Shell, nicht jedoch C, als Werkzeug gewählt.

Aktuelles Skript:

-------------------------------------------------------------------------------------- ARITH_FMT='%.6Lf' set r:025 r0:025 z:025 n:020 e:020 s:025 m:025 m0:025 set sa:025 dp:025 dm:025 d0:025 c61:020 c16:020 c22:020 s=0 m=0.0 m0=-1.0 sa=0.0 d=00 skip=00 i=0000000000 array 1 6 Z $i $i $i $i $i $i

echo Anzahl Zufallszahl SummeZ Mittelwert Abweichungen

for n from 1 to 100000 repeat do let "r= random(6)+1" "d=r-r0" "d>=0" run? "let 'dp+=d'" "let 'dm-=d'" if let "skip==0" then if let "r0==6 && r==1" then let "++c61, skip=1" elif let "r0==1 && r==6" then let "++c16, skip=1" elif let "r0==2 && r==2" then let "++c22, skip=1" fi else skip=0 fi let "s+=r" "m=s/$n.0" "sa+=m-3.5" "++Z[r]" "d==0" && let "++d0" let "r0=r" echo "$n $r $s $m $((llround(sa)))" done

let "r=($n-1)/6" echo "%n$Z1 $Z2 $Z3 $Z4 $Z5 $Z6 " Anzahlen von 1 2 3 4 5 6 echo "$((Z1-r)) $((Z2-r)) $((Z3-r)) $((Z4-r)) $((Z5-r)) $((Z6-r)) " % Differenzen zum Erwartungswert echo "$dp $dm $d0 " Summen der pos. und neg. Differenzen und Gleichheiten Z-Z0 echo "$c61 $c16 $c22 " Anzahlen der Zahlenfolgen 61, 16, 22

--------------------------------------------------------------------------------------

-297 752 166 -541 -4 -72 Differenzen zum Erwartungswert

-41 24 -85 107 1 -2 Differenzen zum Erwartungswert

--------------------------------------------------------------------------------------

Eigentlich schon. Es hatte natuerlich nur die normale rand() funktion fuer die Zufallszahlen verwendet. Nachdem ich das jetzt weiss hat mir chatgpt das Programm entsprechend abgeaendert, ich habe das Programm nicht naeher untersucht:

------- #include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <float.h>

#define N 256

typedef struct { unsigned char S[N]; unsigned char i, j; } RC4Spritz;

void swap(unsigned char *a, unsigned char *b) { unsigned char temp = *a; *a = *b; *b = temp; }

void rc4_spritz_init(RC4Spritz *rc4, const unsigned char *key, size_t key_len) { int i, j; for (i = 0; i < N; i++) { rc4->S[i] = i; } for (i = j = 0; i < N; i++) { j = (j + rc4->S[i] + key[i % key_len]) % N; swap(&rc4->S[i], &rc4->S[j]); } rc4->i = rc4->j = 0; }

unsigned char rc4_spritz_next(RC4Spritz *rc4) { rc4->i = (rc4->i + 1) % N; rc4->j = (rc4->j + rc4->S[rc4->i]) % N; swap(&rc4->S[rc4->i], &rc4->S[rc4->j]); return rc4->S[(rc4->S[rc4->i] + rc4->S[rc4->j]) % N]; }

void rc4_spritz_generate(RC4Spritz *rc4, unsigned char *buffer, size_t len) { for (size_t k = 0; k < len; k++) { buffer[k] = rc4_spritz_next(rc4); } }

int main() { long double ARITH_FMT = 0.0; long long r = 0, r0 = 0, z = 0, n = 0, e = 0, s = 0, m = 0, m0 = 0; long double sa = 0.0, dp = 0.0, dm = 0.0; int d0 = 0, d = 0, i = 0; long long Z[7] = {0}; // Array to store counts of dice rolls from 1 to 6 long long count = 1000000;

printf("Range and Precision of long double on this system:\n"); printf("Minimum positive long double: %Le\n", LDBL_MIN); printf("Maximum positive long double: %Le\n", LDBL_MAX); printf("Precision (decimal digits): %d\n", LDBL_DIG); printf("Smallest increment: %Le\n\n", LDBL_EPSILON);

printf("Anzahl Zufallszahl SummeZ Mittelwert Abweichungen\n");

// RC4 Spritz key setup unsigned char key[] = "mysecretkey"; RC4Spritz rc4; rc4_spritz_init(&rc4, key, strlen((char *)key));

for (n = 1; n <= count; n++) { unsigned char rand_byte; rc4_spritz_generate(&rc4, &rand_byte, 1); r = (rand_byte % 6) + 1; // Generate random number between 1 and 6 d = r - r0; r0 = r;

if (d >= 0) { dp += d; } else { dm -= d; }

s += r; m = s / (long double)n; sa += m - 3.5; Z[r]++;

if (d == 0) { d0++; }

printf("%lld %lld %lld %.6Lf %lld\n", n, r, s, m, llround(sa)); }

r = (count - 1) / 6;

printf("%lld %lld %lld %lld %lld %lld Anzahlen von 1 2 3 4 5 6\n", Z[1], Z[2], Z[3], Z[4], Z[5], Z[6]);

printf("%lld %lld %lld %lld %lld %lld %% Differenzen zum Erwartungswert\n", Z[1] - r, Z[2] - r, Z[3] - r, Z[4] - r, Z[5] - r, Z[6] - r);

printf("%.6Lf %.6Lf %d Summen der pos. und neg. Differenzen und Gleichheiten Z-Z0\n", dp, dm, d0);

return 0; }

-------- Mit auskommentierter Zeile fuer die counts und count=1000000

----- Range and Precision of long double on this system: Minimum positive long double: 3.362103e-4932 Maximum positive long double: 1.189731e+4932 Precision (decimal digits): 18 Smallest increment: 1.084202e-19

Anzahl Zufallszahl SummeZ Mittelwert Abweichungen

-------- Die Differenzen zum Erwartungswert sind aber deutlich hoeher als bei bei der rand() funktion und bei dir, naemlich etwa 1% der Counts.

Mit count=10000000000=10Mrd:

------- Sat Jun 15 12:05:07 CEST 2024 Range and Precision of long double on this system: Minimum positive long double: 3.362103e-4932 Maximum positive long double: 1.189731e+4932 Precision (decimal digits): 18 Smallest increment: 1.084202e-19

Anzahl Zufallszahl SummeZ Mittelwert Abweichungen

------- Dauert also kaum laenger als mit der rand() Funktion. Aber die Differenzen sind viel groesser sie bleiben bei etwa 1% der Anzahlen muessten aber hier um den Faktor 100 kleiner sein als bei 1Mio counts, also 0.01% .

Irgendwie taugt dieser Zufallsgenerator nicht, oder da ist ein Fehler in der Implementierung durch Chatgpt.

Je mehr Zahlen man hat umso kleinere Abweichungen kann man finden, sieht man ja an dem Experiment oben.

Damit es dich daran hindert mehr Zahlen auszuprobieren ?

Man kennt die Implementation des hiesigen 'Spritz' halt nicht.

Ich schätze, der Generator taugt nicht.

------------------------------------------------------------- seed.pid= getpid(); seed.tim= time(NULL); if (b!=3) i-=w; w= wv[(ulong)seed.tim%sizeof(wv)]; for (a=0; a<256; ++a) { i= i+w; j= k+s[j+s[i]&255]; k= i+k+s[j] + ((byte*)&seed)[a]; t= s[i], s[i]=s[j], s[j]=t; z= s[j+s[i+s[z+k&255]&255]&255]; } for (j=i,a=0; a<1024; ++a) { i= i+w; j= k+s[j+s[i]&255]; k= i+k+s[j]; t= s[i], s[i]=s[j], s[j]=t; z= s[j+s[i+s[z+k&255]&255]&255]; } cnt=1600000; f=b; continue;

------------------------------------------------------------- Ich verwende jedenfalls den original 'Spritz'. Die Variablen k, w, wv gibt es im RC4 nicht. Die Änderung gegenüber RC4 ist folglich groß.

Die Abweichungen verschwinden jedoch nicht - jedenfalls nicht mit 6 Nachkommastellen. Und sie haben stets den gleichen Charakter im Verlauf. Folglich sind (viel) mehr random-Zahlen irrelevant.

Ich schrieb bereits in [08.06.2024, 15:32] vom Pendeln um den Mittelwert.

Zu Anfang hatte ich 10 Mio. Zahlen innerhalb von etwa 15 s fertig. Das war voll auskömmlich schnell. Nachdem das Skript stark erweitert wurde, sind 10 Mio. unbequem geworden. Aber 1 Mio. ist immer noch /locker/.

Laß doch mal das aktuelle Skript in C übersetzen. Wegen der neuen Zahlenfolgen.

Helmut Schellong schrieb:

Was ist die letzte Spalte? Die absolute Differenz?

Die kann ja nicht konstant bleiben, da weiter gewürfelt wird. Das ist doch trivial. Warum sieht du das nicht?

Ja, steht ja im Skript eine Beschriftung.

Ich erwarte gar nicht, daß die konstant wird, sondern das Gegenteil. Ich sehe alles. Das ist ja das Pendeln um den erwarteten Mittelwert 3.5, von dem ich seit Tagen rede.

Die Berechnung "s += r" "m = $s.0/$n.0" "sa += m-3.5" ist korrekt. r ist die Zufallszahl Spalte 2, sa sind die akkumulierten Abweichungen Spalte 5, die ja oft zwischen positiv und negativ pendeln. Die Ausgabe: echo "$n $r $s $m $((llround(sa)))"

Es wird vom jeweiligen Mittelwert m der erwartete Mittelwert 3.5 subtrahiert und diese Differenz in sa aufaddiert. Wenn Du Dir eine ganz andere Berechnung für sa vorstellst, mußt Du die auch mal angeben. Ich meine damit einen konkreten mathematischen Ausdruck.

Immerhin ist das ganze doch ein schoenes Beispiel dafuer dass Fehler wie du sie finden wolltest auftreten koennen. Komischerweise verschwindet der Fehler wenn ich rand_byte als integer definiere:

----- unsigned int rand_byte; rc4_spritz_generate(&rc4, &rand_byte, 4);

------

Das ist eine Frage der Menge der Zufallszahlen und der Zahl der Nachkommastellen die du angucken willst.

Wenn die Zufallszahlen gut sind, wird das Pendeln um den Mittelwert bei 100 facher Anzahl um den Faktor 10 kleiner, also um eine Nachkommastelle. Um das zu sehen muss man natuerlich 100 und 10000 mehr Zufallszahlen nehmen koennen.

Das entspricht einem eindimensionalen

Die Ausgabe der Zeile fuer jedes mal wuerfeln macht den groessten Aufwand. Wenn ich die Zufallszahlen in ein File schreiben wollte damit andere sie testen koennen wuerde ich das in binaerer Form tun, also 3 bit pro Zahl (von 1-6), das koennte man in 10 Zahlen pro 4 Byte tun. Dann wuerden 10Mio Zahlen 4Mbyte brauchen. Man koennt auch die Bytes des SPRITZ Algorithmus so ausgeben, das waere dann 1 Byte pro Zahl.

In C koennte man das einfach tun, mit fopen,fwrite,fclose, aber ginge das auch in deinem shell-script ? Ich meine jetzt nicht dass du das machen sollst, sondern es geht mir nur um die Praktikabilitaet soetwas als Shellscript zu programmieren.

Diesmal gibts Fehler beim Kompilieren, durch sich widersprechende doppelte Definitionen von Variablen:

---------------- #include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include <math.h>

#define NUM_ROLLS 100000

int main() { long double ARITH_FMT = 0.000001; int r = 0, r0 = 0, z = 0, n = 0, e = 0, s = 0, m = 0, m0 = 0; int sa = 0, dp = 0, dm = 0, d0 = 0, c61 = 0, c16 = 0, c22 = 0; int Z[7] = {0}; // We use indices 1 to 6 for convenience long long s = 0, skip = 0, i = 0; long double m = 0.0, sa = 0.0;

srand(time(NULL));

printf("Anzahl Zufallszahl SummeZ Mittelwert Abweichungen\n");

for (n = 1; n <= NUM_ROLLS; n++) { r = (rand() % 6) + 1; int d = r - r0; if (d >= 0) { dp += d; } else { dm -= d; } if (skip == 0) { if (r0 == 6 && r == 1) { c61++; skip = 1; } else if (r0 == 1 && r == 6) { c16++; skip = 1; } else if (r0 == 2 && r == 2) { c22++; skip = 1; } } else { skip = 0; }

s += r; m = (long double) s / n; sa += m - 3.5; Z[r]++; if (d == 0) { d0++; } r0 = r;

printf("%d %d %lld %.6Lf %lld\n", n, r, s, m, llround(sa)); }

r = (NUM_ROLLS - 1) / 6; printf("%d %d %d %d %d %d Anzahlen von 1 2 3 4 5 6\n", Z[1], Z[2], Z[3], Z[4], Z[5], Z[6]); printf("%d %d %d %d %d %d %% Differenzen zum Erwartungswert\n", Z[1] - r, Z[2] - r, Z[3] - r, Z[4] - r, Z[5] - r, Z[6] - r); printf("%d %d %d Summen der pos. und neg. Differenzen und Gleichheiten Z-Z0\n", dp, dm, d0); printf("%d %d %d Anzahlen der Zahlenfolgen 61, 16, 22\n", c61, c16, c22);

return 0; }

-----------

------- nscript.c:13:15: error: conflicting types for 's'; have 'long long int' 13 | long long s = 0, skip = 0, i = 0; | ^ nscript.c:10:45: note: previous definition of 's' with type 'int' 10 | int r = 0, r0 = 0, z = 0, n = 0, e = 0, s = 0, m = 0, m0 = 0; | ^ nscript.c:14:17: error: conflicting types for 'm'; have 'long double' 14 | long double m = 0.0, sa = 0.0; | ^ nscript.c:10:52: note: previous definition of 'm' with type 'int' 10 | int r = 0, r0 = 0, z = 0, n = 0, e = 0, s = 0, m = 0, m0 = 0; | ^ nscript.c:14:26: error: conflicting types for 'sa'; have 'long double' 14 | long double m = 0.0, sa = 0.0; | ^~ nscript.c:11:9: note: previous definition of 'sa' with type 'int' 11 | int sa = 0, dp = 0, dm = 0, d0 = 0, c61 = 0, c16 = 0, c22 = 0;

--------

Er interpretiert set sa:025 dass sa eine oktalzahl zugewiesen wird und damit sa als integer. Ein paar Zeilen spaeter wird sa dann 0.0 zugewiesen womit sa eine floatingpoint zahl sein soll...

Ja. Ich habe Spritz vor Jahren mit der NIST-Testsuite getestet, mit positivem Ergebnis. Die verwendet 15 mathematische Verfahren, um Folgen von Zufallszahlen zu testen. Die Chi-square-Methode ist eine davon. Mein random-Skript ist eine simple und daher schnell handhabbare Ergänzung.

Das ist hochgradig seltsam. Du läßt so 4 statt 1 Byte in rand_byte speichern, und die drei oberen Byte werden verworfen. Es wurde also nichts geändert, außer jeweils mehr Aufrufe von rc4_spritz_next(). Wenn diese Maßnahme irgend etwas repariert, so liegt fehlerhafte Programmierung vor.

Es gibt auch keine Leerrunden nach Initialisierung. Außerdem liegt ein Etikettenschwindel vor: Es handelt sich nicht um den Spritz-Algorithmus.

Wird wohl so sein. Jedenfalls nehmen die Frequenz und die Amplitude des Pendelns fortlaufend ab. Sie werden erst im Unendlichen 0. Genau deshalb wird die Anzahl der Zufallszahlen irgendwann extrapolierend irrelevant.

Ja, jedenfalls ist die Ausgabe auf den Bildschirm sehr langsam. Bei Umlenkung rand.bish > random.out ist es vielleicht 20-fach schneller.

Ja, das wird nur mit meiner Shell bish funktionieren.

catv [quelle(n) ...] [=ziel] [[offset,]max,]objekt ... objekt: name|handle [:+-][offset][:+-] [:.]objekt[:.] /konstante /abc%x%255xyz .konstante , ,. ,r Vorstehendes Kommando kann Dateien und Variablen lesen und schreiben und Konstanten lesen und konvertieren. Es können beliebig viele Variablen und Dateien, mit jeweils Offset und Anzahl Byte, und Konstanten gemischt verkettet in ein beliebiges Ziel ebenfalls mit Offset und Anzahl geschrieben werden.

Mittels set sa:025 wird die Variable sa erzeugt und mit 25 Ziffern '0' initialisiert. Mittels set sa:.25 wird die Variable sa erzeugt und mit 25 Zeichen '.' initialisiert. Mittels set sa:46.25 wird die Variable sa erzeugt und mit 25 Zeichen '.' initialisiert. Mittels set sa:0.25000000 wird die Variable sa erzeugt und mit 25 Mio. 0-Byte initialisiert.

Variablen in einer Shell haben keinen Typ. Standardmäßig enthalten sie Zeichenketten. sa:025 erzeugt Variable sa und initialisiert mit 25 '0'-Ziffern. Danach wird 0.0 zugewiesen, um ihr den Gleitkommatyp zuzuordnen. Nach 0.0 sind nur die 3 Zeichen 0.0 enthalten, jedoch 22 weitere Byte reserviert.

Eigentlich nimmt die absolute Amplitude zu mit Wurzel(Anzahl). Was abnimmt ist die relative Amplitude als Wurzel(Anzahl)/Anzahl.

Die absolute Amplitude wird auch im Unendlichen Unendlich...

Er muesste also die Zahlen die bei dir ja Dezimalszahlen als Strings sind, erst mal in Binaerzahlen als Bytes umwandeln und die dann in eine Datei schreiben...

sa ist also eigentlich ein string, das ist fuer eine shell-Varible auch vernuenftig weil es der normale Einsatzzweck ist, z.B. der Library search path...

Zum Rechnen ist es eher unguenstig, weil bei jeder Rechnung die Strings erst mal in Zahlen konvertiert werden muessen, und danach wieder zurueck in Strings.

Haette ja sein koennen dass das bei deiner Shell anders ist.

D.h. es ist eigentlich ein String der Laenge 22 in dem "0.0" steht. In C dagegen macht chatgtp daraus eine "long double" . Auf einem Intel oder Amd PC ist das eine 10byte floating-point Zahl, mit 63 bit Fraction und 15 Bit exponent,das groesste was es auf diesen Prozessoren gibt.

Aufrund welcher Überlegung? Bereits Mittelschulstatistik weist doch darauf hin, dass die Streuung mit SQRT(N) abnimmt und daher nach 100x Proben eine Stelle mehr angegeben werden muss.

Offensichtlich nicht. Die Abweichung ist bei gerader Versuchsnummer eine Ganzzahl und bei ungerader Versuchsnummer was mit ,5. Von Wurf zu Wurf ändert die Abweichung um durchschnittlich etwa 1.5 oder so, in der Tabelle reagiert sie nur trantütig[tm].

Es war schon im ersten Anlauf methodisch falsch

Dort ist es auch nicht besser. Die Abweichung Totale_Augenzahl - Wurfnummer * 3.5 (oder wie rum man es definieren mag, die Sitten divergieren) ist immer noch Schrott.

Ich rede in der Regel stets von den Zahlenfolgen, wie vorstehend. Es ist unübersehbar, daß der Mittelwert um den Erwartungswert 3.500000 pendelt. Es resultieren positive und negative Differenzen. Deshalb pendelt die aufaddierte Summe der Differenzen zwischen positiv und negativ. So starke Abweichungen wie zu Beginn gibt es bei späteren Zeilen nicht mehr. Und zwar nie, weil die Differenzen immer kleiner werden - sie gehen gegen Null. Auch die Pendelfrequenz geht deshalb gegen Null. Es ist erkennbar, daß sich die dritte und vierte Nachkommastelle MW unten fast nicht mehr ändern.

typeset [ -+i[4|8]ISfF{s[obase]|obase} ] [Name[=wert]]... Dieses Kommando ist in Verbindung mit arithmetischen Ausdrücken besonders interessant. Option -f markiert Gleitkomma-Variablen als binär-float. Option -i markiert Variablen als binär-integer. Sie werden solchermaßen besetzt binär gespeichert und nicht als dezimale ascii-Zeichenkette. ... ...

Die Umwandlungsfunktionen wie z.B. atoi() und itoa() sind ultraschnell implementiert. Sind in meinen C-Büchern.

Prinzipiell ja, ich hatte nach Einführung von Gleitkomma darüber gegrübelt. Du hast aber sicher keine entsprechenden Deklarationen bei den Variablen gesehen. Eben weil ich das nicht implementierte. Der Gleitkommatyp ist nur am Inhalt erkennbar: Ist ein '.' oder 'e' vorhanden? Der Arithmetik-Modul muß solches ja erkennen! Es ist auch Ausgabe per 10^3 10^6 10^9 10^12 konfigurierbar - eine Engineer-Ausgabe.

Länge 25. 3 + 22 undefinierte Byte.

Ich hatte mal mit long double == 128 Bit auf HP-HW gearbeitet.

Das aktuelle Skript wird langsam professioneller. Bei den Neuigkeiten sind weitere Besonderheiten/Alleinstellungsmerkmale erkennbar: . expr "$cnt" :: '[^0-9]' . do c$r$e=$i; c$r$e=0; done . do s=c$r$e; echo $r$e:${{s}} %c; done

Aktuelles Skript:

----------------------------------------------------------------------------------- set cnt:020 [ $# -ge 1 ] && cnt="$1" expr "$cnt" :: '[^0-9]' && cnt=10000 [ "$cnt" -lt 1 ] && cnt=10000

ARITH_FMT='%.6Lf' set r:025 r0:025 n:020 e:020 s:025 m:025 m0:025 set sa:025 dp:025 dm:025 d0:025 s=0 m=0.0 m0=-1.0 sa=0.0 d=00 skip=1 i=0000000000 array 1 6 Z $i $i $i $i $i $i

for r in 1 2 3 4 5 6 do for e in 1 2 3 4 5 6 do c$r$e=$i; c$r$e=0; done done

echo Anzahl Zufallszahl SummeZz Mittelwert AbweichungenMw

for n from 1 to $cnt repeat do let "r= random(6)+1" "d=r-r0" "d>=0" run? "let 'dp+=d'" "let 'dm-=d'" if [ skip -le 0 ] then let "++c$r0$r, skip=1" else skip=0 fi let "s+=r" "m=$s.0/$n.0" "sa+=m-3.5" "++Z[r], r0=r" "d==0" && let "++d0" echo "$n $r $s $m $((llround(sa)))" done

let "r=($n-1)/6" echo "%n$Z1 $Z2 $Z3 $Z4 $Z5 $Z6 " Anzahlen von 1 2 3 4 5 6 echo "$((Z1-r)) $((Z2-r)) $((Z3-r)) $((Z4-r)) $((Z5-r)) $((Z6-r)) " % Differenzen zum Erwartungswert echo "$dp $dm $d0 " Summen der pos. und neg. Differenzen und Gleichheiten Z-Z0 echo "Anzahlen der 36 Zahlenfolgen 11 .. 25 .. 66:" for r in 1 2 3 4 5 6 do for e in 1 2 3 4 5 6 do s=c$r$e; echo $r$e:${{s}} %c; done echo done

-----------------------------------------------------------------------------------

16623 16560 16740 16655 16723 16699 Anzahlen von 1 2 3 4 5 6

-43 -106 74 -11 57 33 Differenzen zum Erwartungswert

-----------------------------------------------------------------------------------

Helmut Schellong schrieb:

Ich schlug vor, die absolute Abweichung in Augenzahl anzugeben, also a = s - n * 3.5 da das die statistisch interessante Zahl ist, und keinesfalls die Resultate einer Division zu summieren. Da häufen sich nur Rundungsfehler an; das ist numerisch nicht stabil.

Wir kommen hier nicht zusammen. Ich weiß nicht was Du willst und was Du meinst. Ich finde das Skript schon im aktuellen Zustand sehr hilfreich und lasse es konzeptionell so. Alle Tabellenwerte finde ich optimal hilfreich.

Ich hatte schon beim ersten Posting den Verdacht, daß Du bei der letzten Spalte das Schwanken zwischen positiv und negativ übersiehst. Wegen ca. 750 statt 950. Die Differenz entsteht wegen negativer Werte - kein Fehler, kein Schrott, sondern ganz normal.

Den Ausdruck verstehe ich sofort. "sa += m-3.5" " a = s-n*3.5" Ich sehe vorstehend ein Mißverständnis mit dem /Aufaddieren/.

Rundungsfehler empfinde ich hier als vernachlässigbar, weil diese sich regelmäßig erst nach der 16. signifikanten Stelle zeigen.

------------------------------------------------------------------------------ PS G:\tmp\Helmut\bish> bish32x.exe rand.bish 5 bish: Oeffnen fehlgeschlagen bei Datei: 'rand.bish'

PS G:\tmp\Helmut\bish> cmd.exe Microsoft Windows [Version 10.0.22631.3737] (c) Microsoft Corporation. Alle Rechte vorbehalten.

G:\tmp\Helmut\bish>bish32x.exe rand.bish 5 Anzahl Zufallszahl SummeZz Mittelwert AbweichungenMw AbweichungSummeZ

2 1 2 0000000000 0000000000 0000000000 Anzahlen von 1 2 3 4 5 6

------------------------------------------------------------------------------ Ganz oben in der PowerShell 'PS ' werden Dateiöffnungsversuche der bish32x.exe abgewiesen. Im Kommandointerpreter 'cmd' klappt dies dann - wie seit Jahrzehnten.

Die Fehlermeldung stammt von der bish32x. Folglich wird die bish32x als gültige Executable erkannt und gestartet. Warum die Exe in der PS keine Dateien öffnen darf, ist mir unbekannt.

Die totale Abweichung waere s-3.5*n, also die Abweichung der Summe der Wuerfelergebnisse vom Erwartungswert. Was bei dir in der letzten Spalte steht, ist die Summe ueber die totalen Abweichungen dividiert durch n, gerundet auf ganze Zahlen, damit man ihre Aenderung nicht mehr sieht... Aber was bedeutet diese Zahl ueberhaupt ? Warum wird nochmal summiert ?

Der Punkt ist das was dort steht nicht die totale Abweichung ist, die veraendert sich mit jedem mal Wuerfeln um 0.5 bis 1.5 wuerde also auch gerundet nicht ueber mehrere Wuerfe konstant bleiben.

Dann hat man einen Sprung zwischen x<0 und x=0. Das ist bei den Kurven fuer k>2 aber nicht der Fall die sind alle 0 bei x=0 und steigen mit x>0 stetig an ohne Sprung.

Und sie schreibt auch genau wie:

------ Sind Z1 , Z2 . . . , Zn unabhängige und standardnormalverteilte Zufallsvariablen, so ist die Chi-Quadrat-Verteilung mit n Freiheitsgraden definiert als die Verteilung der Summe Z1^2 + ... + Zn^2 der quadrierten Zufallsvariablen.

------ Das bedeutet aber nicht dass deswegen die Verteilungsfunktion aussieht wie eine Normalverteilung.

Das findet man garantiert auch irgendwo im Netz. Den online Rechner um die Werte zu berechnen haben ich ja schon gepostet. Es gibt auch Tabellen, z.B.

Diese Zahl bedeutet: sa += m-3.5 Summe der fortlaufenden Abweichungen vom Mittelwert. Das ist seit längerem im Skript enthalten, nach [10.06.2024, 22:22].

Der Text, auf den Du vorstehend antwortest, ist seit gestern überholt. Der Rolf hat mir gestern danach einen mathematischen Ausdruck geantwortet, wie ich ihn wünschte. Und diesen habe ich nach 3 Sekunden voll begriffen.

--------------------------------------------------------------------------------------- Eine interessante Spalte wären die absoluten Abweichungen gewesen. Gut, kann man ausrechnen aus (LetzteSpalte - 3.5) * ErsteSpalte.

Gut zu erkennen (auch so) ist, dass Nulldurchgänge (oder hier '3.5'-Durchgänge) nur am Anfang häufig sind und dann nach einigen Hundert Durchgängen extrem selten werden. Etwas störend für mich ist der Bereich ca. 600-800, wo die kumulierte Abweichung fast -100 erreicht. Wichtig wäre zu erkennen, dass die kumulierte Abweichung bei hinreichend vielen Würfen beliebig gross werden kann, das 'übersehen' viele Leute, die immer mit dem Gesetz der grossen Zahl ankommen, ohne es verstanden zu haben.

Ich empfehle, das mal bis zu deutlich höheren Anzahlen zu verfolgen. Aber bitte nicht die Tabelle hier posten, danke.

--------------------------------------------------------------------------------------- Ich hatte Vorstehendes falsch verstanden und daraufhin sa += m-3.5 implementiert. Gestern implementierte ich a = s - n*3.5 zusätzlich (Ausdruck von Rolf). Der Ausdruck "(LetzteSpalte - 3.5) * ErsteSpalte" stimmt damit nicht überein! Auch deshalb mein Mißverständnis.

Rolf kannte nicht die Bedeutung der damals letzten Spalte, bezog sich aber darauf. Deshalb wurde ich noch mehr verwirrt und erbat einen mathematischen Ausdruck.

Das Gesetz der großen Zahlen kannte ich schon in den 1970ern, weil ich schon damals den Christiani-Technikerkalender hatte, in dem ein Würfel-Graph abgebildet ist. Zum progr. Taschenrechner TI59 habe ich damals auch einen Statistik-Software-Modul gehabt. Ich habe das alles heute noch. Auch die Handbücher zum TI59 und dessen Modulen.

Wenn hier die erste Zufallszahl ausgegeben wird, so hat diese die gleiche Wahrscheinlichkeit gehabt wie die anderen 5 möglichen Zahlen. Ist sie 6, ist der Mittelwert s/n = 6/1 = 6. Von diesem zu hohen Mittelwert muß der Weg allmählich Richtung 3.5 gehen. Der Mittelwert muß nicht um 3.5 herum pendeln, sein Wert muß aber auf und ab gehen. Diese Amplitude wird zwangsläufig fortlaufend geringer, weil die aufaddierten einzelnen Zufallszahlen gegenüber ihrer Summe stetig kleiner werden. Das ist ein rein mathematischer Effekt.