Zufallszahlenerzeugung nach dem multiplikativen Kongruenzverfahren

[blubbs]

Hey,

ich bräuchte mal wieder eure Hilfe.

also die Aufgabenstellung lautet:
"Es ist eine Java-Methode zu erstellen, die Pseudozufallszahlen aus dem Intervall (A,B) nach dem multiplikativen Kongruenzverfahren zi+1 = fakt * zi % m erzeugt.
Nach der obigen Vorschrift sind (m = 1) sind Pseudozufallszahlen aus dem Intervall [0,1) zu erzeugen, die dann nach y = A + (B-A) * z in das Intervall (A,B) transformiert werden.
Als Parameter werden übergeben:

* die Intervallgrenzen A und B
* der Faktor fakt >1
* der Anfangswert z0 < 1

Es ist eine Folge von 10 Zahlen zu erzeugen. Diese sind nacheinander durch Komma getrennt in einen String zu schreiben, der als Ergebnis zurückzugeben ist. Wichtig: Es dürfen keine weiteren Leerzeichen oder sonstige Zeichen im String enthalten sein. Hinter der letzten Zahl folgt wieder ein Komma (es muss da also kein Sonderfall beachtet werden). "

Mein Problem ist jetzt, dass ich nicht erkennen kann, was die erste Formel machen soll und was die zweite. Also die erste ist wohl dieses Kongruenzverfahren, aber kommt da nicht immer 0 raus? (weil das Ergebnis soll ja nur im Intervall [0,1] sein) und wie kann das dann durch die zweite Formel in meinem festgelegten Intervall überführt werden?

das zweite Problem ist die Rückgabe dieses Strings. Ich dachte, das macht man mit ". Jetzt hab ich aber schon alles mögliche ausprobiert und es kommt entweder ") expected" oder es gibt eben wortwörtlich das wieder, was innerhalb der Anführungszeichen steht (was prinzipiell ja richtig ist, aber sobald ich da eine Variable einbauen will, kommt eine Fehlermeldung).

Das hab ich bis jetzt, was nicht wirklich viel ist.

public class Zufall
{
    /**
     * Zufallszahlenerzeugung nach dem multiplikativen Kongruenzverfahren
     * 
     * @param  a, b, fakt, z0   Intervallgrenzen, Faktor, Anfangswert
     * @return    mit   Mittelwert der Zufallszahlen
     */
    public String multiplikativesKongruenzverfahren(int a, int b, double fakt,double awert)
    {
        double i = 0;        //für for-schleife
        double m = 1;      //vorgegeben?!
        double zi = 0;      //entspricht zi = 0, da Intervall nur 0 und 1?!
        double zi2 = 1;    //entspricht zi+1 = 1, da Intervall nur 0 und 1?!
        double y = 0;      //Zufallszahl 
         
        zi2 = fakt * zi % m;  //da zi = 0, ist zi2 nicht immer 0?  zi = ((fakt * zi2)) % m (wikip)
        
        for (i = awert; i < 11; i++)    //da ja 10 Zahlen ausgegeben werden sollen
        {
          y = a + (b-a) * zi2;
          return y;             //fehlermeldung: found double but expected java.lang.String
        }

        
       return ",,,";            //wie gibt man einen String zurück?
    }
}

also vielleicht könnte mir jemand wenigstens die Aufgabenstellung erklären?! vielen Dank.

PS: der Methodenname ist vorgegeben und nicht veränderbar.

 

[SlaterB]

bei zi steht das i für das i-te Element der Folge der Zufallszahlen,
es gibt nicht zi, zi2, zi3,

sondern das erste Element ist z0, und das ist auch nicht 0, sondern als Parameter gegeben (awert?),
z.B. könnte z0 den Wert 0.3 haben, fakt 4, dann ist z1 nach der Formel 1.2 also 0.2, der nächste Wert 0.8,
naja, nicht besonders zufällig

die Berechnung 10 verschiedener z-Werte muss in die Schleife, fange damit an,
wobei deine Formel für y schon ziemlich richtig aussieht

gib in der Schleife jeden zi-Wert und evtl. jedes y mit System.out.println() aus,
über den zusammengefügten String kannst du später noch nachdenken,

in die Schleife gehört kein return, die Schleife beginnt auch nicht bei awert sondern läuft von 0-10

 

[blubbs]

vielen Dank schon mal. das hat sehr viel mehr Klarheit in die Aufgabe gebracht =)

also mein Code sieht jetzt folgendermaßen aus:

public class Zufall
{
    /**
     * Zufallszahlenerzeugung nach dem multiplikativen Kongruenzverfahren
     * 
     * @param  a, b, fakt, z0   Intervallgrenzen, Faktor, Anfangswert
     * @return    mit   Mittelwert der Zufallszahlen
     */
    public String multiplikativesKongruenzverfahren(int a, int b, double fakt,double awert)
    {
        double i = 0;       //für for-schleife
        double m = 1;     //vorgegeben
        double y = 0;     //Zufallszahl initiieren 
               
        for (i = 0; i < 10; i++)       //da 10 Zahlen ausgegeben werden sollen
        {
          awert = fakt * (awert) % m;          //multiplikatives Konguenzverfahren
          System.out.println("z = " +awert);   //könnte man doch sicher auch weglassen, da es ja in einem festgelegten Intervall (= y?) ausgegeben werden soll
          
          y = a + (b-a) * awert;
          System.out.println("Zufallszahl = " +y);
        }

        
       return ",,,";   //wie gibt man einen String zurück?
    }
}

wenn ich es ausgeben lasse mit a=3, b=6, fakt=4 und awert=0.3 kommt folgendes:

z = 0.19999999999999996
Zufallszahl = 3.5999999999999996
z = 0.7999999999999998
Zufallszahl = 5.3999999999999995
z = 0.1999999999999993
Zufallszahl = 3.599999999999998
z = 0.7999999999999972
Zufallszahl = 5.3999999999999915
z = 0.19999999999998863
Zufallszahl = 3.599999999999966
z = 0.7999999999999545
Zufallszahl = 5.399999999999864
z = 0.1999999999998181
Zufallszahl = 3.5999999999994543
z = 0.7999999999992724
Zufallszahl = 5.399999999997817
z = 0.19999999999708962
Zufallszahl = 3.599999999991269
z = 0.7999999999883585
Zufallszahl = 5.399999999965075


das sind doch keine wirklichen zufallszahlen oder? der Unterschied ist ja immer minimal. und müsste man nicht noch irgendwo angeben, dass "awert < 1" und "fakt > 1" sein müssen (vgl. Aufgabenstellung)? hätte das jetzt noch in eine if-anweisung gepackt. ist das sinnvoll bzw. muss man das machen? und warum darf der awert nicht größer als eins sein? weil wenn ich das ausprobiere werden ja trotzdem "zufallszahlen" ausgegeben.

und dann bleibt da natürlich noch das Problem mit der Rückgabe =)

 

[Andi_CH]

String zurückgeben ???:L???:L???:L

String wetter = " Es liegt Schnee";

public String gibString {
   return wetter;
}

das sind doch keine wirklichen zufallszahlen oder?

IMHO stimmt mit der Formel etwas nicht. Zufallszahlen durch eine einfach Multiplikation zu gewinnen ist unmöglich.

EDIT: Ah da hab ich doch was entdekt: Du rechnest immer mit dem aWert und das ist falsch - du musst die letzte Zufallszahl einsetzen

 

[Andi_CH]

Du hattest einige Fehler drin - der Algorithmus beruht darauf dass er die letzte Zufallszahl als Wert erhält. zi+1=f(zi) und nicht f(awert)!

Der Anfangswert ist nur für die erste Berechnung gut.

Sieh dir das mal an

public class Zufall {

	public String multiplikativesKongruenzverfahren(int a, int b, double fakt,double awert)
	{
		double m = 1;       //vorgegeben
		double y = awert;   //Zufallszahl initialisieren
		double resultat;    // ist nur um den Code besser lesbar zu machen
		
		String returnValue = "";

		y = fakt * (y) % m;          // berechne erste Zahl
		resultat = a + (b-a) * y;    // umskalieren
		returnValue += resultat;     // damit ist das , Problem entschärft ;-)

		for (int i = 0; i < 9; i++)  // da 10 Zahlen ausgegeben werden sollen und eine schon ausgegeben ist
		{
			y = fakt * (y) % m;      		// nächste Zufallszahl berechnen
			resultat = a + (b-a) * y;    	// umskalieren
			returnValue += ", " + resultat; // Diesmal mit ,
		}
		return returnValue;   // so gibt man einen String zurück ;-)
	}

	public static void main(String[] args) {
		int anfang = 0;
		int ende = 1;
		double faktor = 1.23456789;
		double anfangswert = 0.1;

		Zufall z = new Zufall();
		System.out.println(z.multiplikativesKongruenzverfahren(anfang, ende, faktor, anfangswert));
	}

}

Sieht auch schon besser aus, obwohl die kontinuierlich ansteigen, aber das liegt an den Parametern

0.123456789, 0.15241578750190518, 0.18816763717891544, 0.23230572279825917, 0.2867971860299717, 0.35407059681495956, 0.4371241896208853, 0.5396594884482162, 0.6662462759719936, 0.8225262591471018

mit

	double faktor = 4.23456789;
	double anfangswert = 0.7;

wird es besser

0.9641975229999997, 0.08295987051333498, 0.3512992038343261, 0.48760032833940237, 0.06477669353949045, 0.2743013064826967, 0.16154750461667633, 0.6840838757594043, 0.8967996143575232, 0.7975588507227509

 

[Painii]

Pseudozufallszahlen.
Wenn du den gleichen Wert eingibst kommen immer die gleichen Ergebnisse raus.
Für "Zufall" wird dann als Anfangswert die Systemzeit oder so genommen, die halt selten zweimal die gleiche ist.

Und wenn du nicht weisst wie du einen String zurückgibts, schau es dir nochmal in einem Tutorial an.
Studieren geht da über probieren

 

[SlaterB]

@Andi_CH
> Der Anfangswert ist nur für die erste Berechnung gut.

was ist an
> awert = fakt * (awert) % m;
anders als jetzt bei dir
> y = fakt * (y) % m;

ist doch dieselbe Zeile, nur dass es bisschen unschön war, awert als Laufvariable zu benutzen,
dass 0.4 und 4 nicht so gut sind ist halt Pech, muss man bisschen überlegen, vielleicht nur Primzahlen als Faktor,
mit einem komplizierten Kommawert liegt man sicher auch nicht schlecht,

@blubbs
> 1, < 1 per if prüfen, ja,

solange du die Zufallszahl erst %m = 1 rechnest ist der Anfangswert in der Tat egal,
aber warum gefährlich einen außerhalb des Wertebereichs wählen,

für Rückgabe String in der Schleife mit + zusammenbauen

bei Werten wie 0.19999999999999996 lohnt es sich vorher zu runden, aber da dass eh ne schlechte Zahl ist und die augenscheinlich 'richtigen' Zufallszahlen beliebige Ziffern haben ist die lange Ausgabe sicher ok wenn nicht in der Aufgabe was anderes steht

 

[Andi_CH]

Da war irgend ein Mischmasch von awert und y und mehrfach berechnen und umskalieren - wenigstens in meinen Augen war das so, da habe ich halt den schnelleren Weg gewählt.

Wenn ich es jetzt bei Tageslicht betrachte war es gar nicht so schlimm - sorry ;-)

 

[blubbs]

@ Andi_CH: Vielen Dank für die Hilfe! =) hab jetzt eine hilfsvariable statt dem awert genommen und nicht y aber geht ja trotzdem.

@Slater: es stand in der Aufgabenstellung, dass awert kleiner als 0 und fakt größer als 1 sein muss. ich dachte das hat eine Bedeutung, aber anscheinend war das nur eine Vorgabe oder?!

 

[blubbs]

Hey, also da ist jetzt das was ich abgegeben hab, aber er nimmt es nicht an:

public class Zufall
{
    /**
     * Zufallszahlenerzeugung nach dem multiplikativen
Kongruenzverfahren
     *
     * @param  a, b, fakt, z0   Intervallgrenzen, Faktor, Anfangswert
     * @return    mit   Mittelwert der Zufallszahlen
     */
    public String multiplikativesKongruenzverfahren(int a, int b,
double fakt,double awert)
    {
        double i = 0;     //für for-schleife
        double m = 1;     //vorgegeben
        double y = 0;     //Zufallszahl initiieren
        double h = awert;  //Hilfsvariable initiieren
        String rueckgabe = "";   //Rueckgabewert initiieren

       if ((awert < 1) && (fakt > 1))
        {
         h = fakt * h % m;    //ersten Wert der HV berechnen
         y = a + (b-a) * h;  //auf Intervall anpassen
         rueckgabe += y;     //Rückgabe der ersten Zufallszahl

         for (i = 0; i < 9; i++)  //da nur noch 9 Zahlen ausgegeben
werden müssen
         {
           h = fakt * h % m;      //multiplikatives Konguenzverfahren
           y = a + (b-a) * h;           //auf Intervall anpassen
           rueckgabe += "," + y;            //Rückgabe der 9 weiteren
Zufallszahlen
         }
        }
        else
        return "Zufallszahlenermittlung nicht möglich";

       return rueckgabe;
    }
}

als Fehlermeldung kommt:

"Your submission failed.

testZufall(JUnitTester): multiplikativesKongruenzverfahren(1,5,1.6,0.7) expected:<...8,1.3709488332799808[,]> but was:<...8,1.3709488332799808[]>"


wenn man die erste zahl zum beispiel ausrechnet kommt doch für a=3, b=6, fakt=4, awert=0.3 folgendes raus:
h= (4 * 0.3) % 1 = 0.2
und
y= 3 + ((6-3) *0.2) = 3.6

Meine Frage ist jetzt, ob die berechnung für y überhaupt richtig ist? ist das überhaupt richtig gedacht?
und wie kann man die zahlen runden, weil mir mein programm y = 3,5999999999... ausgibt.