1 / 21

DES-Simulator in JAVA, objektorientiert

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;

alma
Télécharger la présentation

DES-Simulator in JAVA, objektorientiert

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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_Zaehler extends statistischer_Zaehler public class integrierender_Zaehler extends 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);

More Related