WOJSKOWA AKADEMIA TECHNICZNA
Podstawy symulacji
Zadanie laboratoryjne nr 2
Prowadzący : dr inż. Jarosław Rulka
Grupa: I7G2S1
Wykonawca: A
ukasz Kołodziejski
Napisać program symulujący działanie sieci SMO jak na rysunku:
p2
O2
T1 p1
O1 SMO
1-p1
SMO
O3
SMO
p3
Przy realizacji zadania należy przyjąć następujące dane z listy przedstawionej poniżej:
a) rozkład zmiennych Tj: (nrDz + i) mod 6 + 1;
b) rozkład zmiennych Oi: (nrDz + i + 1) mod 6 + 1;
c) Li: (nrDz + i) mod 2 + 1;
d) ALi: (nrDz + i + 2) mod 3 + 1;
e) Rj = (nrDz + i + 5) mod 3 + 1;
f) Mi = (nrDz + i + 2) mod 4 + 1;
g) Blokowanie zgłoszeń 1. SMO;
h) Klienci niecierpliwi w SMOi : Ni = (nrDz + i) mod 4 (ograniczony czas oczekiwania na rozpoczęcie obsługi);
gdzie:
i  numer SMO;
j  numer strumienia;
Tj  zmienna losowa oznaczająca czas pomiędzy kolejnymi napływami zgłoszeń do systemu;
Oi  zmienna losowa oznaczająca czas obsługi pojedynczego zgłoszenia w gniez
dzie;
Ni  zmienna losowa oznaczająca czas niecierpliwości zgłoszenia (gdy i = 0 => zgłoszenia cierpliwe);
Rj  zmienna losowa oznaczająca wielkość paczki zgłoszeń (wchodzących w tej samej chwili) j-tego strumienia;
pk  prawdopodobieństwa przemieszczenia się zgłoszenia po danym łuku;
Li  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.
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 gniez
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ądz
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ądz
opuścić system. Po
wyjściu z gniazda trzeciego klient może powrócić do gniazda pierwszego (prawdopodobieństwo p3),
bądz
opuścić system. Jeżeli powróci do systemu, to prawdopodobieństwo, że przy następnym
wyborze też pozostanie w systemie zostanie zmniejszone.
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.