4. Problem bei der Simulation einer M/M/1 Warteschlange

Problem bei der Simulation einer M/M/1 Warteschlange

  • P

    Hallo erstmal ...

    Ich grübel jetzt schon seit ein paar Tagen an dieser Warteschlangensimulation (M/M/1) herum und komme nicht auf die Lösung. Ich hoffe ihr habt ein paar Tipps für mich, oder vieleicht auch eine Lösung ;).

    Ich glaube/hoffe das ich eine M/M/1 Warteschlange in dem folgenden Programmcode in einer zeitorientierten Simulation erstellt habe.

    λ Ankunftsprozesse = 3
    μ Bedienprozesse = 4
    Die Zufallszahlen sollen poissonverteilt sein... was sie auch sind, zumindest habe ich Lambda = 3 mit dem Zufallszahlengenerator auf eine Poissonverteilung geprüft ... bei 5000 und 50000 Zufallszahlen.

    Nach Little lautet die Formel für die durchschnittliche Anzahl an Elementen im System:
    Ns=λ/(μ-λ)=3/(4-3)=3

    In meinem Programmcode soll die Variable NsT die durchschnittliche Anzahl an Elementen im System ausgeben...
    Leider scheint in meinem Programm die durchschnittliche Menge an Elementen = 5.133 zu sein... Dies scheint mir doch ein bisschen zu weit von der errechneten Menge 3 abzuweichen ... Ich kann meinen Fehler nicht finden und hoffe hier sieht ihn vieleicht jemand ...

    Danke schonmal ... hier der Programmcode

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

int poisson(double lambda);
double drand();
int poisson(double lamdba);

int main()
{
double lambda;
int  i, anzZE, ap, bp;
int *ws, Nw=0, Ns=0, XY=0;

anzZE=5000;
ws=new int[anzZE+1]; ws[0]=0;

/*printf("Lambda:%f\n", lambda);*/

	for(i=1;i<=anzZE;i++)
	{
	lambda=3;
	ap=poisson(lambda);
	lambda=4;
	bp=poisson(lambda);
	ws[i]=ap-bp+ws[i-1];
		if(ws[i]<0)
		ws[i]=0;
	Nw=ws[i]+Nw;
	XY=ap+ws[i-1];
	Ns=ap+ws[i-1]+Ns;
	/*printf("i:%d  ap:%d  bp:%d  ws[i]%d  XY:%d\n",i,ap, bp, ws[i], XY);*/
	}

printf("anzZE:%d\n",anzZE);

float NwT=(float)Nw/anzZE, NsT=(float)Ns/anzZE;
printf("NwT:%2.3f  NsT:%2.3f", NwT, NsT);

}

double drand()
{
return (double) rand() / (RAND_MAX + 1);
}

double exponential(double lambda)
{
return -1 / lambda * log(1 - drand());
}

int poisson(double lambda)
{
int zzp=0;
double expz=0;
		while(expz<=1)
		{
		expz=exponential(lambda)+expz;
		zzp++;
		}
return zzp-1;
}
    0
  • C

    Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C++ (auch C++0x und C++11) in das Forum C (C89, C99 und C11) verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.

    0
  • ?

    Das sieht für mich nach einer Art Rundungsfehler aus, weil die Anzahl Elemente ist halt diskret schon sehr klein.

    Setze ich λ auf 3000 und μ auf 4000 erhalte ich NsT:3000.363, was ziemlich nahe an 3·10^irgendwas ist. Der Faktor 1000 ist wohl noch irgend ein Fehler.

    @SeppJ: Das ist C++ 😡 😡 😡

    Siehst du nicht Zeile 17: ws=new int[anzZE+1]; ?

    0
  • P

    Gibt es keine andere Lösung ... wenn es sich wirklich nur um Rundungsfehler handelt kann ich das nicht anders verbessern ...

    Wie kann es zu einem Rundungsfehler von 2 Einheiten kommen ?

    Also 5 anstatt 3?

    Sorry wegen der falschen Einordnung, meines Beitrages ...

    0
Anmelden zum Antworten