nicht angemeldet
Gunnar Bittersmann
Der Martin
Gunnar Bittersmann
Gunnar Bittersmann
Der Martin
Gunnar Bittersmann
Gunnar Bittersmann
MudGuard
Hi!
Ich möchte eine positive 24bit Zufallszahl generieren. Dazu habe ich mir folgende Funktion geschrieben:
int createRandom24()
{
unsigned random24 = 1;
for(int i = 0; i < 23; i++)
{
random24 = (random24 * 10) + (rand() % 2);
}
return random24;
}
srand() wird in der main()-Funktion aufgerufen.
Ich erstelle mir also eine Bitfolge und stelle mit der 1 am Anfang sicher, dass sie auch garantiert eine 24bit Zahl darstellt.
Jetzt ist die Frage ob diese Funktion so sinnvoll ist und "wie zufällig" die Zufallszahlen sind? Folgt die Funktion dem Prinzip großer Zahlen und ist sie auch in solchen Fällen anwendbar wo eine Zufallsfunktion eine wichtige Rolle spielt?
Grüße
@@Nick:
nuqneH
Ich möchte eine positive 24bit Zufallszahl generieren. Dazu habe ich mir folgende Funktion geschrieben:
Wenn du _eine_ Zufallszahl möchtest, ist es unsinnig, das mit einer Schleife zu tun, die 24 Mal läuft.
int createRandom24()
{
unsigned random24 = 1;for(int i = 0; i < 23; i++)
{
random24 = (random24 * 10) + (rand() % 2);
}
return random24;
}
Wieso `\* 10`?
> Ich erstelle mir also eine Bitfolge und stelle mit der 1 am Anfang sicher, dass sie auch garantiert eine 24bit Zahl darstellt.
Wieso läuft die Schleife 24 Mal, wenn du vorn eine 1 und dann 23 Stellen haben möchtest?
Du möchtest eine Zufallszahl im Bereich 2²³ bis 2²⁴ − 1?
`random24 = rand() * 2^23 + 2^23;`{:.language-c}
siehe [C++ Reference](http://www.cplusplus.com/reference/cstdlib/rand/)
Dazu muss RAND\_MAX natürlich mindestens 2²³ sein.
Ansonsten kannst du `rand()`{:.language-c} zweimal aufrufen. Aber nicht 24 Mal.
Qapla'
--
„Talente finden Lösungen, Genies entdecken Probleme.“ (Hans Krailsheimer)
Hi Gunnar!
Wenn du _eine_ Zufallszahl möchtest, ist es unsinnig, das mit einer Schleife zu tun, die 24 Mal läuft.
Sie läuft 23 mal oder was habe ich übersehen?
Wieso
\* 10?
Damit ich die Bitkette erweitern kann und die nächste 0 o. 1 nicht auf die letzte 0 o. 1 addiert wird.
Wieso läuft die Schleife 24 Mal, wenn du vorn eine 1 und dann 23 Stellen haben möchtest?
Siehe oben.
Du möchtest eine Zufallszahl im Bereich 2²³ bis 2²⁴ − 1?
random24 = rand() * 2^23 + 2^23;siehe C++ Reference
Dazu muss RAND_MAX natürlich mindestens 2²³ sein.
Herzlichen Dank!
Ansonsten kannst du
rand()zweimal aufrufen. Aber nicht 24 Mal.
Ändert das nichts an der Verteilung? Wie schon gesagt, meine Idee war halt eine zufällige 24-Bit-Kette anstatt der Zahl selbst zu generieren.
Danke für deine Hilfe!
Hallo,
Wieso
\* 10?Damit ich die Bitkette erweitern kann und die nächste 0 o. 1 nicht auf die letzte 0 o. 1 addiert wird.
mit welcher Basis arbeitest du denn grade?
Gruß
Kalk
Hi Kalk!
mit welcher Basis arbeitest du denn grade?
Ähm ja, binär mit 2.
Das Brett vorm Kopf lässt grüßen :/
Grüße
random24 = rand() * 2^23 + 2^23;
Kann es sein, dass dir ein Fehler passiert ist? Müsste es laut der Reference nicht
random24 = rand() % (2^24 -1) + 2^23
sein?
Dein Beispiel gibt mir wesentlich kleinere Zahlen als 8388608 (die kleinste 24bit Zahl). Oder habe ich etwas falsch verstanden? Müsste eine 24bit Zahl nicht zwischen 8388608 und 16777215 liegen? Binär also zwischen 1000 0000 0000 0000 0000 0000 und 1111 1111 1111 1111 1111 1111?
Hallo,
random24 = rand() * 2^23 + 2^23;
Kann es sein, dass dir ein Fehler passiert ist?
oder vielleicht dir beim Interpretieren?
Möglicherweise hast du übersehen, dass der Operator ^ in C/C++ nicht für Potenzierung steht, sondern für bitweises XOR, und dass die Formel, so wie Gunnar sie hingeschrieben hat, nur abstrakt gemeint war? Und hast du vielleicht auch übersehen, dass rand() einen Wert vom Typ float oder double im Intervall [0.0, 1.0[ liefert?
Ach, und bevor du 2^23 tatsächlich durch Potenzieren bildest: Zweierpotenzen notiert man am effizientesten per Bit-Shift, also hier z.B. (1<<23). Oder man schreibt's direkt als ausgerechnete Konstante hin, aber dann ist meist nicht so klar erkennbar, was man meint.
So long,
Martin
Hallo,
random24 = rand() * 2^23 + 2^23;
Kann es sein, dass dir ein Fehler passiert ist?oder vielleicht dir beim Interpretieren?
Ah, ok. die Reference sagt
„A typical way to generate trivial pseudo-random numbers in a determined range using rand is to use the modulo of the returned value by the range span and add the initial value of the range:“
v2 = rand() % 100 + 1; // v2 in the range 1 to 100
v3 = rand() % 30 + 1985; // v3 in the range 1985-2014
Also müsste es so sein?
random24 = rand() % 2<<23 + 2<<24 - 1
Möglicherweise hast du übersehen, dass der Operator ^ in C/C++ nicht für Potenzierung steht, sondern für bitweises XOR,
Ja, das wusste ich nicht. Bedeutet das, dass 2^23 zu 26 (11010) wird?
und dass die Formel, so wie Gunnar sie hingeschrieben hat, nur abstrakt gemeint war?
Oh, sie war in Code-Tags gefasst. Daher nahm ich an, dass es auch Code ist.
Und hast du vielleicht auch übersehen, dass rand() einen Wert vom Typ float oder double im Intervall [0.0, 1.0[ liefert?
Laut Reference sollte es ein Integer sein?!
Ach, und bevor du 2^23 tatsächlich durch Potenzieren bildest: Zweierpotenzen notiert man am effizientesten per Bit-Shift, also hier z.B. (1<<23). Oder man schreibt's direkt als ausgerechnete Konstante hin, aber dann ist meist nicht so klar erkennbar, was man meint.
Danke für die Erklärung! Siehe oben.
Grüße
@@Nick:
nuqneH
Also müsste es so sein?
random24 = rand() % 2<<23 + 2<<24 - 1
Nein. Wenn du 2²³ haben willst, musst du 1 23 Stellen nach links schieben, nicht 2. (Oder 2 22 Stellen.)
Wenn 2²³ die kleinste Zahl ist, die deine Zufallszahl annehmen kann, dann musst du eben 2²³ addieren. (Der kleinste Wert von rand() % x ist ja 0.)
Qapla'
Hi Gunnar!
Nein. Wenn du 2²³ haben willst, musst du 1 23 Stellen nach links schieben, nicht 2. (Oder 2 22 Stellen.)
Wenn 2²³ die kleinste Zahl ist, die deine Zufallszahl annehmen kann, dann musst du eben 2²³ addieren. (Der kleinste Wert von rand() % x ist ja 0.)
Mh, jetzt verstehe ich gar nichts mehr.
Jetzt habe ich versucht eine Zahl zwischen 24bit und 32bit zu erzeugen aber der Wert ist immer 16777216.
Der Code sieht so aus
unsigned r;
r = rand() % (1<<32) + (1<<24);
Das sollte doch eigentlich nichts anderes sein als das Beispiel der Referenz mit
v2 = rand() % 100 + 1; // v2 in the range 1 to 100
Was mache ich falsch?
@@Nick:
nuqneH
Jetzt habe ich versucht eine Zahl zwischen 24bit und 32bit zu erzeugen aber der Wert ist immer 16777216.
Der Code sieht so aus
unsigned r;
r = rand() % (1<<32) + (1<<24);
Das läuft auf einem 32-Bit-System? Was ist dann 1<<32? Was x % (1<<32)?
Qapla'
--
„Talente finden Lösungen, Genies entdecken Probleme.“ (Hans Krailsheimer)
Hi Gunnar!
Das läuft auf einem 32-Bit-System?
Ja. Win7 32Bit.
Was ist dann 1<<32? Was x % (1<<32)?
Der Compiler sagt >= width of type bzw. Division durch 0. Nicht gut. Aber wieso kann ich die 32Bit nicht adressieren auf einem 32Bit-System? Dann halt 1<<31 :)
Ok, ich habe es geändert zu
r = rand() % (1<<31) + (1<<24);
Das gibt mir sehr viele Werte im Bereich 167xxxxx bis 168xxxxx - meist mit 167 am Anfang. Aber nach 100 Durchläufen kam noch keine Zahl mit mehr Stellen oder in einem anderen Bereich :(
Irgend etwas mache ich wohl leider immernoch falsch.
@@Nick:
nuqneH
Aber wieso kann ich die 32Bit nicht adressieren auf einem 32Bit-System?
Wie willst du 2³² (eine 1 mit 32 Nullen) mit 32 Bit darstellen?
Ok, ich habe es geändert zu
r = rand() % (1<<31) + (1<<24);Das gibt mir sehr viele Werte im Bereich 167xxxxx bis 168xxxxx - meist mit 167 am Anfang. Aber nach 100 Durchläufen kam noch keine Zahl mit mehr Stellen oder in einem anderen Bereich :(
Du hast ein x vergessen? Das wäre dann 2²⁴ + ein bisschen. Da scheint rand() % (1<<31) nicht wie erwartet eine Zufallszahl aus dem Bereich [0, 2³¹[ zu liefern. Da sollte dein Debugging ansetzen.
BTW sind weder 2²⁴ noch 2³¹ das, was du ursprünglich wolltest.
Qapla'
Guten Morgen Gunnar!
Wie willst du 2³² (eine 1 mit 32 Nullen) mit 32 Bit darstellen?
Achso ja. Ich habe es verstanden.
Das gibt mir sehr viele Werte im Bereich 167xxxxx bis 168xxxxx - meist mit 167 am Anfang. Aber nach 100 Durchläufen kam noch keine Zahl mit mehr Stellen oder in einem anderen Bereich :(
Du hast ein x vergessen? Das wäre dann 2²⁴ + ein bisschen. Da scheint rand() % (1<<31) nicht wie erwartet eine Zufallszahl aus dem Bereich [0, 2³¹[ zu liefern. Da sollte dein Debugging ansetzen.
Nein, ich habe kein x vergessen. Und ja, das scheinen nur Zahlen bis 25bit zu sein (wenn ich mich nicht irre :D). Ich weiß allerdings nicht wie bzw. wo ich da mit debuggen ansetzen sollte. Es ist ja nur 1 Funktionsaufruf. Es tut nicht was ich erwartet hätte aber ich weiß auch nicht wo der Fehler liegt. Siehe:
Ok, ich habe es geändert zu
r = rand() % (1<<31) + (1<<24);
Das sollte doch eigentlich nichts anderes sein als das Beispiel der Referenz mit
v2 = rand() % 100 + 1; // v2 in the range 1 to 100
BTW sind weder 2²⁴ noch 2³¹ das, was du ursprünglich wolltest.
Ja, ich schrieb doch, dass ich die Problemstellung geändert habe:
Jetzt habe ich versucht eine Zahl zwischen 24bit und 32bit zu erzeugen...
Oder habe ich dich falsch verstanden?
Grüße
@@Nick:
nuqneH
Ja, ich schrieb doch, dass ich die Problemstellung geändert habe:
Jetzt habe ich versucht eine Zahl zwischen 24bit und 32bit zu erzeugen...
Du meinst eine aus dem Intervall [2²³, 2³²[?
Dann ist modulo (%) 2³¹ ebenso falsch wie es 2³² wäre. Es muss modulo 2³² − 2²³ sein.
Das heißt, du erzeugst eine Zufallszahl aus [0, 2³² − 2²³[ und addierst dann 2²³.
Nur dass das auf einem 32-Bit-System kaum gehen dürfte; rand() % (-(1<<23)) liefert wohl keine brauchbaren Zufallszahlen.
Qapla'
Hi Gunnar!
Zunächst einmal danke für deine Erklärung!
Nur dass das auf einem 32-Bit-System kaum gehen dürfte; rand() % (-(1<<23)) liefert wohl keine brauchbaren Zufallszahlen.
Weil der Bereich zu klein definiert ist? Würde sich das denn auf einem z.B. 64Bit-System ändern?
Hast du einen Hinweis wie andere Lösungen dabei verfahren? Immerhin gibt es ja bereits Programme die einen Schlüsselaustausch vornehmen. Der DSA verlangt z.B. min. 1024 Bits für den Primmodulus.
Grüße
Hi,
oder vielleicht dir beim Interpretieren?
Ah, ok. die Reference sagt
„A typical way to generate trivial pseudo-random numbers in a determined range using rand is to use the modulo of the returned value by the range span and add the initial value of the range:“
v2 = rand() % 100 + 1; // v2 in the range 1 to 100
v3 = rand() % 30 + 1985; // v3 in the range 1985-2014
ja, stimmt. Ich hatte das wohl mit Math.random() in JS verwechselt.
> Also müsste es so sein?
> `random24 = rand() % 2<<23 + 2<<24 - 1`{:.language-c}
Fast. Die Untergrenze deines gewünschten Bereichs ist aber nicht 2^24, sondern 2^23.
> > Möglicherweise hast du übersehen, dass der Operator ^ in C/C++ nicht für Potenzierung steht, sondern für bitweises XOR,
> Ja, das wusste ich nicht. Bedeutet das, dass 2^23 zu 26 (11010) wird?
Nein, `2^23`{:.language-c} wird in C zu 21:
0000 0010
xor 0001 0111
-------------
0001 0101 (21)
> > Und hast du vielleicht auch übersehen, dass rand() einen Wert vom Typ float oder double im Intervall [0.0, 1.0[ liefert?
> Laut [Reference](http://www.cplusplus.com/reference/cstdlib/rand/) sollte es ein Integer sein?!
Siehe oben, da war \_ich\_ schief gewickelt.
Ciao,
Martin
--
Nicht jeder, der aus dem Rahmen fällt, war vorher im Bilde.
Selfcode: fo:) ch:{ rl:| br:< n4:( ie:| mo:| va:) de:] zu:) fl:{ ss:) ls:µ js:(
@@Der Martin:
nuqneH
Möglicherweise hast du übersehen, dass der Operator ^ in C/C++ nicht für Potenzierung steht, sondern für bitweises XOR, und dass die Formel, so wie Gunnar sie hingeschrieben hat, nur abstrakt gemeint war?
Meine C++-Kenntnisse haben schon eine Staubschicht angesetzt. Ist schon ein paar Jährchen her …
Und hast du vielleicht auch übersehen, dass rand() einen Wert vom Typ float oder double im Intervall [0.0, 1.0[ liefert?
Tut es das? Die C++ Reference sagt anderes.
Qapla'
Hi!
Ich möchte eine positive 24bit Zufallszahl generieren.
Also das ist schon etwas sehr proprietär ;)
Üblich sind 8,16,32,64 Bit. Idee: Operiere mit den üblichen Standards und ziehe Dir ggf. den 24bit-Anteil aus einem 32bit-Integer.
Schöne Grüße.
Hi hotti!
Ich möchte eine positive 24bit Zufallszahl generieren.
Also das ist schon etwas sehr proprietär ;)
Üblich sind 8,16,32,64 Bit. Idee: Operiere mit den üblichen Standards und ziehe Dir ggf. den 24bit-Anteil aus einem 32bit-Integer.
In der Praxis geht es mir (nur zu Übungszwecken und zum Verständnis!) um die Umsetzung des DSA-Standards (Seite 27 der PDF).
Ich möchte mir zunächst ausgehend von einer Zufallszahl eine hohe Primzahl generieren. Ich stehe also direkt am Anfang schon vor einem Problem das ich alleine nicht lösen kann.
Grüße
@@Nick:
nuqneH
Ich möchte mir zunächst ausgehend von einer Zufallszahl eine hohe Primzahl generieren.
?? Wie soll das gehen?
Qapla'
Hi Gunnar!
?? Wie soll das gehen?
Ich nehme eine Zufallszahl und zähle von der aus weiter bis ich eine Primzahl treffe.
Aber da frage ich direkt zurück was du mir vorschlagen würdest wie es stattdesssen gehen könnte oder sollte?
Grüße
@@Nick:
nuqneH
Ich nehme eine Zufallszahl und zähle von der aus weiter bis ich eine Primzahl treffe.
Wie effizient das ist, hat Tabellenkalk schon angedeutet. Wobei es „Jahre“ eher trifft als „Sekunden“.
Qapla'
Man muss gar nicht so sehr lange suchen bis man von einer Primzahl aus zur nächsten kommt. Die Kunst ist rauszufinden wann man eine gefunden hat.
Da gibts schon einen Algorithmus, der bei asymmetrischer Verschlüsselung eingesetzt wird.
Hi Encoder!
Man muss gar nicht so sehr lange suchen bis man von einer Primzahl aus zur nächsten kommt. Die Kunst ist rauszufinden wann man eine gefunden hat.
Da gibts schon einen Algorithmus, der bei asymmetrischer Verschlüsselung eingesetzt wird.
Könntest du mir dazu bitte etwas mehr erzählen? Oder wo kann ich mehr Informationen dazu finden?
Grüße
Hallo,
?? Wie soll das gehen?
das ist doch einfach: du addierst/subtrahierst in einer do-loop-Schleife solange 1 bis der Test auf Primalität true ergibt.
Je nach Rechner müsste man dann halt mal 2-3 Sekunden/Jahre warten...
Gruß
Kalk
Hi Kalk!
das ist doch einfach: du addierst/subtrahierst in einer do-loop-Schleife solange 1 bis der Test auf Primalität true ergibt.
Warum so umständlich? Alle geraden Zahlen und die mit 5 und 0 am Ende fallen ja schonmal raus. Mit verschiedenen Tests kann man weitere Zahlen ausschließen. Ich will damit sagen, dass man nicht jede Zahl prüfen müsste und mit ein paar wenigen Sekunden für die Berechnung der übrigen Zahlen + Prüfung könnte ich leben.
Siehe die Antwort von Encoder. Wie sieht der Algorithmus aus bzw. wie wird das in der Praxis umgesetzt?
Grüße
@@Nick:
nuqneH
Warum so umständlich? Alle geraden Zahlen und die mit 5 und 0 am Ende fallen ja schonmal raus. Mit verschiedenen Tests kann man weitere Zahlen ausschließen. Ich will damit sagen, dass man nicht jede Zahl prüfen müsste und mit ein paar wenigen Sekunden für die Berechnung der übrigen Zahlen + Prüfung könnte ich leben.
Es sind eher ein paar wenige Sekunden für die Berechnung der nächsten Zahl (Einzahl!) + Prüfung. Und die addieren sich auf … Selbst wenn du die geraden Zahlen und die mit 5 am Ende rausimmst.
Sinnvoller dürfte es sein, sich vorher eine Liste von Primzahlen im gewünschten Bereich zu erstellen (bzw. nach einer solchen schon existierenden zu suchen) und dann per Zufall (über den Index) eine von diesen auszuwählen.
Qapla'
hi,
Ich möchte mir zunächst ausgehend von einer Zufallszahl eine hohe Primzahl generieren. Ich stehe also direkt am Anfang schon vor einem Problem das ich alleine nicht lösen kann.
Es gibt keinen Algorithmus, der für _große_ Primzahlen tauglich ist. Das Problem, große Primzahlen in akzeptablen Zeiten zu erzeugen besteht weltweit. Damit befassen sich Heerscharen vom Mathematikern und nicht erst seit Diffie/Hellmann.
Nichtsdestoweniger kannst Du Dich mit dem Thema befassen, da will ich Dir nicht den Mut nehmen. Auch wenn Du die Formel zur Goldherstellung nicht findest, das Ergebnis kann auch eine Lizenz zum Gelddrucken sein.
Viel Erfolg ;)
Hi hotti!
Nichtsdestoweniger kannst Du Dich mit dem Thema befassen, da will ich Dir nicht den Mut nehmen. Auch wenn Du die Formel zur Goldherstellung nicht findest, das Ergebnis kann auch eine Lizenz zum Gelddrucken sein.
Danke für deine aufmunternden Worte! Leider besteht aber immernoch auch das Problem das ich mit rand() nicht lösen konnte :D
Grüße
Hi,
Auch wenn Du die Formel zur Goldherstellung nicht findest, das Ergebnis kann auch eine Lizenz zum Gelddrucken sein.
Eher nicht. Das Verfahren zur Umwandlung von Blei in Gold ist bekannt, und es ist eher eine Lizenz zum Geldvernichten. Die Kosten sind extrem hoch, im Bereich von Milliarden (oder waren es Billiarden) pro Gramm Gold. Beim aktuellen Goldpreis von weniger als 40 Euro pro Gramm ist das nicht wirklich wirtschaftlich ...
cu,
Andreas
Hakuna matata!
Folgt die Funktion dem Prinzip großer Zahlen und ist sie auch in solchen Fällen anwendbar wo eine Zufallsfunktion eine wichtige Rolle spielt?
Hier geht es offenbar um Verschlüsselung, oder? rand() liefert "nur" Pseudo-Zufallszahlen und ist daher für bestimmte Anwendungsfälle, zum Beispiel die Schlüsselgenerierung, ungeeignet. In solchen Fällen verlangt man von Zufallszahlen, dass sie von irgendwelchen Umgebungsrauschen beeinflusst werden. In C++ gibt es dafür die random_device-Klasse.
Hi 1UnitedPower!
Hier geht es offenbar um Verschlüsselung, oder?
Naja eher am Rande. Der Schlüsselaustausch stellt ja "nur" die Integrität der Nachrichten sicher. Die Verschlüsselung der Nachrichten selbst unterliegt anderen Verfahren.
rand() liefert "nur" Pseudo-Zufallszahlen und ist daher für bestimmte Anwendungsfälle, zum Beispiel die Schlüsselgenerierung, ungeeignet. In solchen Fällen verlangt man von Zufallszahlen, dass sie von irgendwelchen Umgebungsrauschen beeinflusst werden. In C++ gibt es dafür die random_device-Klasse.
Danke aber das habe ich mir bereits angeschaut. Leider kann man damit kein Minimum festlegen.
„static constexpr result_type min();
Minimum value
_Returns the minimum value_ potentially returned by member operator(), _which for random_device is always zero_.“
Besteht dabei nicht die Gefahr, dass man sich eine eher kleine Zahl generiert welche dann potentiell als unsicher angesehen werden kann? Oder generiert man in so einem Fall einfach neue Zahlen bis man sein gewünschtes Minimum trifft?
Grüße
Hakuna matata!
Besteht dabei nicht die Gefahr, dass man sich eine eher kleine Zahl generiert welche dann potentiell als unsicher angesehen werden kann?
Unter der kryptografischen Sicherheit oder besser kryptografischen Stärke einer Zufallszahl versteht man eine Eigenschaft des verwendeten Zufallszahlen-Generators: Reine Software-Generatoren liefen die kryptgrafisch schwachen Psuedo-Zufallszahlen. Generatoren, die auf spezielle Hardware zugreifen, um so ein paar Umgebungsvariablen mit einfließen zu lassen, liefern die kryptografisch starken Zufallszahlen.
Ob eine Zufallszahl nun groß oder klein ausfällt, hat keinen Einfluss auf ihre kryptografische Stärke. Man kann nicht pauschal sagen: 42 ist sicherer als 11.
Oder generiert man in so einem Fall einfach neue Zahlen bis man sein gewünschtes Minimum trifft?
Man generiert in solchen Fällen eine Zufallszahl und addiert dann das Minimum, das man haben möchte, dazu. Angenommen du hast einen Zufallszahlen-Generator der liefert dir Zahlen zwischen 0 und 100. Du brauchst aber eine Zufallszahl zwischen 100 und 200. Dann addier einfach 100 auf die ursprüngliche Zufallszahl und schon liegst du mit deiner Zahl im Zielbereich.
Hi 1UnitedPower!
Vielen Dank für deine Erklärung!
Grüße