WOJSKOWA AKADEMIA TECHNICZNA

Podstawy symulacji

Prowadzący : dr inż. Jarosław Rulka
Grupa: I8C1S1
Wykonawca: Błażej Bubrowiecki

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 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)

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 SMO, : N, = (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;

0.

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

N, - 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; p

k

- prawdopodobieństwa przemieszczenia się zgłoszenia po

danym łuku; L, - długość kolejki i-tego SMO;
AL., - 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.

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

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ść:

Kod programu:

MAIN MODULE mblazej;

(*=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 (" Blazej Bubrowiecki ");

OUTPUT (" I8C1S1 ");

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.