Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung

[SeppJ]

manni66 hat Recht.

[EinNutzer0]

Der Beweis geht quasi direkt aus dem Kommentar/Source hervor:

    /**
     * Creates a new random number generator. This constructor sets
     * the seed of the random number generator to a value very likely
     * to be distinct from any other invocation of this constructor.
     */
    public Random() {
        this(seedUniquifier() ^ System.nanoTime());
    }

    private static long seedUniquifier() {
        // L'Ecuyer, "Tables of Linear Congruential Generators of
        // Different Sizes and Good Lattice Structure", 1999
        for (;;) {
            long current = seedUniquifier.get();
            long next = current * 1181783497276652981L;
            if (seedUniquifier.compareAndSet(current, next))
                return next;
        }
    }

http://www.java2s.com/example/java-src/pkg/java/util/random-fd044.html

@SeppJ sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

manni66 hat Recht.

Womit hat er recht? Wie man sich danebenbenimmt?

[wob]

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Random wählt den seed unter anderem anhand der Nanosystemzeit. Dadurch ist eine ausreichende seed-Entropie sichergestellt.

Ähm. Vielleicht einmalig. Aber sicher nicht beim Wiederholen.

Der Zustand des Systems kann praktisch auch nicht so genau beobachtet werden, dass der seed reproduzierbar wäre (Werner Heisenbergs Unschärferelation).

Ich sehe einen im Grab rotierenden Heisenberg.

[EinNutzer0]

@wob sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Ich sehe einen im Grab rotierenden Heisenberg.

Es könnte lediglich (theoretisch) passieren, dass zwei getRandomDouble-Aufrufe zeitlich so nah beieinander liegen, dass sie denselben Wert berechnen und zurückgeben...

Das war irgendwie falsch formuliert... Das kann eigentlich gar nicht passieren.

Dennoch hat, wo das new Random() nun genau vorkommt, gar nichts mit meiner Frage zu tun!

[Schlangenmensch]

@EinNutzer0 Du willst normalverteilte Zufallsvariablen haben, richtig? Warum sollten die ersten Werte der Zufallsreihen verschieden initialisierter Zufallsgeneratoren normalverteilt sein? Garantiert ist das für die Werte eines Zufallsgenerators.

[wob]

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Dennoch hat, wo das new Random() nun genau vorkommt, gar nichts mit meiner Frage zu tun!

Eine deiner Fragen war (Zitat) "Oder gibts vielleicht etwas Besseres als new Random().nextGaussian()?" (Zitat Ende). Ja, gibt es. Trennen von "new Random()" und dem "nextGaussian()". Aber für mich ist jetzt Ende.

[EinNutzer0]

@Schlangenmensch : #nextGaussian() ist eine Methode von Random basierend auf dessen seed.

[EinNutzer0]

@wob sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Dennoch hat, wo das new Random() nun genau vorkommt, gar nichts mit meiner Frage zu tun!

Eine deiner Fragen war (Zitat) "Oder gibts vielleicht etwas Besseres als new Random().nextGaussian()?" (Zitat Ende). Ja, gibt es. Trennen von "new Random()" und dem "nextGaussian()". Aber für mich ist jetzt Ende.

Etwas Besseres nur in Hinblick auf die Methode nextGaussian() meinte ich...

Und die erstere Frage bezog sich auf die Vermeidung der do-while-Schleife.

Du musst nicht weglaufen, nur, weil es etwas unbequem wird.

[Quiche Lorraine]

@Schlangenmensch sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Warum sollten die ersten Werte der Zufallsreihen verschieden initialisierter Zufallsgeneratoren normalverteilt sein?

Das frage ich mich auch schon die ganze Zeit. Aber es scheint mir noch ein wenig schlimmer denn der TE schneidet ja alles über +- Sigma (siehe Standardabweichung) weg. Das heißt in 30% der Fälle wird einfach nochmals gewürfelt bis der Wert im +- Sigma Raster liegt. Und dadurch ändert sich die Verteilung.

Das was da rauskommt dürfte ähnlich der Normalverteilung sein. Sicher bin ich da nicht.

[Schlangenmensch]

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

@Schlangenmensch : #nextGaussian() ist eine Methode von Random basierend auf dessen seed.

Und? Du hast meine Antwort nicht verstanden, denke ich.
In deinem ursprünglichen Code hast du ja eben nicht mit nextGaussian auf einen Zufallsgenerator gearbeitet, sondern nextGaussian immer nur einmal auf einen neuen Zufallsgenerator aufgerufen. Und das ist eben nicht nur aus Performance Gründen problematisch, was dir ja egal war, sondern auch aus Sicht des Zufalls.

[EinNutzer0]

@Schlangenmensch sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Und?

Mir scheint, du hast Random noch nicht richtig verstanden. Solange die nextGaussian()-Werte auf unterschiedlichen seeds beruhen, werden auch "gute" Zufallszahlen generiert. Und das tun sie ja.

Um die Performance kann man sich später kümmern. Kein Grund, an meiner Intelligenz zu zweifeln...

Wer paranoid ist, nimmt eben SecureRandom.

[Schlangenmensch]

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Mir scheint, du hast Random noch nicht richtig verstanden.

Kann sein. Hab ewig kein Java mehr gemacht.

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Solange die nextGaussian()-Werte auf unterschiedlichen seeds beruhen, werden auch "gute" Zufallszahlen generiert. Und das tun sie ja.

Aber nicht zwangsweise normalverteilt. Da du nextGaussian nimmst, bin ich davon ausgegangen, dass es dir Normalverteilung für dich wichtig ist. Sonst hätte ich ein nextDouble erwartet. (Wobei ich mir da unsicherer werde, wenn ich länger drüber nachdenke).

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Um die Performance kann man sich später kümmern. Kein Grund, an meiner Intelligenz zu zweifeln...

An deiner Intelligenz habe ich nicht gezweifelt, Performance hinten anzustellen ist sicherlich nicht verkehrt.

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Wer paranoid ist, nimmt eben SecureRandom.

Es kommt hinterher drauf an, wofür du die Zufallszahlen benötigst. Wenn es um kryptografische Anwendungen geht, ist das mit dem immer neu initialisieren und nur die erste Zufallszahl nehmen, noch problematischer. Man kann ja Random auch manuell initialisieren. Wenn das von deiner Systemzeit abhängt kann man einfach die Seeds um die wahrscheinliche genutzte Systemzeit ausprobieren und die damit generierten Werte vergleichen.

[SeppJ]

@Schlangenmensch sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Mir scheint, du hast Random noch nicht richtig verstanden.

Kann sein. Hab ewig kein Java mehr gemacht.

Lass dir bloß nichts von EinNutzer0 einreden. Hier im Thread gibt es genau eine Person, die keine Ahnung von Random hat.

[EinNutzer0]

@SeppJ sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

@Schlangenmensch sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Mir scheint, du hast Random noch nicht richtig verstanden.

Kann sein. Hab ewig kein Java mehr gemacht.

Lass dir bloß nichts von EinNutzer0 einreden. Hier im Thread gibt es genau eine Person, die keine Ahnung von Random hat.

Entweder du benimmst dich, oder ich bin weg.

Schlangenmenschs Irrtum konnten wir ja schon aufklären, d. h., du kannst dir deine Beleidigungen sparen.

Hier gibt es ziemlich viele, die von Java keine Ahnung haben, und ggf. war es ein Fehler, nachzufragen.

[Schlangenmensch]

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Schlangenmenschs Irrtum konnten wir ja schon aufklären, d. h., du kannst dir deine Beleidigungen sparen.

Was genau mein Irrtum war, würde mich hier doch interessieren. Nur, weil es unterschiedlich initialisiert scheinbar zufällige Werte wiedergibt, heißt es nicht, dass es eine sinnvolle Wahrscheinlichkeitsverteilung ergibt.

Edit:

g += (0.5 - g) * a * a;
g -= (g - 0.5) * a * a;

ist das nicht das gleiche?

g = g + ((0.5 -g) * a²) = g + (0.5a² - ga²) = g + 0.5a² - ga²
g = g - ((g - 0.5) * a²) = g - (ga² - 0.5a²) = g - ga² + 0.5ga² = g + 0.5a² - ga²

[Quiche Lorraine]

@EinNutzer0
Ich verstehe deinen Einsatzweck nicht so recht.

In einem Teil sprichst du von Entropie und Güte der Zufallswerte, nicht reprodzierbare Seeds als würdest du deine Funktion im kryptographischen Bereich einsetzen.

Auf der anderen Seite nutzt du eine veränderte Gauß oder Beta-Verteilung, als würdest du beispielsweise einen physikalischen Prozess simulieren. Und dies wiederspricht einer Verwendung im Kryptographie-Bereich.

• In welchem Bereich verwendest du deine Funktion?
• Nutzt du deine Funktion im kryptographischen Bereich?
• Rufst du absichtlich new Random() auf, damit du einen neuen Seed bekommst und so "zufällig" wirst?
• Wozu benötigst du die Gauß- bzw. Beta Verteilung?

[EinNutzer0]

@Schlangenmensch sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Edit:
g += (0.5 - g) * a * a;
g -= (g - 0.5) * a * a;

ist das nicht das gleiche?
g = g + ((0.5 -g) * a²) = g + (0.5a² - ga²) = g + 0.5a² - ga²
g = g - ((g - 0.5) * a²) = g - (ga² - 0.5a²) = g - ga² + 0.5ga² = g + 0.5a² - ga²

Ja, es könnte durchaus sein, dass ich da etwas nachlässig war, und dass nur ein Term genügt hätte...

@Schlangenmensch sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Was genau mein Irrtum war, würde mich hier doch interessieren.

Ich will jetzt nicht auf PRNGs eingehen... so schwer sind die nicht zu verstehen. Wichtig ist nur, dass aus mehreren Aufrufen von new Random() auch "unterschiedliche" Zahlen resultieren. Es gibt nur einen Fall, der problematisch ist, nämlich jedes Mal new Random(0) oder new Random(1) aufzurufen, um nur einen Wert zu bestimmen.

@Quiche-Lorraine sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Wozu benötigst du die Gauß- bzw. Beta Verteilung?

Ich wollte einfach nur Aktienkursverläufe simulieren...

@Quiche-Lorraine sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Rufst du absichtlich new Random() auf, damit du einen neuen Seed bekommst und so "zufällig" wirst?

Eigentlich ist das nur dem raschen Schreiben geschuldet...

tl;dr: Die Beta-Funktion ist besser. Ich hab die nur noch nicht verstanden...

Danke für eure Antworten.

[Schlangenmensch]

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Ich will jetzt nicht auf PRNGs eingehen... so schwer sind die nicht zu verstehen. Wichtig ist nur, dass aus mehreren Aufrufen von new Random() auch "unterschiedliche" Zahlen resultieren. Es gibt nur einen Fall, der problematisch ist, nämlich jedes Mal new Random(0) oder new Random(1) aufzurufen, um nur einen Wert zu bestimmen.

Mir ging es die ganze Zeit nur um die Frage ob einzelne Ziehungen aus unterschiedlich initialisierten PRNGs eine passende Wahrscheinlichkeitsverteilung ergeben. Offenbar haben wir aneinander vorbei geschrieben.

[Quiche Lorraine]

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Ich wollte einfach nur Aktienkursverläufe simulieren...

Dann dürfte die erste Frage wohl sein: Wie simuliere ich dies?

Schaut man sich nämlich einen Aktienkurs auf kleinen Zeiteinheiten an, so erscheint diese eher gleich verteilt. Je größer die Zeiteinheit wird, desto eher werden Trends erkennbar.

Schau dir ruhig mal die Kurse von Amazon und Deutsche Bank an.

Ich habe mal schnell im Netz gegoogelt und eine Möglichkeit zur Simulation mittels Geometric Brownian motion gefunden: How to use Monte Carlo simulation with GBM

Es gibt sogar ein Paper hierzu: Simulating stock prices using geometric Brownian motion

Daran würde ich mich jetzt zuerst orientieren.

[SeppJ]

@Schlangenmensch sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

@EinNutzer0 sagte in Zufälligen nextGaussian-Wert zwischen zwei Grenzen mit einer Häufung:

Ich will jetzt nicht auf PRNGs eingehen... so schwer sind die nicht zu verstehen. Wichtig ist nur, dass aus mehreren Aufrufen von new Random() auch "unterschiedliche" Zahlen resultieren. Es gibt nur einen Fall, der problematisch ist, nämlich jedes Mal new Random(0) oder new Random(1) aufzurufen, um nur einen Wert zu bestimmen.

Mir ging es die ganze Zeit nur um die Frage ob einzelne Ziehungen aus unterschiedlich initialisierten PRNGs eine passende Wahrscheinlichkeitsverteilung ergeben. Offenbar haben wir aneinander vorbei geschrieben.

Wenn du wirklich verunsichert sein solltest: Nein, natürlich haben die jeweils ersten Ziehungen aus einem biased Seed selber einen Bias. Oder andersrum gedacht: Wenn die Methode zum Erzeugen des Seeds so toll wäre, um unbiased Zufall zu erzeugen, dann bräuchte man ja keinen Zufallsgenerator mehr…

Hier trifft es wohl nicht zu, da der Generator recht einfach ist, aber bei vielen Generatoren ist der interne State viel größer als der Seed, und man würde mit der ersten Zahl nach dem Seeding immer eine Zahl ziehen, die aus ganz vielen 0 erzeugt wurde. Die Anweisung dort ist, dass man stets erst ein paar Tausend Zahlen ziehen sollte, damit der Generator überhaupt warm gelaufen ist, bevor man richtig anfängt.