Zufallszahlen...

[schnei]

Hi!

In jeder Programmiersprache gibts einen random Befehl, mit der eine Zufallszahl erzeugt wird. Meine Aufgabe ist es, den Algorithmus der dahinter steckt (Uhrzeit abgreifen, daraus ne Zahl errechnen, usw.) in ein Struktogramm o.ä. zu packen.

Leider finde ich nichts über diesen Algorithmus....

Hätte jemand eine Idee o.ä.?

Vielen Dank bereits im vorraus!!!

[Amstelchen]

vielleicht hilft dir Wikipedia:Zufallszahl und weiterführende artikel.

s'Amstel

[Bubble]

Hi!

In jeder Programmiersprache gibts einen random Befehl, mit der eine Zufallszahl erzeugt wird. Meine Aufgabe ist es, den Algorithmus der dahinter steckt (Uhrzeit abgreifen, daraus ne Zahl errechnen, usw.) in ein Struktogramm o.ä. zu packen.

Leider finde ich nichts über diesen Algorithmus....

Hätte jemand eine Idee o.ä.?

Es gibt unterschiedliche Algorithmen, die sich in ihrer Güte (d.h. der "Vorhersagberkeit" der nächsten Zahl basierend auf der Kenntniss der vorangegangenen Zahlen) unterscheiden. Für die C-Funktion rand() kannst Du Dir auch den Source der C-Library-Implementierung ansehen, um eine Idee über die Implementierung zu bekommen.

Viele Verschlüsselungsalgorithmen basieren auch auf der Verwendung eines Pseudo-Zufallszahlengenerators, daher wirst Du vielelicht einige interessante Artikel über Zufallszahlen in Zusammenhand mit Verschlüsselungsalgorithmen finden. Vergiss aber nie, dass es sich um keine wirklich zufälligen Zahlen handelt, nur die Verteilung der Zahlenabfolge ist so "verworren", dass man sie ohne Kenntnis der Seed-Zahl (auch als Initialisierungsvektor bezeichnet) nicht erraten können soll, bzw. mit vertretbarem Aufwand durch statistische Beobachtungen ermitteln.

(Uhrzeit abgreifen, daraus ne Zahl errechnen, usw.)

Aus der Urzeit kann man einen Seed (Initialisierungsvektor) gewinnen. Verwendet man den gleichen Seed wieder, erhält man jedes mal die gleiche Abfolge an Zahlen.

[SNOWMAN]

ich erinenre mich gerade an meine Schulzeit, da haben wir in QBasic "programmiert".

Und unter anderem hat uns unser Lehrer da mal die Randomfunktion kurz erläutert.

Soweit ich mich erinnere hat QBasic ne Liste an Zahlen und die werden der Reihe nach ausgegeben.

Also wenn ich mein prog starte und mir 3 Zufallszahlen geben lasse, das Programm beende, neu starte und wieder drei Zahlen geben lasse sind das die gleichen.

Haben wir auch getestet und es stimmte. Also von wegen Generator is da nix dahinter

Aber gut, das war damals, in C/C++ und VBasic is das ja nich mehr so, gottseidank.

[nic_power]

Hallo,

Und unter anderem hat uns unser Lehrer da mal die Randomfunktion kurz erläutert.

Soweit ich mich erinnere hat QBasic ne Liste an Zahlen und die werden der Reihe nach ausgegeben.

Auch QBASIC verwendet einen Pseudozufallszahlengenerator, der mit einer entsprechenden Funktion initialisiert werden kann (d.h. Du setzt die seed). Wenn Du diesen seed nicht setzt (oder im den gleichen Wert verwendest) erhälst Du auch bei jedem Programmstart identische Zufallszahlen.

Nic

[SNOWMAN]

so ausführlich haben wir das nicht gemacht, das war "nur" realschule.

ich erinnere mich auch garnich mehr an die funktion, also wie die hieß und ob da irgendwelche übergabe Parameter dabei waren oder oder oder...

Nagut, also wenns so is, dann korrigier ich mich mal:

Die QBasicfunktion HAT einen Generator dahinter!

[schnei]

Vielen Dank für die Antworten!!!

Werde mir zuerst einfach mal die random-funktion angucken (kein Plan warum ich nicht selber drauf gekommen bin... :confused: )

Bei Wikipedia hab ich schonmal reingeguckt.

Leider hatte der Artikel den ich gefunden habe nichts mit der Errechnung von Zufallszahlen zu tun...

[speedi]

Jag Doch einfach mal die JAVA-Klasse Random durch den Decompiler

package java.util;


import java.io.*;

import sun.misc.AtomicLong;


public class Random

    implements Serializable

{


    public double nextDouble()

    {

        long l = ((long)next(26) << 27) + (long)next(27);

        return (double)l / 9007199254740992D;

    }


    public synchronized double nextGaussian()

    {

        if(haveNextNextGaussian)

        {

            haveNextNextGaussian = false;

            return nextNextGaussian;

        }

        double d;

        double d1;

        double d2;

        do

        {

            d = 2D * nextDouble() - 1.0D;

            d1 = 2D * nextDouble() - 1.0D;

            d2 = d * d + d1 * d1;

        } while(d2 >= 1.0D || d2 == 0.0D);

        double d3 = Math.sqrt((-2D * Math.log(d2)) / d2);

        nextNextGaussian = d1 * d3;

        haveNextNextGaussian = true;

        return d * d3;

    }


    public float nextFloat()

    {

        int i = next(24);

        return (float)i / 1.677722E+007F;

    }


    public int nextInt()

    {

        return next(32);

    }


    public long nextLong()

    {

        return ((long)next(32) << 32) + (long)next(32);

    }


    public Random()

    {

        this(System.currentTimeMillis());

    }


    public boolean nextBoolean()

    {

        return next(1) != 0;

    }


    protected int next(int i)

    {

        long l;

        long l1;

        do

        {

            l = seed.get();

            l1 = l * 0x5deece66dL + 11L & 0xffffffffffffL;

        } while(!seed.attemptUpdate(l, l1));

        return (int)(l1 >>> 48 - i);

    }


    public int nextInt(int i)

    {

        if(i <= 0)

            throw new IllegalArgumentException("n must be positive");

        if((i & -i) == i)

            return (int)((long)i * (long)next(31) >> 31);

        int j;

        int k;

        do

        {

            j = next(31);

            k = j % i;

        } while((j - k) + (i - 1) < 0);

        return k;

    }


    public Random(long l)

    {

        haveNextNextGaussian = false;

        seed = AtomicLong.newAtomicLong(0L);

        setSeed(l);

    }


    public synchronized void setSeed(long l)

    {

        for(l = (l ^ 0x5deece66dL) & 0xffffffffffffL; !seed.attemptSet(l);

        haveNextNextGaussian = false;

    }


    public void nextBytes(byte abyte0[])

    {

        int i = abyte0.length;

        int j = 0;

        int k = 0;

        do

        {

            int l = 0;

            while(l < 4) 

            {

                if(j == i)

                    return;

                k = l != 0 ? k >> 8 : next(32);

                abyte0[j++] = (byte)k;

                l++;

            }

        } while(true);

    }


    private void readObject(ObjectInputStream objectinputstream)

        throws IOException, ClassNotFoundException

    {

        java.io.ObjectInputStream.GetField getfield = objectinputstream.readFields();

        long l = getfield.get("seed", -1L);

        if(l < 0L)

        {

            throw new StreamCorruptedException("Random: invalid seed");

        } else

        {

            seed = AtomicLong.newAtomicLong(l);

            nextNextGaussian = getfield.get("nextNextGaussian", 0.0D);

            haveNextNextGaussian = getfield.get("haveNextNextGaussian", false);

            return;

        }

    }


    private synchronized void writeObject(ObjectOutputStream objectoutputstream)

        throws IOException

    {

        java.io.ObjectOutputStream.PutField putfield = objectoutputstream.putFields();

        putfield.put("seed", seed.get());

        putfield.put("nextNextGaussian", nextNextGaussian);

        putfield.put("haveNextNextGaussian", haveNextNextGaussian);

        objectoutputstream.writeFields();

    }


    static final long serialVersionUID = 0x363296344bf00a53L;

    private AtomicLong seed;

    private static final long multiplier = 0x5deece66dL;

    private static final long addend = 11L;

    private static final long mask = 0xffffffffffffL;

    private static final int BITS_PER_BYTE = 8;

    private static final int BYTES_PER_INT = 4;

    private double nextNextGaussian;

    private boolean haveNextNextGaussian;

    private static final ObjectStreamField serialPersistentFields[];


    static 

    {

        serialPersistentFields = (new ObjectStreamField[] {

            new ObjectStreamField("seed", Long.TYPE), new ObjectStreamField("nextNextGaussian", Double.TYPE), new ObjectStreamField("haveNextNextGaussian", Boolean.TYPE)

        });

    }

}[/code]

schaue dir mal die Methode "next" an!

[perdian]

Jag Doch einfach mal die JAVA-Klasse Random durch den Decompiler

Oder direkt in die Sources gucken, dann sind auch die Kommentare mit drin.