Текст программы

program Project1;

{$APPTYPE CONSOLE}

uses

SysUtils, Math;

Const Npc = 5; {количество компьютеров}

Nk = 3; {количество каналов}

T = 20; {интервал наблюдения (сутки)}

Test_count = 10; {количество тестов}

U = 1.960; {Квантиль нормального распределения при уровне значимости 0.05}

PC: array[1..Npc] of String = ('1-ый компьютер', '2-ой компьютер', '3-ий компьютер', '4-ый компьютер', '5-ый компьютер');

Var L, aM, M: array[1..Npc] of real; {Интенсивности занятия / освобождения каналов}

statePC: array[1..Npc] of integer; {состояние компьютеров: 0 - не в сети, 1 - в сети}

timePC: array[1..Npc] of real; {продолжительность состояний компьютеров}

cTime: real; {текущее время}

Arr_Busy, Arr_Req: array[1..Test_Count] of integer; {счётчики отказов и числа обращений (попыток соединений)}

Sn, Sk: integer; {Sn и Sk - общее число обращений и отказов}

p, Ga, Gb: real; {Ga и Gb - границы доверительного интервала}

{******************************************************************************}

Procedure iArrFill(var a: array of integer; count, value: integer);

Var i: integer; {заполняет count элементов массива a целым значением value}

Begin

For i: =1 to count do

a[i]: = value;

End;

{******************************************************************************}

Procedure rArrFill(var a: array of real; count: integer; value: real);

Var i: integer; {заполняет count элементов массива a вещественным значением value}

Begin

For i: =1 to count do

a[i]: = value;

End;

{******************************************************************************}

Procedure Load; {Чтение данных из файла и подсчёт усредненных}

Var i, j, c1, c2: integer; {значений для каждого из компьютеров}

t: real;

Begin

Assign(input, 'input.txt'); {открытие файла на чтение}

ReSet(input);

Assign(output, 'output.txt'); {открытие файла на запись}

ReWrite(output);

rArrFill(L, Npc, 0); {обнуление массива}

ReadLn(c1);

For i: =1 to Npc do

Begin

For j: =1 to c1 do

Begin

Read(t);

L[i]: = L[i] + t;

End;

L[i]: = L[i] / c1;

End;

rArrFill(M, Npc, 0); {обнуление массива}

rArrFill(aM, Npc, 0); {обнуление массива}

ReadLn(c2);

For i: =1 to Npc do

Begin

For j: =1 to c2 do

Begin

Read(t);

aM[i]: = aM[i] + t;

End;

M[i]: = (c2 * 24) / aM[i];

End;

Close(input); {закрытие файла на чтение}

Randomize; {инициализация встроенного генератора случайных чисел}

End;

{******************************************************************************}

Function Analit: real; {Аналитический метод}

Var i: integer;

s1, s2, p0: real;

Begin

s1: = L[1];

WriteLn('------Решение аналитическим методом------');

WriteLn('Усредненное значение интенсивности подключений: ');

Write('(', L[1]: 6: 3);

For i: =2 to Npc do

Begin

Write('+', L[i]: 6: 3);

s1: = s1 + L[i];

End;

s1: = s1 / Npc;

WriteLn(') / ', Npc, ' =', s1: 6: 3);

WriteLn('Усредненное значение интенсивности отключений: ');

Write(Npc, ' * 240 / (', aM[1]: 5: 2);

s2: = aM[1];

For i: =2 to Npc do

Begin

Write('+', aM[i]: 5: 2);

s2: = s2 + aM[i];

End;

s2: = Npc * 240 / s2;

WriteLn(') = ', s2: 6: 3);

p0: = 1 / (1 + 3 * s1 / s2 + 3 * Power(s1 / s2, 2) + Power(s1 / s2, 3));

Result: = p0 * Power(s1 / s2, 3);

End;

{******************************************************************************}

Procedure PrintWriter;

Var i: integer;

Begin

WriteLn('Интенсивности подключений компьютеров: ');

For i: =1 to Npc do

WriteLn(PC[i], ' - ', L[i]: 7: 3, '; ');

WriteLn('Интенсивности отключений компьютеров:: ');

For i: =1 to Npc do

WriteLn(PC[i], ' - ', M[i]: 7: 3, '; ');

WriteLn('Аналитическая вероятность отказа при ', Npc, ' компьютерах и ', Nk, ' каналах: ', Analit: 6: 3);

WriteLn('------Решение методом Монте-Карло-------');

WriteLn('Продолжительность моделирования: ', T, ' суток');

Write('Номер теста ');

For i: =1 to Test_Count do

Write(i: 4);

WriteLn;

Write('Количество обращений ');

For i: =1 to Test_Count do

Write(Arr_Req[i]: 4);

WriteLn;

Write('Количество отказов ');

For i: =1 to Test_Count do

Write(Arr_Busy[i]: 4);

WriteLn;

WriteLn('Общее число обращений n = ', Sn);

WriteLn('Общее число отказов k = ', Sk);

WriteLn('Доля времени, когда все каналы заняты p*: ', p: 6: 3);

WriteLn('Доверительный интервал (', Ga: 6: 4, '; ', Gb: 6: 4, ').');

Close(output); {закрытие файла на запись}

End;

{******************************************************************************}

Procedure Step(k: integer; var count_busy, count_req: integer);

Var i, connect: integer; {Один шаг моделирования для k-ого компьютера}

x, TT: real;

Begin

If(statePC[k] = 0) then {если компьютер не в сети, пытаемся подключить}

Begin

connect: = 0;

Inc(count_req); {увеличиваем счётчик обращений}

For i: =1 to Npc do {считаем число подключений к сети}

Inc(connect, statePC[i]);

if (connect < Nk) then {если есть свободные каналы}

Begin

statePC[k]: = 1; {подключаем компьютер к сети}

x: = random; {генерируем случайное число от 0 до 1}

TT: = -Ln(x)/M[k]; {время отключения от сети}

End

else {если нет свободных каналов}

Begin

Inc(count_busy); {увеличиваем счётчик отказов}

x: = random; {генерируем случайное число от 0 до 1}

TT: = -Ln(x)/L[k]; {время следующей попытки войти в сеть}

End;

timePC[k]: = timePC[k] + TT;

End

else {если компьютер в сети, отключяем его}

Begin

statePC[k]: = 0; {отключаем компьютер к сети}

x: = random; {генерируем случайное число от 0 до 1}

TT: = -Ln(x)/L[k]; {время следующей попытки войти в сеть}

timePC[k]: = timePC[k] + TT;

End;

End;

{******************************************************************************}

Procedure MinTime(var cTime: real; var kPC: integer);

Var i: integer; {определяем минимальное время и номер компьютера}

Begin

cTime: = timePC[1];

kPC: = 1;

For i: =2 to Npc do {По всем компьютерам по порядку...)}

Begin

If(timePC[i] < cTime) then {если нашёлся ПК с меньшим временем}

Begin

cTime: = timePC[i];

kPC: = i;

End;

End;

End;

{******************************************************************************}

Procedure Model_MK;

Var i, kPC: integer;

Begin

Sn: =0; Sk: =0;

iArrFill(Arr_Req, Test_Count, 0); {обнуляем счётчики}

iArrFill(Arr_Busy, Test_Count, 0);

For i: =1 to Test_count do {проводим серию тестов}

Begin

iArrFill(statePC, Npc, 0); {обнуляем массивы}

rArrFill(timePC, Npc, 0);

MinTime(cTime, kPC); {определяем минимальное время и номер компьютера}

While(cTime < T) do

Begin

Step(kPC, Arr_Busy[i], Arr_Req[i]); {шаг моделирования}

MinTime(cTime, kPC); {определяем минимальное время и номер компьютера}

End;

End;

For i: =1 to Test_count do {суммируем данные по всем тестам}

Begin

Inc(Sk, Arr_Busy[i]);

Inc(Sn, Arr_Req[i]);

End;

p: = Sk / Sn; {Искомая вероятность...}

Ga: = p - U * sqrt((p * (1 - p)) / Sn); {...и границы интервала }

Gb: = p + U * sqrt((p * (1 - p)) / Sn);

End;

{******************************************************************************}

Begin {основная программа}

Load;

Model_MK;

PrintWriter;

End.