Студопедия

Главная страница Случайная страница

КАТЕГОРИИ:

АвтомобилиАстрономияБиологияГеографияДом и садДругие языкиДругоеИнформатикаИсторияКультураЛитератураЛогикаМатематикаМедицинаМеталлургияМеханикаОбразованиеОхрана трудаПедагогикаПолитикаПравоПсихологияРелигияРиторикаСоциологияСпортСтроительствоТехнологияТуризмФизикаФилософияФинансыХимияЧерчениеЭкологияЭкономикаЭлектроника






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




 

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.

 

 



mylektsii.ru - Мои Лекции - 2015-2018 год. (0.016 сек.)Пожаловаться на материал