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.