Rechteckverteilung bei Zufallszahlen

Hey allerseits,

ich benötige einen Zufallsgenerator, der nicht wie rand ungleichmäßig zufallszahlen ausspuckt, sondern eine Rechteckverteilung. Sprich jede Zufallszahl hat die gleiche Chance ausgespuckt zu werden.

Mit dem Zufallsgenerator sollen Koordinaten in x, so wie y Richtung von -100 bis +100 entstehen.

....
int x_k, y_k;

srand(time(NULL)
x_k=rand()%101;
x_k=(rand()%2==0)?x_k:-x_k;
......

Verteilung bei Rand sieht ungefähr so aus: 0 bis rand_max/2 > 50%
und rand_max/2 bis rand_max demensprechend weniger.

Vllt kann mir jemand helfen. fände ich super!

Cheers

Hans-Stein schrieb:

Verteilung bei Rand sieht ungefähr so aus: 0 bis rand_max/2 > 50% und rand_max/2 bis rand_max demensprechend weniger.

Wo und wie hast du das festgestellt?

SeppJ

rand() erzeugt gleichverteilte Zufallszahlen. Deine Messung ist falsch.

Also draufgekommen bin ich, nachdem ich bei meinem statistisch ermittelten wert pi kein exaktes ergebnis bekommen habe.
Einfach mit hilfe von einer if-abfrage und jedes mal, wenn der wert kleiner 50 ist bei einem vorher definierten Zähler zum Beispiel int i = 0; einen Wert dazuzählen sprich i++; und dann schaust du dir die anzahl an, die kleiner 50 sind und der rest ist dann über 50. wenn du jetzt 10 zufallszahlen machst ist das prozentual sehr gering, aber bei 10^6 zahlen eben nicht mehr.

@ seppj:

scheinbar nein! sonst würde bei der prozentuale fehler bei der zahl pi bei 10^5 - 10^6 nicht größer als ein promill sein.
der fehler kann nur an einer nicht linearen verteilung der zufallszhalen liegen!

SeppJ

Der Fehler liegt 100% bei dir, das kann ich dir garantieren.

Dass bei statistischen Verfahren dennoch nichts gutes rauskommt, kann übrigens auch andere Gründe haben. Die rand() Zufallszahlen sind z.B. oftmals nicht besonders gut, was ihre Korrellationen angeht. Aber gleichverteilt sind sie garantiert.

Wie kommst du auf die Fehlerabschätzung zur Bestimmung von Pi? Die statistische Bestimmung von Pi konvergiert grauenhaft langsam. Ein Fehler im Promillebereich kommt mir wahnsinnig gut vor für 10^6 Stichproben. Habe es jetzt nicht nachgerechnet, aber das klingt falsch.

SG1

Zeig mal Dein Programm. Deine Beschreibung ist zu unpräzise, da fallen mir gleich mehrere Fehler ein, die zu Deinen Beobachtungen passen.

Also ich bin mir ziemlich sicher, dass die Berechnung stimmt. Der Zufallsgenerator wird durch srand initialisiert und startet somit immer bei einem anderem Wert. Wie erklärst du dir sonst, dass rand() mir mehr kleine als große Zahlen liefert. Was wäre die Lösung des Problems, um die Korrelation besser zu machen?

Also ich kann leider nur einen Teil von meinem Programm einstellen. Die Aufgabe ist grafisch zu lösen, deswegen lasst euch von den unterprogrammen greendots(hwndMain) nicht stören:

BOOL punkte (HWND hwnd)
{
extern int x_k, y_k; //Koordinaten
double z_k; //Fallunterscheidung
double wurzel; //Quadratzwurzel
int zaehler = 0; //Zaehlt die Anzahl
extern int anzahl; //Eingelesene Versuchsanzahl
extern int in; //Anzahl der Punkte im Kreis
in = 0;
extern int out; //Anzahl der Punkte außerhalb des Kreis
out = 0;
int x = 0;
int y = 0;
extern int aus; //Schalter für Animation
extern HWND hwndMain; //Für Programmaufruf von reddots/greendots(hwndMain)
extern int schalter; //Schalter für WM_Paint
extern double gr;
extern double gr2;
printf("\n\nAusknopf: %i", aus);

srand(time(NULL));

while(anzahl+1 >= zaehler)
{
zaehler++;

//X-Koord. würfeln
x_k = rand()%101;
x_k = ((rand()%2)==0)?x_k:-x_k;
my_random_double();

//Y-Koord. würfeln
y_k = rand()%101;
y_k = ((rand()%2)==0)?y_k:-y_k;

//printf("\n\n %i\n %i", x_k, y_k);

wurzel = sqrt((double)x_k*(double)x_k + (double)y_k*(double)y_k);

if(wurzel == 100)
{
z_k = rand()%2;

wurzel = wurzel - z_k;
printf("\n\nWurzel: %lf", wurzel);
}

//Fallunterscheidung
if (wurzel < 100)
{
in++;
if(aus != 1)
{
greendots(hwndMain);
}
}
else
{
out++;
if(aus != 1)
{
reddots(hwndMain);
}
}

}
schalter = 0;

berechnung(hwnd);

return 0;
}

Wo kommt es bei dem Programm denn auf die Verteilung Kleiner/größer RAND_MAX/2 an?

Versuch mal x_k = (rand()%201)-100; (bei y_k auch)

Und srand(time(NULL)); gehört an den Anfang der main()

earli

Mach bitte CODE-Klammern um den Code.

Mit Modulo machst du übrigens leicht die Verteilung kaputt.

main() ist in einer .c Datei. Das ist ein Ausschnitt meiner Unterprogramme.c datei. Da sind nur Unterprogramm enthalten. Deswegen denke ich ist srand dort ganz gut aufgehoben?
Mein ganzes Programm wäre zu lang um es hier reinzukopieren. Vor allem, weil es mehrere Dateien sind.

das mit rand_max war in einem Versuchsprogramm, der meine Vermutung bestätigt hat.

Hilft übrigens nichts! Aber danke für die Antwort

Sorry was sind Codeklammern?

Dieses Programm bestätigt deine Vermutung nicht:

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

#define ANZ  5000000
#define ANZ2 100

int main()
{ long i,j,l=0,k=0;

  srand ( time(NULL) );

  for(j=0;j<ANZ2 ;j++)
  { for(i=0,l=0;i<=ANZ ;i++)
    { if (rand()< (RAND_MAX/2))
        l--;
      else
        l++;
    }
    printf("%ld\n", l);
    k+=l;
  }
  puts("-------");
  printf("%ld\n", k);
  return 0;
}

Zumindest bei mir.

Und srand sollte nur einmal im Programm aufgerufen werden.

Codeklammern kriegst du mit dem C/C++ Button unter den und das sieht dann wie oben aus.

Hmmm komisch. Also ich habe es heute Mittag mit meinem Prof ausprobiert gehabt. Und da sah es nicht so schön aus. Bei deinem sieht es echt sher ausgeglichen aus!
Also rand kann ja nicht einmal so und einmal so funktionieren

earli

Mein Testprogramm:

#include <stdio.h>

int r[201];

int main() {
	int x;
	srand(time(NULL));
	int i;

	for (i = 0; i < 1000 * 1000; i++) {
		x = rand() % 101;
		x = (rand() % 2 == 0) ? x : -x;
		r[x + 100]++;
	}
	for (i = 0; i < 201; i++)
		printf("%d:\t%d\n", i - 100, r[i]);
	return 0;
}

Ergebnis:

Sieht doch super aus. Nur die 0 ist doppelt.

earli schrieb:

Nur die 0 ist doppelt.

Dann mach statt

x = rand() % 101;
        x = (rand() % 2 == 0) ? x : -x;

x_k = (rand()%201)-100

und die doppelte 0 ist auch weg.

earli

DirkB schrieb:

earli schrieb:

Nur die 0 ist doppelt.

Dann mach statt
x = rand() % 101;
        x = (rand() % 2 == 0) ? x : -x;
x_k = (rand()%201)-100
und die doppelte 0 ist auch weg.

Ich hab das ja genau vom Fragesteller übernommen.

Also die Null darf ruhig doppelt vorkommen. Macht ja nichts!

[cpp]

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int main(void)
{
	int zz;
	long anzahl = 10000000;
	int i = 0;
	int	kleiner=0;
	int groesser=0;
  	srand ( time(NULL) );

	while(i <= anzahl)
	{
		zz = rand()%101;
		if(zz <= 50)
		{
			kleiner++;
		}
		else
			{
				groesser++;
			}
	i++;
	}
	printf("\n\nkleiner:%i\n\ngroesser:%i", kleiner, groesser);
  return 0;
}

Du hast mit rand()%101; auch 101 Werte (0 bis 100)

Von 00 bis 050 hast du 51 Werte und
von 51 bis 100 hast du 50 Werte.

Kalr dass das Ungleich verteilt ist.