WOJSKOWA AKADEMIA TECHNICZNA 

 

 

 

Podstawy symulacji

 

Zadanie laboratoryjne nr 2

 

 

 

 

 

 

 

Prowadzący : dr inż. Jarosław Rulka 
Grupa: I7G2S1 
Wykonawca: 

Łukasz Kołodziejski 

 

Napisać program symulujący działanie sieci SMO jak na rysunku: 

 

Przy realizacji zadania należy przyjąć następujące dane z listy przedstawionej poniżej: 
a) 

rozkład zmiennych T

j

: (nrDz + i) mod 6 + 1; 

b) 

rozkład zmiennych O

i

: (nrDz + i + 1) mod 6 + 1; 

c)  L

i

: (nrDz + i) mod 2 + 1; 

d)  AL

i

: (nrDz + i + 2) mod 3 + 1; 

e)  R

j

 = (nrDz + i + 5) mod 3 + 1; 

f)  M

i

 = (nrDz + i + 2) mod 4 + 1; 

g) 

Blokowanie zgłoszeń 1. SMO; 

h)  Klienci niecierpliwi w SMO

i

 : N

i

 = (nrDz + i)  mod 4 (ograniczony czas oczekiwania na rozpoczęcie obsługi); 

gdzie: 
i – numer SMO; 
j – numer strumienia; 
T

j

 – zmienna losowa oznaczająca czas pomiędzy kolejnymi napływami zgłoszeń do systemu; 

O

i

 – zmienna losowa oznaczająca czas obsługi pojedynczego zgłoszenia w gnieździe; 

N

i

 – zmienna losowa oznaczająca czas niecierpliwości zgłoszenia (gdy i = 0 => zgłoszenia cierpliwe); 

R

j

 – zmienna losowa oznaczająca wielkość paczki zgłoszeń (wchodzących w tej samej chwili) j-tego strumienia; 

p

k

 – prawdopodobieństwa przemieszczenia się zgłoszenia po danym łuku; 

L

i

 – długość kolejki i-tego SMO; 

AL.

i

 – algorytmy kolejek (w przypadku istnienia kolejki z priorytetami należy przyjąć, że zgłoszenia posiadają 

priorytety); 
1.  Rozkłady zmiennych losowych: 

1.1.  Wykładniczy 
1.2.  Erlanga 
1.3.  Normalny 
1.4.  Jednostajny 
1.5.  Trójkątny 
1.6.  Weibulla 

2.  Długości kolejek pojedynczych SMO 

2.1.  ograniczone (możliwe straty) 
2.2.  nieograniczone 

3.  Algorytm kolejek: 

3.1.  FIFO 
3.2.  LIFO 
3.3.  Z priorytetami 

4.  Liczba stanowisk obsługi w gniazdach (1-M) 
5.  Ilość zgłoszeń jednocześnie napływających do systemu (1-R) 
Pozostałe dane należy określać na początku symulacji. 

 

SMO 

SMO 

O

2 

O

3 

SMO 

O

1 

T

1 

p

1 

1-p

1 

p

2 

p

3 

Rozwiązanie dla numeru 2. 

Rozkłady zmiennej losowej oznaczający czas pomiędzy kolejnymi napływami zgłoszeń do systemu: 
T1 – rozkład jednostajny 
Paczka R1 = 1 
Rozkłady zmiennych losowych oznaczających czas obsługi pojedynczego zgłoszenia w gnieździe: 
O1 – rozkład trójkątny 
O2 – rozkład Weibull’a 
O3 – rozkład wykładniczy 
Długości kolejek SMO: 
L1 – nieograniczona 
L2 – ograniczona 
L3 – nieograniczona 
Algorytmy kolejek: 
AL1 – z priorytetami 
AL2 – FIFO 
AL3 – LIFO 
Liczba stanowisk obsługi: 
M1 – 2 
M2 – 3 
M3 – 4 
Zmienne losowe oznaczające czas niecierpliwości zgłoszenia: 
N1 – rozkład normalny 
N2 – zgłoszenie cierpliwe 
N3 – rozkład wykładniczy 
Blokowanie zgłoszeń w 1 SMO. 
 
Sposób rozwiązania 
Na początku generowani są klienci, którzy udają się do pierwszej kolejki (z priorytetami) po jednym 
kliencie. Do każdego klienta zostaje przypisany priorytet i prawdopodobieństwo przejść między 
elementami systemu. Z pierwszej kolejki klient przechodzi do pierwszego gniazda obsługi o rozkładzie 
trójkątnym i ilości stanowisk obsługi  równej 2, aby zostać  tam obsłużonym. Po wyjściu z pierwszego 
gniazda klient z nadanym mu wcześniej prawdopodobieństwem p1 pójdzie do gniazda numer 2 o 
rozkładzie Weibull’a z trzema stanowiskami obsługi, bądź z prawdopodobieństwem 1-p1 uda się do 
trzeciego gniazda o rozkładzie wykładniczym z czterema stanowiskami obsługi. Po wyjściu z gniazda 
drugiego ,klient może powrócić do niego (prawdopodobieństwo p2) , bądź opuścić system. Po 
wyjściu z gniazda trzeciego klient może powrócić do gniazda pierwszego (prawdopodobieństwo p3), 
bądź opuścić system.  Jeżeli powróci do systemu, to prawdopodobieństwo, że przy następnym 
wyborze też pozostanie w systemie zostanie zmniejszone. 
 
 
 
 
 
 

Użyte rozkłady: 
-Rozkład jednostajny: 

 

-Rozkład trójkątny:  
 

 

-Rozkład Weibulla: 

Gęstość: 

 

 

Dystrybuanta: 

 

 
-Rozkład wykładniczy: 

Gęstość: 

 

 

Dystrybuanta: 

 

 

 

 

 
 
 
Kod programu: 

MAIN MODULE wooka; 
 
(*=====================================================================biblioteki=========*) 
 
FROM IOMod IMPORT ReadKey; (*we/wy*) 
FROM RandMod IMPORT RandomObj, Random; (*liczby pseudolosowe*) 
FROM ListMod IMPORT QueueList; (*struktury z rekordami*) 
FROM GrpMod IMPORT QueueObj, StackObj, RankedObj; (*struktury z obiektami*) 
FROM SimMod IMPORT SimTime, StartSimulation, TriggerObj; (*operacje zwiazane z symulacja*) 
FROM StatMod IMPORT SREAL, RStatObj,ITimedStatObj, TSINTEGER; (*monitory statyczne , zmienne real, wazony czasem*) 
FROM IOMod IMPORT StreamObj, ALL FileUseType;  
 
 
(*======================================================================obiekty===========*) 
 
TYPE 
GeneratorObj = OBJECT; FORWARD; 
Kolejka1Obj = OBJECT; FORWARD; 
Kolejka2Obj = OBJECT; FORWARD; 
Kolejka3Obj = OBJECT; FORWARD; 
Okienko1Obj = OBJECT; FORWARD; 
Okienko2Obj = OBJECT; FORWARD; 
Okienko3Obj = OBJECT; FORWARD; 
KlientObj = OBJECT; FORWARD; 
 
GeneratorObj = OBJECT(RandomObj); 
 

kom: BOOLEAN; 

 

lo: REAL; 

 

hi: REAL; 

 

GenLos: RandomObj; 

 

Kolejka1: Kolejka1Obj; 

 

showst: INTEGER; 

 

TELL METHOD Generuj(IN LiczbaOsob:INTEGER); 

 

ASK METHOD Ustaw(IN l: REAL; IN h: REAL; IN Kol:Kolejka1Obj; IN showst2:INTEGER; IN kw:BOOLEAN); 

 
END OBJECT; 
 
Kolejka1Obj = OBJECT(RankedObj); 
 

kom: BOOLEAN; 

 

dlugosc: TSINTEGER; 

 

okienko1: Okienko1Obj; 

 

przyjete: INTEGER; 

 

odrzucone: INTEGER; 

 

ASK METHOD Wstaw(IN Kl:KlientObj; IN kw:BOOLEAN); 

 

ASK METHOD Ustaw(IN okien: Okienko1Obj); 

END OBJECT; 
 
Kolejka2Obj = OBJECT(QueueObj); 
 

kom: BOOLEAN; 

 

ograniczenie: INTEGER; 

 

okienko2: Okienko2Obj; 

 

dlugosc: TSINTEGER; 

 

przyjete: INTEGER; 

 

odrzucone: INTEGER; 

 

ASK METHOD Wstaw(IN Kl:KlientObj; IN kw:BOOLEAN); 

 

ASK METHOD Ustaw(IN okien: Okienko2Obj; IN ogran: INTEGER); 

END OBJECT; 
 
Kolejka3Obj = OBJECT(StackObj); 
 

kom: BOOLEAN; 

 

dlugosc: TSINTEGER; 

 

przyjete: INTEGER; 

 

odrzucone: INTEGER; 

 

okienko3: Okienko3Obj; 

 

ASK METHOD Wstaw(IN Kl:KlientObj; IN kw:BOOLEAN); 

 

ASK METHOD Ustaw(IN okien: Okienko3Obj); 

END OBJECT; 
 
Okienko1Obj = OBJECT(RandomObj); 
 

kom: BOOLEAN; 

 

min: REAL; 

 

mode: REAL; 

 

max: REAL; 

 

Kolejka1: Kolejka1Obj; 

 

Kolejka2: Kolejka2Obj; 

 

Kolejka3: Kolejka3Obj; 

 

los:RandomObj; 

 

stanowiska: TSINTEGER; 

 

TELL METHOD Obsluguj(); 

 

ASK METHOD Ustaw(IN mi:REAL; IN mo:REAL; IN ma:REAL; IN Kol1: Kolejka1Obj; IN Kol2:Kolejka2Obj; IN Kol3:Kolejka3Obj; IN 

kw:BOOLEAN); 
END OBJECT; 
 
Okienko2Obj = OBJECT(RandomObj); 
 

kom: BOOLEAN; 

 

shape: REAL; 

 

scale: REAL; 

 

czasprzebywania:SREAL; 

 

los:RandomObj; 

 

Kolejka2: Kolejka2Obj; 

 

stanowiska: TSINTEGER; 

 

TELL METHOD Obsluguj(); 

 

ASK METHOD Ustaw(IN sh: REAL; IN sc: REAL; IN kol:Kolejka2Obj; IN kw:BOOLEAN); 

END OBJECT; 
 
Okienko3Obj = OBJECT(RandomObj); 
 

kom: BOOLEAN; 

 

meanwyk: REAL; 

 

czasprzebywania:SREAL; 

 

Kolejka3: Kolejka3Obj; 

 

Kolejka1: Kolejka1Obj; 

 

los:RandomObj; 

 

stanowiska: TSINTEGER; 

 

TELL METHOD Obsluguj(); 

 

ASK METHOD Ustaw(IN meanw: REAL; IN kol: Kolejka3Obj; IN kol1: Kolejka1Obj; IN kw:BOOLEAN); 

END OBJECT; 
 
KlientObj = OBJECT(RandomObj); 
 

Nr: INTEGER; 

 

CzasWejscia: REAL; 

 

Kolejka1:Kolejka1Obj; 

 

show: BOOLEAN; 

 

ASK METHOD ustawCzas(); 

 

ASK METHOD usun(); 

 

ASK METHOD ustaw(IN numer: INTEGER; IN kol:Kolejka1Obj; IN show2:BOOLEAN); 

END OBJECT; 
 
OBJECT GeneratorObj; 

 

ASK METHOD Ustaw(IN l: REAL; IN h: REAL; IN Kol:Kolejka1Obj; IN showst2:INTEGER; IN kw:BOOLEAN); 

 

BEGIN 

 

 

kom:=kw; 

 

 

lo:=l; 

 

 

hi:=h; 

 

 

Kolejka1:=Kol; 

 

 

showst:=showst2; 

 

END METHOD; 

 
 

TELL METHOD Generuj(IN LiczbaOsob:INTEGER); 

 

VAR 

 

 

i:INTEGER; 

 

 

kl:KlientObj; 

 

 

showst2:BOOLEAN; 

 

BEGIN 

 

 

FOR i:=1 TO LiczbaOsob BY 1 

 

 

 

WAIT DURATION UniformReal(lo,hi); 

 

 

 

END WAIT; 

 

 

 

NEW(kl); 

 

 

 

IF (showst = i) OR (showst = 0) 

 

 

 

 

showst2:=TRUE; 

 

 

 

ELSE 

 

 

 

 

showst2:=FALSE; 

 

 

 

END IF; 

 

 

 

ASK kl TO ustaw(i,Kolejka1,showst2); 

 

 

 

IF (kom) 

 

 

 

 

OUTPUT(SimTime," -powstal nowy klient o numerze [", ASK kl TO Nr,"]."); 

 

 

 

END IF; 

 

 

 

ASK Kolejka1 TO Wstaw(kl, kom); 

 

 

END FOR; 

 

END METHOD; 

END OBJECT; 
 
OBJECT Kolejka1Obj; 
 

ASK METHOD Wstaw(IN Klient:KlientObj; IN kw:BOOLEAN); 

 

BEGIN 

 

 

 

kom:=kw; 

 

 

 

Add(Klient); 

 

 

 

ASK Klient TO ustawCzas; 

 

 

 

IF (kom) 

 

 

 

OUTPUT(SimTime, " -klient o numerze [", ASK Klient TO Nr, "] zostal wprowadzony do kolejki [1]"); 

 

 

 

END IF; 

 

 

 

dlugosc:=numberIn; 

 

 

 

IF ASK okienko1 TO stanowiska < 2 

 

 

 

 

INC(przyjete); 

 

 

 

 

TELL okienko1 TO Obsluguj; 

 

 

 

ELSE 

 

 

 

 

INC(odrzucone); 

 

 

 

END IF; 

 

END METHOD; 

 

ASK  METHOD Ustaw(IN gnd:Okienko1Obj); 

 

BEGIN 

 

 

okienko1:=gnd; 

 

END METHOD; 

END OBJECT; 
 
OBJECT Kolejka2Obj; 
 

ASK METHOD Wstaw(IN Klient:KlientObj; IN kw:BOOLEAN); 

 

BEGIN 

 

 

 

kom:=kw; 

 

 

IF ograniczenie > numberIn; 

 

 

 

Add(Klient); 

 

 

 

 

IF (kom) 

 

 

 

 

OUTPUT(SimTime, " -klient o numerze [", ASK Klient TO Nr, "] zostal wprowadzony do kolejki 

[2]"); 
 

 

 

 

END IF; 

 

 

 

dlugosc:=numberIn; 

 

 

 

IF ASK okienko2 TO stanowiska < 3 

 

 

 

 

INC(przyjete); 

 

 

 

 

TELL okienko2 TO Obsluguj; 

 

 

 

ELSE 

 

 

 

 

INC(odrzucone); 

 

 

 

END IF; 

 

 

ELSE 

 

 

 

IF (kom) 

 

 

 

OUTPUT(SimTime, " -klient o numerze [", ASK Klient TO Nr,"] zostal odrzucony z kolejki [2]"); 

 

 

 

END IF; 

 

 

 

DISPOSE(Klient); 

 

 

 

 

END IF; 

 

END METHOD; 

 

 

 

ASK METHOD Ustaw(IN gnd: Okienko2Obj; IN ogran:INTEGER); 

 

BEGIN 

 

 

okienko2:=gnd; 

 

 

ograniczenie:=ogran; 

 

END METHOD; 

END OBJECT; 
 
OBJECT Kolejka3Obj; 
 

ASK METHOD Wstaw(IN Klient:KlientObj; IN kw:BOOLEAN); 

 

BEGIN 

 

 

 

kom:=kw; 

 

 

 

Add(Klient); 

 

 

 

IF (kom) 

 

 

 

OUTPUT(SimTime, " -klient o numerze [", ASK Klient TO Nr, "] zostal wprowadzony do kolejki [3]"); 

 

 

 

END IF; 

 

 

 

dlugosc:=numberIn; 

 

 

 

IF ASK okienko3 TO stanowiska < 4 

 

 

 

 

INC(przyjete); 

 

 

 

 

TELL okienko3 TO Obsluguj; 

 

 

 

ELSE 

 

 

 

 

INC(odrzucone); 

 

 

 

END IF; 

 
 

END METHOD; 

 

 

 

ASK METHOD Ustaw(IN gnd: Okienko3Obj); 

 

BEGIN 

 

 

okienko3:=gnd; 

 

END METHOD; 

END OBJECT; 
 
OBJECT Okienko1Obj; 
 

ASK METHOD Ustaw(IN mi:REAL; IN mo:REAL; IN ma:REAL; IN Kol1: Kolejka1Obj; IN Kol2:Kolejka2Obj; IN Kol3:Kolejka3Obj; IN 

kw:BOOLEAN); 
 

BEGIN 

 

 

kom:=kw; 

 

 

min:=mi; 

 

 

mode:=mo; 

 

 

max:=ma; 

 

 

Kolejka1:=Kol1; 

 

 

Kolejka2:=Kol2; 

 

 

Kolejka3:=Kol3; 

 

 

NEW(los); 

 

 

stanowiska:=0; 

 

END METHOD; 

 

 

 

TELL METHOD Obsluguj(); 

 

VAR  

 

 

kl:KlientObj; 

 

 

zmlos:REAL; 

 

BEGIN 

 

 

 

 

 

WHILE ASK Kolejka1 TO numberIn > 0 

 

 

INC(stanowiska); 

 

 

 

kl:=ASK Kolejka1 TO Remove(); 

 

 

 

IF (kom) 

 

 

 

OUTPUT(SimTime, "  -rozpoczeto obsluge klienta o numerze [", ASK kl TO Nr,"] w okienku [1] | stan 

stanowiska:", stanowiska); 
 

 

 

END IF; 

 

 

 

WAIT DURATION Triangular(min,mode,max) 

 

 

 

ON INTERRUPT 

 

 

 

END WAIT; 

 

 

 

 

 

 

 

IF (kom) 

 

 

 

OUTPUT(SimTime, " -klient o numerze [", ASK kl TO Nr, "] zostal obsluzony w okienku [1]"); 

 

 

 

END IF; 

 
 

 

 

zmlos:=ASK los Sample(); 

 

 

 

 

 

 

 

IF zmlos > 0.7 

 

 

 

 

IF (kom) 

 

 

 

 

OUTPUT(SimTime, " -okienko [1] przekierowuje klienta o numerze [", ASK kl TO Nr,"] do kolejki 

[2] | zmienna losowa=", zmlos); 
 

 

 

 

END IF; 

 

 

 

 

ASK Kolejka2 TO Wstaw(kl, kom); 

 

 

 

ELSE 

 

 

 

 

IF (kom) 

 

 

 

 

OUTPUT(SimTime, " -okienko [1] przekierowuje klienta o numerze [", ASK kl TO Nr,"] do kolejki 

[3] | zmienna losowa=", zmlos); 
 

 

 

 

END IF; 

 

 

 

 

ASK Kolejka3 TO Wstaw(kl, kom); 

 

 

 

END IF; 

 

 

DEC(stanowiska); 

 

 

END WHILE; 

 

END METHOD; 

END OBJECT; 
 
OBJECT Okienko2Obj; 
 

ASK METHOD Ustaw(IN sh: REAL; IN sc: REAL; IN kol:Kolejka2Obj; IN kw:BOOLEAN); 

 

BEGIN 

 

 

kom:=kw; 

 

 

shape:=sh; 

 

 

scale:=sc; 

 

 

Kolejka2:=kol; 

 

 

stanowiska:=0; 

 

 

NEW(los); 

 

END METHOD; 

 
 

TELL METHOD Obsluguj(); 

 

VAR 

 

 

kl:KlientObj; 

 

 

zmlos:REAL; 

 

BEGIN 

 

 

INC(stanowiska); 

 

 

WHILE ASK Kolejka2 TO numberIn > 0 

 

 

 

 

kl:=ASK Kolejka2 TO Remove(); 

 

 

 

IF (kom) 

 

 

 

OUTPUT(SimTime, "  -rozpoczeto obsluge klienta o numerze [", ASK kl TO Nr,"] w okienku [2] | stan 

stanowiska:", stanowiska); 

 

 

 

 

 

END IF; 

 

 

 

WAIT DURATION Weibull(shape,scale) 

 

 

 

ON INTERRUPT 

 

 

 

END WAIT; 

 

 

 

IF (kom) 

 

 

 

OUTPUT(SimTime, " -klient o numerze [", ASK kl TO Nr, "] zostal obsluzony w okienku [2]"); 

 

 

 

END IF; 

 

 

 

zmlos:=ASK los Sample(); 

 

 

 

 

 

 

 

IF zmlos > 0.3 

 

 

 

 

IF (kom) 

 

 

 

 

OUTPUT(SimTime, " -okienko [2] przekierowuje klienta o numerze [", ASK kl TO Nr,"] do kolejki 

[2] | zmienna losowa=", zmlos); 
 

 

 

 

END IF; 

 

 

 

 

ASK Kolejka2 TO Wstaw(kl,kom); 

 

 

 

ELSE 

 

 

 

 

IF (kom) 

 

 

 

 

OUTPUT(SimTime, " -klient o numerze [", ASK kl TO Nr, "] opuscil system | zmienna losowa=", 

zmlos); 
 

 

 

 

END IF; 

 

 

 

 

czasprzebywania:=SimTime - ASK kl TO CzasWejscia; 

 

 

 

 

ASK kl TO usun(); 

 

 

 

END IF; 

 
 

 

END WHILE; 

 

 

DEC(stanowiska); 

 

END METHOD; 

END OBJECT; 
 
OBJECT Okienko3Obj; 
 

ASK METHOD Ustaw(IN meanw: REAL; IN kol: Kolejka3Obj; IN kol1: Kolejka1Obj; IN kw:BOOLEAN); 

 

BEGIN 

 

 

kom:=kw; 

 

 

meanwyk:=meanw; 

 

 

Kolejka3:=kol; 

 

 

NEW(los); 

 

 

Kolejka1:=kol1; 

 

END METHOD; 

 

 

 

TELL METHOD Obsluguj(); 

 

VAR 

 

 

kl:KlientObj; 

 

 

zmlos:REAL; 

 

BEGIN 

 

 

INC(stanowiska); 

 

 

WHILE ASK Kolejka3 TO numberIn > 0 

 

 

 

kl:=ASK Kolejka3 TO Remove(); 

 

 

 

IF (kom) 

 

 

 

OUTPUT(SimTime, "  -rozpoczeto obsluge klienta o numerze [", ASK kl TO Nr,"] w okienku [3] | stan 

stanowiska:", stanowiska); 
 

 

 

END IF; 

 

 

 

WAIT DURATION Exponential(meanwyk) 

 

 

 

ON INTERRUPT; 

 

 

 

END WAIT; 

 

 

 

IF (kom) 

 

 

 

OUTPUT(SimTime," -klient o numerze [", ASK kl TO Nr, "] zostal obsluzony w okienku [2]"); 

 

 

 

END IF; 

 

 

 

zmlos:=ASK los Sample(); 

 

 

 

 

 

 

 

IF zmlos > 0.4 

 

 

 

 

IF (kom) 

 

 

 

 

OUTPUT(SimTime, " -okienko [3] przekierowuje klienta o numerze [", ASK kl TO Nr,"] do kolejki 

[1] | zmienna losowa=", zmlos); 
 

 

 

 

END IF; 

 

 

 

 

ASK Kolejka1 TO Wstaw(kl,kom); 

 

 

 

ELSE 

 

 

 

 

IF (kom) 

 

 

 

 

OUTPUT(SimTime, " -klient o numerze [", ASK kl TO Nr, "] opuscil system | zmienna losowa=", 

zmlos); 
 

 

 

 

END IF; 

 

 

 

 

czasprzebywania:=SimTime - ASK kl TO CzasWejscia; 

 

 

 

 

ASK kl TO usun(); 

 

 

 

END IF; 

 

 

END WHILE; 

 

 

DEC(stanowiska); 

 

END METHOD; 

END OBJECT; 
 
OBJECT KlientObj; 
 

ASK METHOD ustaw(IN numer: INTEGER; IN kol:Kolejka1Obj; IN show2:BOOLEAN); 

 

BEGIN 

 

 

Nr:=numer; 

 

 

show:=show2; 

 

 

Kolejka1:=kol; 

 

END METHOD; 

 
 

ASK METHOD usun(); 

 

BEGIN 

 

 

DISPOSE(SELF); 

 

END METHOD; 

 
 

ASK METHOD ustawCzas(); 

 

BEGIN 

 

 

CzasWejscia:=SimTime; 

 

END METHOD; 

END OBJECT; 
 
(*============================================================================main=======*) 
 
VAR 
 

okienko1:Okienko1Obj; 

 

okienko2:Okienko2Obj; 

 

okienko3:Okienko3Obj; 

 

kolejka1:Kolejka1Obj; 

 

kolejka2:Kolejka2Obj; 

 

kolejka3:Kolejka3Obj; 

 

generator:GeneratorObj; 

 

ch:CHAR; 

 

lo,hi,min,mean,max,shape,scale,meanwyk,praw1,praw2,praw3:REAL; 

 

ogran,losob,stwatch:INTEGER; 

 

monITS1, monITS2, monITS3, monSTA1, monSTA2, monSTA3: ITimedStatObj; 

 

monRS3, monRS2: RStatObj; 

 

KomunikatyWlaczone : BOOLEAN; 

 

 

BEGIN 
 

OUTPUT ("!Podstawy symulacji!"); 

 

OUTPUT (" sieci kolejkowe "); 

 

OUTPUT ("    zadanie 2    "); 

 

OUTPUT (" "); 

 

OUTPUT ("Aby rozpoczac symulacje prosze wcisnac dowolny klawisz"); 

 

OUTPUT (" domyslnie komunikaty sa wyswietlane"); 

 

OUTPUT (" nacisnij 'n' aby nie wyswietlac komunikatow "); 

 

ch := ReadKey(); 

 
 

IF ((ch = 'n') OR (ch = 'N')) 

 

 

OUTPUT ("ie beda wyswietlane komunikaty."); 

 

END IF; 

 
 

OUTPUT (""); 

 

 

 

KomunikatyWlaczone := TRUE; 

 

IF ((ch = 'n') OR (ch = 'N')) 

 

 

KomunikatyWlaczone := FALSE; 

 

ELSE  

 

KomunikatyWlaczone := TRUE; 

 

END IF; 

 
 
 
 

OUTPUT (" "); 

 

OUTPUT ("ROZPOCZECIE SYMULACJI"); 

 

OUTPUT (" "); 

 
 

NEW(okienko1); 

 

NEW(okienko2); 

 

NEW(okienko3); 

 

NEW(kolejka1); 

 

NEW(kolejka2); 

 

NEW(kolejka3); 

 

NEW(generator); 

 

 

 

stwatch:=0; 

 

ogran:=5; 

 

lo:=1.2; 

 

hi:=5.6; 

 

min:=2.3; 

 

mean:=4.3; 

 

max:=5.6; 

 

shape:=3.5; 

 

scale:=7.8; 

 

meanwyk:=4.6; 

 

losob:=15; 

 

 

 

ASK generator TO Ustaw(lo,hi, kolejka1,stwatch, KomunikatyWlaczone); 

 

ASK kolejka1 TO Ustaw(okienko1); 

 

 

ASK okienko1 TO Ustaw(min,mean,max,kolejka1,kolejka2,kolejka3, KomunikatyWlaczone); 

 

ASK kolejka2 TO Ustaw(okienko2, ogran); 

 

 

ASK okienko2 TO Ustaw(shape,scale,kolejka2, KomunikatyWlaczone); 

 

ASK kolejka3 TO Ustaw(okienko3); 

 

 

ASK okienko3 TO Ustaw(meanwyk,kolejka3,kolejka1, KomunikatyWlaczone); 

 
 

TELL generator TO Generuj(losob); 

 

 

 

StartSimulation(); 

 

monITS1 := GETMONITOR(ASK kolejka1 TO dlugosc, ITimedStatObj); 

 

monITS2 := GETMONITOR(ASK kolejka2 TO dlugosc, ITimedStatObj); 

 

monITS3 := GETMONITOR(ASK kolejka3 TO dlugosc, ITimedStatObj); 

 

monSTA1 := GETMONITOR(ASK okienko1 TO stanowiska, ITimedStatObj); 

 

monSTA2 := GETMONITOR(ASK okienko2 TO stanowiska, ITimedStatObj); 

 

monSTA3 := GETMONITOR(ASK okienko3 TO stanowiska, ITimedStatObj); 

 

monRS2 := GETMONITOR(ASK okienko2 TO czasprzebywania, RStatObj); 

 

monRS3 := GETMONITOR(ASK okienko3 TO czasprzebywania, RStatObj); 

 
 

OUTPUT ("=========================================================================================="); 

 

OUTPUT (" SREDNIA "); 

 

OUTPUT ("========="); 

 

OUTPUT ("-srednia liczba zgloszen w pierwszej kolejce: ",ASK  monITS1 TO Mean()); 

 

OUTPUT ("          +odchylenie: ", ASK monITS1 TO StdDev()); 

 

 

 

OUTPUT ("-srednia liczba zgloszen w drugiej kolejce: ",ASK  monITS2 TO Mean()); 

 

OUTPUT ("          +odchylenie: ", ASK monITS2 TO StdDev()); 

 
 

OUTPUT ("-srednia liczba zgloszen w trzeciej kolejce: ",ASK  monITS3 TO Mean()); 

 

OUTPUT ("          +odchylenie: ", ASK monITS3 TO StdDev()); 

 

 

 

OUTPUT ("-sredni czas przebywania zgloszenia w SMO2: ",ASK  monRS2 TO Mean()); 

 

OUTPUT ("          +odchylenie: ", ASK monRS2 TO StdDev()); 

 

 

 

OUTPUT ("-sredni czas przebywania zgloszenia w SMO3: ",ASK  monRS3 TO Mean()); 

 

OUTPUT ("          +odchylenie: ", ASK monRS3 TO StdDev()); 

 

 

 

OUTPUT ("-srednia liczba zajetych kanalow w pierwszym okienku: ", ASK monSTA1 TO Mean()); 

 

OUTPUT ("          +odchylenie: ", ASK monSTA1 TO StdDev()); 

 

 

 

OUTPUT ("-srednia liczba zajetych kanalow w drugim okienku: ", ASK monSTA2 TO Mean()); 

 

OUTPUT ("          +odchylenie: ", ASK monSTA2 TO StdDev()); 

 

 

 

OUTPUT ("-srednia liczba zajetych kanalow w trzecim okienku: ", ASK monSTA3 TO Mean()); 

 

OUTPUT ("          +odchylenie: ", ASK monSTA3 TO StdDev()); 

 

 

 

OUTPUT (" PRAWDOPODOBIENSTWO "); 

 

OUTPUT ("===================="); 

 

praw1 := FLOAT(ASK kolejka1 TO odrzucone)/FLOAT(ASK kolejka1 TO przyjete + ASK kolejka1 TO odrzucone); 

 

OUTPUT ("-prawdopodobiestwo obsluzenia przez pierwsze okienko: ", praw1); 

 
 

praw2 := FLOAT(ASK kolejka2 TO odrzucone)/FLOAT(ASK kolejka2 TO przyjete + ASK kolejka2 TO odrzucone); 

 

OUTPUT ("-prawdopodobienstwo obsluzenia przez drugie okienko: ", praw2); 

 
 

praw3 := FLOAT(ASK kolejka3 TO odrzucone)/FLOAT(ASK kolejka3 TO przyjete + ASK kolejka3 TO odrzucone); 

 

OUTPUT ("-prawdopodobienstwo obsluzenia przez trzecie okienko: ", praw3); 

 
(*==========================================zwalnianie==================*) 
 
 

DISPOSE(okienko1); 

 

DISPOSE(okienko2); 

 

DISPOSE(okienko3); 

 

DISPOSE(kolejka1); 

 

DISPOSE(kolejka2); 

 

DISPOSE(kolejka3); 

 

DISPOSE(generator); 

 

OUTPUT (" "); 

 

OUTPUT ("..."); 

 

OUTPUT ("!aby zamknac to okienko, nacisnij dowolny klawisz!"); 

 

OUTPUT ("!aby zapisac wynik do pliku Stdout.txt nacisnij ALT i 2xENTER"); 

 

ch:=ReadKey(); 

 

 

 
END MODULE. 
 

Wnioski 
Zadanie zostało rozwiązane. Otrzymane wartości wydają się być poprawne.