1

DES-Simulator in JAVA, objektorientiert

class Element { // Elemente der Listen

public Element Naechstes, Ende;

public double Zeit;

public Ereignis E; // später in Unterklasse?

};

 

public class Ereignis { // Oberklasse für Ereignisse

public String Name;

public void Ereignisroutine(){}

}

 

2

Schlange: <------------------------------------------------ Allgemein: Org-Element ---> Kopf ---> Element ---> ... --->

Schwanzspitze - - - - - - - - - - - - - - - - - - - - - - - - - ->  <----- Länge 0: Org-Element <- - -  <-------------- Länge 1: Org-Element ---> Kopf (= Schwanzspitze) - - - - - - - ->  <---------------------------- Länge 2: Org-Element ---> Kopf ---> Schwanzspitze  - - - - - - - - - - - - - - ->  ----->: Verweis mit Naechstes; - - - ->: Verweis mit Ende   verlaengere hängt ein neues Element an die Schwanzspitze der Schlange, auf das dann

Ende zeigt. Das Org-Element hat den Typ Element

3

public class Liste{ // Klasse für die Ereignisliste und Schlangen der Modelle

private Element Org_Element;

public Liste() // Konstruktor, baut bei der Inkarnation

// eine leere Liste zusammen

 

public void verlaengere(double t, Ereignis E)

// die Liste am Ende um ein Element

// mit dem Zeiteintrag t und Ereignisroutine

 

public boolean leer() // Liste leer?

 

public double Zeit_am_Kopf ()

 

public Ereignis Ereignis_am_Kopf()

 

public void entferne_Kopf()

 

public void leeren() // Liste leeren

4

public void plane_Ereignis(double wann, Ereignis E)

// ordnet neues Element gemäß seines Zeit-Attributes

// in die Liste ein, bei gleicher Zeit hinter das

// hinter das vorhandene Ereignis.

// Das andere Attribut ist die Ereignisroutine

5

public class Zufalls_Zahlen { static private long faktor=16807; static private long modul=1024*1024*2048-1; static private double v = 1 / (double)modul; private long y; public int[] saat = {1, 1550655590, 766698560, 1645116277, 1154667137, 1961833381,

460575272, ..... 1793656969, 1701980729, 1883864564, 251608257, 642486710,

1115145546, 1021484058 // Saat für Ströme 1 bis 128, je 2^24 Zufallszahlen auseinander, // der letzte Strom aber nur 2^24-1 Zahlen public Zufalls_Zahlen(int stromnummer) // Setze den Generator auf // den Beginn des Stromes

6

public Zufalls_Zahlen() // Konstruktor, 1. Strom

 

// Zufallszahlen unterschiedlicher Verteilungen:

public double gleichverteilt_0_1()

 

public double exponentiell_mit_Parameter(double par)

 

public double gleichverteilt(double a, double b)

}

7

public class statistischer_Zaehler { // Oberklasse der statistischen Zaehler

public void initialisiere(double Anfangsordinate, double Anfang){

// Integrierender Zaehler

public String Name;

public static int summierend=0,

integrierend=1,

ordnend=2,

VI=3;

Haeufigkeiten=4;

public int Art; // summierend, integrierend, ordnend,

// fuer Vertrauensintervalle (VI),

// fuer Haeufigkeitsverteilungen

8

public void akkumuliere(double Veraenderung) // Neue Ordinate, integrierender Zaehler

public void addiere(double Summand) // Weiterer Wert, summierender Zaehler

public double Wert(){return 0;} // Integral

public double Mittelwert() {return 0;}

public double Summe() {return 0;}

public double Anzahl() {return 0;}}

public class summierender_Zaehlerextends statistischer_Zaehler public class integrierender_Zaehlerextends statistischer_Zaehler

9

public class Simulation { // Grundalgorithmus, Uhr

 

public Liste E_Liste = new Liste();

public double Uhr;

Modell M;

public Simulation(Modell M0) // Konstruktor, Initialisierung

{ Uhr = 0; M = M0; }

 

public void initialisiere() { E_Liste.leeren(); }

10

public void simuliere(double Anfangszeit, double Endzeit)

{ Ereignis E;

Uhr = Anfangszeit;

if (!E_Liste.leer() )

if (M.Spur >0) M.Spurdaten(null);

while (!E_Liste.leer() && Uhr <= Endzeit)

{ Uhr = E_Liste.Zeit_am_Kopf();

if (Uhr <= Endzeit)

{ E = E_Liste.Ereignis_am_Kopf();

E.Ereignisroutine();

E_Liste.entferne_Kopf();

if (M.Spur >0) M.Spurdaten(E);

}

}

}

}

11

public class Modell { // Oberklasse der Modelle

public Modell(){}

public String Modellbeschreibung, Bericht;

public int Spur;

public void simuliere(double t){}

 

public void Spurdaten(Ereignis E){}

}

12

public class WSS_Modell extends Modell {

// Konstanten:

// Zustaende des Bedieners:

public final static int frei = 0, belegt = 1;

 

// Arten des Bedienungsbeginns:

public final static int sofort = 1, spaeter = 0;

// Ereignisobjekte mit Ereignisroutinen:

Ereignis Ankunft, Bedienungsbeginn, Bedienungsende, Simulationsende;

 

// Zustand:

public int N; // Anzahl der Kunden im Warteschlangensystem (WSS)

public int Q; // Anzahl der wartenden Kunden

public int B; // Bediener frei oder belegt

public Liste Warteschlange = new Liste();

13

// Attribute des Modells: public double lambda, a, b; // Statistische Zaehler: public statistischer_Zaehler // integrierend: Kundenzahl, Wartende, Bedienerbelegung, // summierend: Wartezeiten, Bedienungsstart; // Experimentplanung: public double Endzeitpunkt; public int Zufallszahlen_Strom; public Zufalls_Zahlen ZZahl; public Simulation S;

14

// Ereignisroutinen:

class Ankunftsereignis extends Ereignis { // Lokale Klasse

Ankunftsereignis(){ this.Name = "Ankunft"; }

public void Ereignisroutine(){

// Neuer Zustand:

N++; Q++;

Warteschlange.verlaengere(S.Uhr,null);

// plane Ereignisse:

if (B == frei) // Bedeiner frei

{ S.E_Liste.plane_Ereignis(S.Uhr, Bedienungsbeginn); // sofort

}

// Naechste Ankunft:

S.E_Liste.plane_Ereignis(S.Uhr +

ZZahl.exponentiell_mit_Parameter(lambda), Ankunft);

15

// Statistik:

Kundenzahl.akkumuliere(+1);

Wartende.akkumuliere(+1);

if (B == frei) { // Bediener frei

Bedienungsstart.addiere(sofort);

} else {

Bedienungsstart.addiere(spaeter);

}

}

}

 

class Bedienungsbeginnereignis extends Ereignis

 

class Bedienungsendeereignis extends Ereignis

 

class Simulationsendeereignis extends Ereignis{

Simulationsendeereignis(){ this.Name = "Simulationsende";

}

16

 public void Ereignisroutine(){ // Simulationsende (Fortsetzung möglich) // Bis zur aktuellen Uhrzeit akkumulieren: Kundenzahl.akkumuliere(0); Wartende.akkumuliere(0); Bedienerbelegung.akkumuliere(0);  Bericht = "\n\n\n"+ "******************************************************" + "\n" + "* Bericht *" + "\n" + "******************************************************" + "\n" + "Mittlere Kundenzahl im System= " + Kundenzahl.Mittelwert() + "\n" + "Mittlere Kundenzahl in der Warteschlange= " + Wartende.Mittelwert() + "\n" + "Mittlere Kundenzahl im Bediener= " + Bedienerbelegung.Mittelwert() + "\n" + "Mittlere Wartezeit= " + Wartezeiten.Mittelwert() + "\n" + " Anzahl der Kunden, die die Warteschlange \n" + " wieder verlassen haben= " + Wartezeiten.Anzahl() + "\n" + "Mittlerer Anteil der Kunden, die nicht auf Bedienung \n" + " warten mussten= " + Bedienungsstart.Mittelwert() + "\n" + " Anzahl der Kunden, deren Bedienung begann= " + Bedienungsstart.Anzahl() + "\n" + "Zufallszahlenstrom " + Zufallszahlen_Strom + "\n\n\n"; } }

17

// Konstruktor, initialisiert ein Modell:

public WSS_Modell(int N0, int Q0, int B0,

double lambda_aktuell, double a_aktuell, double b_aktuell,

int Stromnummer, int Spur0)

{ B = B0; N = N0; Q = Q0;

lambda = lambda_aktuell ; // Ankunftsrate

a = a_aktuell; b = b_aktuell; // Bedienzeiten gleichverteilt zwischen a und b

ZZahl = new Zufalls_Zahlen(Stromnummer);

Zufallszahlen_Strom = Stromnummer;

Spur = Spur0;

S = new Simulation(this);

18

Ankunft = new Ankunftsereignis();

Bedienungsbeginn = new Bedienungsbeginnereignis();

Bedienungsende = new Bedienungsendeereignis();

Simulationsende = new Simulationsendeereignis();

Kundenzahl = new integrierender_Zaehler("Kundenzahl",S);

Wartende = new integrierender_Zaehler("Wartende",S);

Bedienerbelegung = new integrierender_Zaehler("Bedienerbelegung",S);

Wartezeiten = new summierender_Zaehler("Wartezeiten");

Bedienungsstart= new summierender_Zaehler("Bedienungsstart");

19

Modellbeschreibung =

"******************************************************" + "\n" +

"* Warteschlangenmodell *" + "\n" +

"******************************************************" + "\n" +

"Poissonscher Ankunftsprozess mit Rate lambda= " +

+ lambda + "\n" +

"Bedienzeiten gleichverteilt zwischen a= " +

+ a + " und b=" + b + "\n" +

"Anfangszustand: " + "\n" +

" Anzahl Kunden im System, N= " + N + "\n" +

" Anzahl Kunden in der Warteschlange, Q= " + Q + "\n" +

" Anzahl Kunden in Bedienung, B = " + B + "\n" +

"\n\n";

}

20

public void simuliere(double t)

{ S.initialisiere();

// plane erste Ankunft:

S.E_Liste.plane_Ereignis(

ZZahl.exponentiell_mit_Parameter(lambda), Ankunft);

 

// plane Simulationsende:

Endzeitpunkt = t;

S.E_Liste.plane_Ereignis(Endzeitpunkt, Simulationsende);

// Statistische Zähler: Automatisch auf 0,0 gesetzt

S.simuliere(0,t);

}

 

public void Spurdaten(Ereignis E)

 

} // Ende der Klasse WSS-Modell

21

Hauptprogramm:

 

Modell M = new WSS_Modell(0, // Anzahl Kunden

0, // Anzahl in WS

WSS_Modell.frei,

0.2, // Ankunftsrate

2.0, // minimale Bedienzeit

3.0, // maximale "

1, // Zufallszahlenstrom

Spur);

System.out.println(M.Modellbeschreibung);

M.simuliere(t);

System.out.println(M.Bericht);