Wojskowa Akademia Techniczna

PODSTAWY SYMULACJI

Temat: Projekt programu symulującego działanie
sieci SMO

Prowadzący: dr inż. Jarosław Rulka
Student: Artur Piersa
Grupa: I2A4S1
Numer na liście: 3

Zadanie laboratoryjne numer 1

Zaprojektować i zaimplementować program symulujący działanie sieci SMO jak na rysunku:

Wyznaczenie parametrów:

•

rozkład zmiennych Tj: (nrDz + i) mod 6 + 1
◦

T1 = (3+1) mod6 + 1 = 4 + 1 = 5 → rozkład trójkątny

◦

T2 = (3+2) mod6 + 1 = 5 + 1 = 6 → rozkład Weibulla

•

rozkład zmiennych Oi: (nrDz + i + 1) mod 6 + 1
◦

O1 = (3 + 1 + 1) mod6 + 1 = 5 + 1 = 6 → rozkład Weibulla

◦

O2 = (3 + 2 + 1) mod6 + 1 = 0 + 1 = 1 → rozkład wykładniczy

◦

O3 = (3 + 3 + 1) mod6 + 1 = 1 + 1 = 2 → rozkład Erlanga

•

długość kolejki i-tego SMO Li: (nrDz + i) mod 2 + 1
◦

L1 = (3+1) mod2 + 1 = 0 + 1 = 1 → ograniczona (możliwe straty)

◦

L2 = (3+2) mod2 + 1 = 1 + 1 = 2 → nieograniczona

◦

L3 = (3+3) mod2 + 1 = 0 + 1 = 1 → ograniczona (możliwe straty)

•

algorytmy kolejek ALi: (nrDz + i + 2) mod 3 + 1
◦

AL1 = (3 + 1 + 2) mod3 + 1 = 0 + 1 = 1 → FIFO

◦

AL2 = (3 + 2 + 2) mod3 + 1 = 1 + 1 = 2 → LIFO

◦

AL3 = (3 + 3 + 2) mod3 + 1 = 2 + 1 = 3 → z priorytetami

•

wielkość paczki zgłoszeń j-tego strumienia Rj = (nrDz + i + 5) mod 3 + 1
◦

R1 = (3 + 1 + 5) mod3 + 1 = 0 + 1 = 1 → 1

◦

R2 = (3 + 2 + 5) mod3 + 1 = 1 + 1 = 2 → 2

•

liczba stanowisk obsługi w gniazdach Mi = (nrDz + i + 2) mod 4 + 1
◦

M1 = (3 + 1 + 2) mod4 + 1 = 2 + 1 = 3 → 3

◦

M2 = (3 + 2 + 2) mod4 + 1 = 3 + 1 = 4 → 4

◦

M3 = (3 + 3 + 2) mod4 + 1 = 0 + 1 = 1 → 1

•

klienci niecierpliwi w SMOi : Ni = (nrDz + i) mod 4
◦

N1 = (3 + 1) mod4 = 0 → 0

◦

N2 = (3 + 2) mod4 = 1 → 1

◦

N3 = (3 + 3) mod4 = 2 → 2

Rozwiązanie problemu:

Opis obiektów stworzonych przeze mnie w tym zadaniu:

•

Generator1Obj – obiekt generatora 1 (rozkład trójkątny)

•

Generator2Obj – obiekt generatora 2 (rozkład Weibulla)

•

Kolejka1Obj – obiekt kolejki pierwszej (FIFO z ograniczeniami)

•

Kolejka2Obj – obiekt kolejki drugiej (LIFO bez ograniczeń)

•

Kolejka3Obj – obiekt kolejki trzeciej (priorytetowa z ograniczeniami)

•

Okienko1Obj – obiekt gniazda pierwszego

•

Okienko2Obj – obiekt gniazda drugiego

•

Okienko3Obj – obiekt gniazda trzeciego

•

StudentObj – obiekt reprezentujący studenta w kolejce

Opis użytych rozkładów:

Kod programu:

MAIN MODULE psy;

FROM RandMod IMPORT RandomObj, Random;
FROM IOMod IMPORT ReadKey;
FROM ListMod IMPORT QueueList;
FROM GrpMod IMPORT QueueObj, StackObj, RankedObj;
FROM SimMod IMPORT SimTime, StartSimulation, TriggerObj;
FROM StatMod IMPORT SREAL, RStatObj,ITimedStatObj, TSINTEGER;
FROM IOMod IMPORT StreamObj, ALL FileUseType;

TYPE
Generator1Obj = OBJECT; FORWARD;
Generator2Obj = OBJECT; FORWARD;
Kolejka1Obj = OBJECT; FORWARD;
Kolejka2Obj = OBJECT; FORWARD;
Kolejka3Obj = OBJECT; FORWARD;
Okienko1Obj = OBJECT; FORWARD;
Okienko2Obj = OBJECT; FORWARD;
Okienko3Obj = OBJECT; FORWARD;
StudentObj = OBJECT; FORWARD;

Generator1Obj = OBJECT(RandomObj);

min: REAL;
mode: REAL;
max: REAL;
GenLos: RandomObj;
Kolejka1: Kolejka1Obj;
tryb: INTEGER;
TELL METHOD Generuj(IN LiczbaOsob:INTEGER);
ASK METHOD Ustaw(IN a, b, c: REAL; IN Kol:Kolejka1Obj; IN t:INTEGER);

END OBJECT;

Generator2Obj = OBJECT(RandomObj);

shape: REAL;
scale: REAL;
GenLos: RandomObj;
Kolejka2: Kolejka2Obj;
tryb: INTEGER;
TELL METHOD Generuj(IN LiczbaOsob:INTEGER);
ASK METHOD Ustaw(IN sh, sc: REAL; IN Kol:Kolejka2Obj; IN t:INTEGER);

END OBJECT;

Kolejka1Obj = OBJECT(QueueObj);

{Kolejka FIFO z ograniczeniami}

ograniczenie: INTEGER;
dlugosc: TSINTEGER;
okienko1: Okienko1Obj;
przyjete: INTEGER;
odrzucone: INTEGER;
tryb: INTEGER;
ASK METHOD Wstaw(IN Kl:StudentObj);
ASK METHOD Ustaw(IN okien: Okienko1Obj; IN ogr: INTEGER; IN t:INTEGER);

END OBJECT;

Kolejka2Obj = OBJECT(StackObj);

{Kolejka LIFO nieograniczona}

okienko2: Okienko2Obj;
dlugosc: TSINTEGER;
przyjete: INTEGER;
odrzucone: INTEGER;

tryb: INTEGER;
ASK METHOD Wstaw(IN Kl:StudentObj);
ASK METHOD Ustaw(IN okien: Okienko2Obj; IN t:INTEGER);

END OBJECT;

Kolejka3Obj = OBJECT(RankedObj);

{Kolejka priorytetowa ograniczona}

ograniczenie: INTEGER;
dlugosc: TSINTEGER;
przyjete: INTEGER;
odrzucone: INTEGER;
tryb: INTEGER;
okienko3: Okienko3Obj;
ASK METHOD Wstaw(IN Kl:StudentObj);
ASK METHOD Ustaw(IN okien: Okienko3Obj; IN ogr: INTEGER; IN t:INTEGER);

END OBJECT;

Okienko1Obj = OBJECT(RandomObj);

shape: REAL;
scale: REAL;
Kolejka1: Kolejka1Obj;
Kolejka3: Kolejka3Obj;
los:RandomObj;
stanowiska: TSINTEGER;
tryb: INTEGER;
p1: REAL;
TELL METHOD Obsluguj();
ASK METHOD Ustaw(IN sh: REAL; IN sc: REAL; IN Kol1: Kolejka1Obj; IN Kol3:Kolejka3Obj; IN

t:INTEGER; IN pstwo: REAL);
END OBJECT;

Okienko2Obj = OBJECT(RandomObj);

lambda: REAL;
czasprzebywania:SREAL;
Kolejka2: Kolejka2Obj;
Kolejka3: Kolejka3Obj;
stanowiska: TSINTEGER;
tryb: INTEGER;
TELL METHOD Obsluguj();
ASK METHOD Ustaw(IN la:REAL; IN Kol2:Kolejka2Obj; IN Kol3:Kolejka3Obj; IN t:INTEGER);

END OBJECT;

Okienko3Obj = OBJECT(RandomObj);

shape: REAL;
lambda: INTEGER;
czasprzebywania:SREAL;
Kolejka3: Kolejka3Obj;
Kolejka2: Kolejka2Obj;
los:RandomObj;
zajete: BOOLEAN;
tryb: INTEGER;
p2: REAL;
TELL METHOD Obsluguj();
ASK METHOD Ustaw(IN sh: REAL; IN la: INTEGER; IN Kol3: Kolejka3Obj; IN Kol2: Kolejka2Obj; IN

t:INTEGER; IN pstwo: REAL);
END OBJECT;

StudentObj = OBJECT(RandomObj);

Nr: INTEGER;
CzasWejscia: REAL;
ASK METHOD ustawCzas();
ASK METHOD usun();
ASK METHOD ustaw(IN numer: INTEGER);

END OBJECT;

OBJECT Generator1Obj;

ASK METHOD Ustaw(IN a, b, c: REAL; IN Kol:Kolejka1Obj; IN t:INTEGER);
BEGIN

min:=a;
mode:=b;
max:=c;
tryb:=t;
Kolejka1:=Kol;

END METHOD;

TELL METHOD Generuj(IN LiczbaOsob:INTEGER);
VAR

i:INTEGER;
st:StudentObj;

BEGIN

FOR i:=1 TO LiczbaOsob BY 1

WAIT DURATION Triangular(min, mode, max);
END WAIT;
NEW(st);

ASK st TO ustaw(i);
IF tryb<>0
OUTPUT(SimTime," [*] Stworzono nowego Studenta Nr ", ASK st TO Nr,".");
END IF;
ASK Kolejka1 TO Wstaw(st);

END FOR;

END METHOD;

END OBJECT;

OBJECT Generator2Obj;

ASK METHOD Ustaw(IN sh, sc: REAL; IN Kol:Kolejka2Obj; IN t:INTEGER);
BEGIN

shape:=sh;
scale:=sc;
tryb:=t;
Kolejka2:=Kol;

END METHOD;

TELL METHOD Generuj(IN LiczbaOsob:INTEGER);
VAR

i:INTEGER;
st:StudentObj;

BEGIN

FOR i:=1 TO LiczbaOsob BY 1

WAIT DURATION Weibull(shape, scale);
END WAIT;
NEW(st);

ASK st TO ustaw(i);
IF tryb<>0
OUTPUT(SimTime," [*] Stworzono nowego Studenta Nr ", ASK st TO Nr,".");
END IF;
ASK Kolejka2 TO Wstaw(st);

END FOR;

END METHOD;

END OBJECT;

OBJECT Kolejka1Obj;

ASK METHOD Wstaw(IN student:StudentObj);

BEGIN

IF ograniczenie > numberIn;

Add(student);
ASK student TO ustawCzas;
IF tryb<>0
OUTPUT(SimTime, " [+] Student Nr ", ASK student TO Nr, " zostal zakolejkowany do

kolejki 1");

END IF;
dlugosc:=numberIn;
IF ASK okienko1 TO stanowiska < 3 {ilosc stanowisk w okienku 1}

INC(przyjete);
TELL okienko1 TO Obsluguj;

ELSE

INC(odrzucone);

END IF;

ELSE

IF tryb<>0
OUTPUT(SimTime, " [<<] Student Nr ", ASK student TO Nr," zostal odrzucony z Kolejki

1");

END IF;
DISPOSE(student);

END IF;

END METHOD;
ASK METHOD Ustaw(IN gnd:Okienko1Obj; IN ogr:INTEGER; IN t:INTEGER);
BEGIN

okienko1:=gnd;
ograniczenie:=ogr;
tryb:=t;

END METHOD;

END OBJECT;

OBJECT Kolejka2Obj;

ASK METHOD Wstaw(IN student:StudentObj);
BEGIN

Add(student);
IF tryb<>0
OUTPUT(SimTime, " [+] Student Nr ", ASK student TO Nr, " zostal zakolejkowany do Kolejki 2");
END IF;
dlugosc:=numberIn;
IF ASK okienko2 TO stanowiska < 4 {ilosc stanowisk w okienku 2}

INC(przyjete);
TELL okienko2 TO Obsluguj;

ELSE

INC(odrzucone);

END IF;

END METHOD;

ASK METHOD Ustaw(IN gnd: Okienko2Obj; IN t:INTEGER);
BEGIN

okienko2:=gnd;
tryb:=t;

END METHOD;

END OBJECT;

OBJECT Kolejka3Obj;

ASK METHOD Wstaw(IN student:StudentObj);
BEGIN

IF ograniczenie > numberIn;

Add(student);
IF tryb<>0
OUTPUT(SimTime, " [+] Student Nr ", ASK student TO Nr, " zostal zakolejkowany do

kolejki 3");

END IF;

dlugosc:=numberIn;
IF NOT ASK okienko3 TO zajete

INC(przyjete);
TELL okienko3 TO Obsluguj;

ELSE

INC(odrzucone);

END IF;

ELSE

IF tryb<>0
OUTPUT(SimTime, " [<<] Student Nr ", ASK student TO Nr," zostal odrzucony z Kolejki

3");

END IF;
DISPOSE(student);

END IF;

END METHOD;

ASK METHOD Ustaw(IN gnd: Okienko3Obj; IN ogr:INTEGER; IN t:INTEGER);
BEGIN

okienko3:=gnd;
ograniczenie:=ogr;
tryb:=t;

END METHOD;

END OBJECT;

OBJECT Okienko1Obj;

ASK METHOD Ustaw(IN sh: REAL; IN sc: REAL; IN Kol1: Kolejka1Obj; IN Kol3:Kolejka3Obj; IN

t:INTEGER; IN pstwo: REAL);

BEGIN

shape:=sh;
scale:=sc;
Kolejka1:=Kol1;
Kolejka3:=Kol3;
NEW(los);
stanowiska:=0;
tryb:=t;
p1:=pstwo;

END METHOD;

TELL METHOD Obsluguj();
VAR

st:StudentObj;
zmlos:REAL;

BEGIN

WHILE ASK Kolejka1 TO numberIn > 0
INC(stanowiska);

st:=ASK Kolejka1 TO Remove();
IF tryb<>0
OUTPUT(SimTime, " [@] Rozpoczeto obsluge Studenta Nr ", ASK st TO Nr," w okienku 1,

stanowisko:", stanowiska);

END IF;
WAIT DURATION Weibull(shape, scale)
ON INTERRUPT
END WAIT;

IF tryb<>0
OUTPUT(SimTime, " [V] Student: ", ASK st TO Nr, " Obsluzony w okienku1");
END IF;

zmlos:=ASK los Sample();

IF zmlos < p1

IF tryb<>0

OUTPUT(SimTime, " [>>] Okienko 1 przekierowuje Studenta Nr ", ASK st TO Nr,"

do kolejki 1, zmlos=", zmlos);

END IF;
ASK Kolejka1 TO Wstaw(st);

ELSE

IF tryb<>0
OUTPUT(SimTime, " [>>] Okienko 1 przekierowuje Studenta Nr ", ASK st TO Nr,"

do kolejki 3, zmlos=", zmlos);

END IF;
ASK Kolejka3 TO Wstaw(st);

END IF;

DEC(stanowiska);
END WHILE;

END METHOD;

END OBJECT;

OBJECT Okienko2Obj;

ASK METHOD Ustaw(IN la:REAL; IN Kol2:Kolejka2Obj; IN Kol3:Kolejka3Obj; IN t:INTEGER);
BEGIN

lambda:=la;
Kolejka2:=Kol2;
Kolejka3:=Kol3;
stanowiska:=0;
tryb:=t;

END METHOD;

TELL METHOD Obsluguj();
VAR

st:StudentObj;
zmlos:REAL;

BEGIN

INC(stanowiska);
WHILE ASK Kolejka2 TO numberIn > 0

st:=ASK Kolejka2 TO Remove();
IF tryb<>0
OUTPUT(SimTime, " [@] Rozpoczeto obsluge studenta nr ", ASK st TO Nr," w okienku 2,

stan stanowiska:", stanowiska);

END IF;
WAIT DURATION Exponential(1.0 / lambda)
ON INTERRUPT
END WAIT;

IF tryb<>0
OUTPUT(SimTime, " [V] Student: ", ASK st TO Nr, " Obsluzony w okienku2");
OUTPUT(SimTime, " [>>] Okienko 2 przekierowuje Studenta Nr ", ASK st TO Nr," do

kolejki 3");

END IF;
ASK Kolejka3 TO Wstaw(st);

END WHILE;
DEC(stanowiska);

END METHOD;

END OBJECT;

OBJECT Okienko3Obj;

ASK METHOD Ustaw(IN sh: REAL; IN la: INTEGER; IN Kol3: Kolejka3Obj; IN Kol2: Kolejka2Obj; IN

t:INTEGER; IN pstwo: REAL);

BEGIN

shape:=sh;
lambda:=la;
Kolejka3:=Kol3;

Kolejka2:=Kol2;
NEW(los);
zajete:=FALSE;
tryb:=t;
p2:=pstwo;

END METHOD;

TELL METHOD Obsluguj();
VAR

st:StudentObj;
zmlos:REAL;

BEGIN

zajete:=TRUE;
WHILE ASK Kolejka3 TO numberIn > 0

st:=ASK Kolejka3 TO Remove();
IF tryb<>0
OUTPUT(SimTime, " [@] Rozpoczeto obsluge studenta nr ", ASK st TO Nr," w okienku 3,

stan stanowiska:", zajete);

END IF;
WAIT DURATION Erlang(shape,lambda)
ON INTERRUPT;
END WAIT;
IF tryb<>0
OUTPUT(SimTime, " [V] Student: ", ASK st TO Nr, " Obsluzony w okienku 3");
END IF;
zmlos:=ASK los Sample();

IF zmlos < p2

IF tryb<>0
OUTPUT(SimTime, " [>>] Okienko 3 przekierowuje Studenta Nr ", ASK st TO Nr,"

do kolejki 2, zmlos=", zmlos);

END IF;
ASK Kolejka2 TO Wstaw(st);

ELSE

IF tryb<>0
OUTPUT(SimTime, " [X] Student Nr ", ASK st TO Nr, " OPUSCIL SYSTEM,

zmlos=", zmlos);

END IF;
czasprzebywania:=SimTime - ASK st TO CzasWejscia;
ASK st TO usun();

END IF;

END WHILE;
zajete:=FALSE;

END METHOD;

END OBJECT;

OBJECT StudentObj;

ASK METHOD ustaw(IN numer: INTEGER);
BEGIN

Nr:=numer;

END METHOD;

ASK METHOD usun();
BEGIN

DISPOSE(SELF);

END METHOD;

ASK METHOD ustawCzas();
BEGIN

CzasWejscia:=SimTime;

END METHOD;

END OBJECT;

VAR

okienko1:Okienko1Obj;
okienko2:Okienko2Obj;
okienko3:Okienko3Obj;
kolejka1:Kolejka1Obj;
kolejka2:Kolejka2Obj;
kolejka3:Kolejka3Obj;
generator1:Generator1Obj;
generator2:Generator2Obj;
tryb:INTEGER;
ch:CHAR;
min,mode,max,shape,scale,shape2,scale2,lambda,shapeEr,praw1,praw2,praw3:REAL;
p1, p2: REAL;
lambdaEr:INTEGER;
plik, conf: StreamObj;
ogr1,ogr2,losob:INTEGER;
monITS1, monITS2, monITS3, monSTA1, monSTA2: ITimedStatObj;
monRS1, monRS2: RStatObj;
i, liczbaParametrow: INTEGER;

BEGIN

NEW(okienko1);
NEW(okienko2);
NEW(okienko3);
NEW(kolejka1);
NEW(kolejka2);
NEW(kolejka3);
NEW(generator1);
NEW(generator2);

OUTPUT(" ");
OUTPUT("Struktura pliku z konfiguracja: ");
OUTPUT("Generator 1 - rozklad trojkatny: min, mode, max");
OUTPUT("Generator 2 - rozklad Weibulla: shape, scale");
OUTPUT("Okienko 1 - rozklad Weibulla: shape, scale");
OUTPUT("Okienko 2 - rozklad wykladniczy: lambda");
OUTPUT("Okienko 3 - rozklad Erlanga: shape, lambda");
OUTPUT("Ograniczenia okienka 1 i okienka 3");
OUTPUT("Liczba osob");
OUTPUT("Prawdopodobienstwo p1");
OUTPUT("Prawdopodobienstwo p2");
OUTPUT("-------------------------------------------------------------");
OUTPUT("Podaj tryb pracy (=0 - bez komunikatow, <>0 - z komunikatami )");
INPUT(tryb);

liczbaParametrow:= 15;

{parametry domyslne}
min:=0.1;
mode:=0.3;
max:=0.7;
shape:=0.1;
scale:=0.8;
shape2:=0.2;

scale2:=0.7;
lambda:=5.0;
shapeEr:=0.1;
lambdaEr:=9;
ogr1:=30;
ogr2:=3;
losob:=25;
p1:=0.1;
p2:=0.3;

NEW(conf);
ASK conf TO Open("sim.txt", Input);

ASK conf TO ReadReal(min);
ASK conf TO ReadReal(mode);
ASK conf TO ReadReal(max);
ASK conf TO ReadReal(shape);
ASK conf TO ReadReal(scale);
ASK conf TO ReadReal(shape2);
ASK conf TO ReadReal(scale2);
ASK conf TO ReadReal(lambda);
ASK conf TO ReadReal(shapeEr);
ASK conf TO ReadInt(lambdaEr);
ASK conf TO ReadInt(ogr1);
ASK conf TO ReadInt(ogr2);
ASK conf TO ReadInt(losob);
ASK conf TO ReadReal(p1);
ASK conf TO ReadReal(p1);

ASK conf TO Close;

ASK generator1 TO Ustaw(min, mode, max, kolejka1, tryb);
ASK generator2 TO Ustaw(shape, scale, kolejka2, tryb);
ASK kolejka1 TO Ustaw(okienko1, ogr1, tryb);

ASK okienko1 TO Ustaw(shape2,scale2,kolejka1,kolejka3,tryb,p1);

ASK kolejka2 TO Ustaw(okienko2,tryb);

ASK okienko2 TO Ustaw(lambda,kolejka2,kolejka3,tryb);

ASK kolejka3 TO Ustaw(okienko3, ogr2,tryb);

ASK okienko3 TO Ustaw(shapeEr,lambdaEr,kolejka3,kolejka2,tryb,p2);

TELL generator1 TO Generuj(losob);
TELL generator2 TO Generuj(losob);

StartSimulation();

NEW(plik);
ASK plik TO Open("wyniki.txt", Output);

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);
monRS1 := GETMONITOR(ASK okienko2 TO czasprzebywania, RStatObj);
monRS1 := GETMONITOR(ASK okienko3 TO czasprzebywania, RStatObj);

ASK plik TO WriteString ("SREDNIA DLUGOSC KOLEJKI1: ");
ASK plik TO WriteReal (ASK monITS1 TO Mean(), 10, 4);
ASK plik TO WriteLn;
ASK plik TO WriteString ("ODCHYLENIE: ");
ASK plik TO WriteReal (ASK monITS1 TO StdDev(), 10, 4);
ASK plik TO WriteLn;

ASK plik TO WriteString ("SREDNIA DLUGOSC KOLEJKI2: ");
ASK plik TO WriteReal (ASK monITS2 TO Mean(), 10, 4);
ASK plik TO WriteLn;
ASK plik TO WriteString ("ODCHYLENIE: ");
ASK plik TO WriteReal( ASK monITS2 TO StdDev(), 10, 4);
ASK plik TO WriteLn;
ASK plik TO WriteString ("SREDNIA DLUGOSC KOLEJKI3: ");
ASK plik TO WriteReal(ASK monITS3 TO Mean(), 10, 4);
ASK plik TO WriteLn;
ASK plik TO WriteString ("ODCHYLENIE: ");
ASK plik TO WriteReal(ASK monITS3 TO StdDev(), 10, 4);
ASK plik TO WriteLn;
ASK plik TO WriteString ("SREDNI CZASOBSLUGI: ");
ASK plik TO WriteReal(ASK monRS1 TO Mean(), 10, 4);
ASK plik TO WriteLn;
ASK plik TO WriteString ("ODCHYLENIE: ");
ASK plik TO WriteReal(ASK monRS1 TO StdDev(), 10, 4);
ASK plik TO WriteLn;
ASK plik TO WriteString("SREDNIA LICZBA ZAJETYCH KANALOW W OKIENKU1: ");
ASK plik TO WriteReal( ASK monSTA1 TO Mean(), 10, 4);
ASK plik TO WriteLn;
ASK plik TO WriteString("ODCHYLENIE: ");
ASK plik TO WriteReal(ASK monSTA1 TO StdDev(), 10, 4);
ASK plik TO WriteLn;
ASK plik TO WriteString ("SREDNIA LICZBA ZAJETYCH KANALOW W OKIENKU2: ");
ASK plik TO WriteReal( ASK monSTA2 TO Mean(), 10, 4);
ASK plik TO WriteLn;
ASK plik TO WriteString("ODCHYLENIE: ");
ASK plik TO WriteReal(ASK monSTA2 TO StdDev(), 10, 4);
ASK plik TO WriteLn;
praw1 := FLOAT(ASK kolejka1 TO odrzucone)/FLOAT(ASK kolejka1 TO przyjete + ASK kolejka1 TO

odrzucone);

ASK plik TO WriteString ("PRAWDOPODOBIENSTWO OBSLUZENIA PRZEZ OKIENKO1: ");
ASK plik TO WriteReal(praw1, 10, 4);
ASK plik TO WriteLn;
praw2 := FLOAT(ASK kolejka2 TO odrzucone)/FLOAT(ASK kolejka2 TO przyjete + ASK kolejka2 TO

odrzucone);

ASK plik TO WriteString("PRAWDOPODOBIENSTWO OBSLUZENIA PRZEZ OKIENKO2: ");
ASK plik TO WriteReal(praw2, 10, 4);
ASK plik TO WriteLn;
praw3 := FLOAT(ASK kolejka3 TO odrzucone)/FLOAT(ASK kolejka3 TO przyjete + ASK kolejka3 TO

odrzucone);

ASK plik TO WriteString ("PRAWDOPODOBIENSTWO OBSLUZENIA PRZEZ OKIENKO3: ");
ASK plik TO WriteReal(praw3, 10, 4);
ASK plik TO Close;
DISPOSE(okienko1);
DISPOSE(okienko2);
DISPOSE(okienko3);
DISPOSE(kolejka1);
DISPOSE(kolejka2);
DISPOSE(kolejka3);
DISPOSE(generator1);
DISPOSE(generator2);
OUTPUT ("Nacisnij dowolny klawisz...");

ch:=ReadKey();

END MODULE.