код на языке C для внешних определений

"/* внешние определения для системы массового обслуживания с 1 устройством обслуживания*/

#include <studio.h>
#include <math.h>
#include "1cgrand.h" /* заголовочный файл для генератора случайного числа */

#define Q_LIMIT 100 /* ограничение длины очереди */
#define BUSY 1 /* устройство в состоянии занятости */
#define IDLE 0 /* устройство в состоянии незанятости */

int next_event_type, num_custs_delayed, num_delays_required, num_events, num_in_q, server_status;

float area_num_in_q, area_server_status, mean_interarrival, mean_service, sim_time, time_ariival[Q_LIMIT+1], time_last_event, time_next_event[3], total_of_delays;
FILE *infile, *outfile;

void initialize(void);
void timing(void);
void arrive(void);
void depart(void);
void report(void);
void update_time_avg_status(void);
float expon(float mean);"

код для основной функции

"main()
{
	/* открываем входной и выходной файлы из файла mml.in, в котором содержится одна строка с числами 1,0; 0,5 и 1000, разделенные пробелами */
	infile = fopen("mml.in", "r");
	outfile = fopen("mml.in", "w");

	/* указываем число событий для синхронизирующей функции */
	num events = 2;

	/* считываем входные параметры */
	fscanf(infile, "%f %f %d", &mean_interarrival, &mean_service, &num_delays_required);

	/* указываем заголовок отчета и входные параметры */
	fprintf(outfile, "среднее время между поступлениями %11.3f мин\n\n", mean_interrarival);
	fprintf(outfile, "среднее число обслуживания%16.3f мин\n\n", mean_service);
	fprintf(outfile, "число требований%14d\n\n", num_delays_required);

/* инициализируем моделирование */
initialize();

/* выполняем пока не зарегистрировано нужное число задержек в очереди */
while (num_custs_delayed < num_delays_required) {
	/* определяем следующее событие */
	timing();
	/* обновляем среднестатистические накопители */
	update_time_avg_stats();
	/* вызываем соответствующую событийную функцию */
	switch (next_event_type) {
		case 1:
			arrive();
			break;
		case 2:
			depart();
			break;
	}
}
/* вызываем генератор отчетов и завершаем моделирование */
report();
fclose(infile);
fclose(outline);
return 0;
}"

код на языке C для функции инициализации

"void initialize(void) /* функция инициализации */
{
/* устанавливаем в исходное состояние часы модельного времени */
sim_time = 0.0;

/* задаем исходные значения переменных состояния */
server_status = IDLE;
num_in_q = 0;
time_last_event = 0.0;

/* устанавливаем в исходное состояние статистические счетчики */
num_custs_delayed = 0;
total_of_delays = 0.0;
area_num_in_q = 0.0;
area_server_status = 0.0;

/* инициализируем список событий. отменяем учет ухода (завершения обслуживания), поскольку в системе нет требований */
time_next_event[1] = sim_time + expon(mean_interarrival);
time_next_event[2] = 1.0e+30;"

код на языке C для синхронизирующей функции
"void timing(void) /* синхронизирующая функция */
{
int 1;
float min_time_next_event = 1.0e+29;
next_event_type = 0;

/* определяем тип следующего события */
for (i = 1; i <= num_events; ++1)
	if (time_next_event[i] < min_time_next_event) {
		min_time_next_event = time_next_event[i];
		next_event_type = i;}

/* проверяем, является ли список событий пустым */
if (next_event_type == 0) {
/* список событий пуст. завершаем моделирование */
fprint(outline, "\n список событий пуст в момент времени %f", sim_time);
exit(1);
}"

код для функции arrive

"void arrive(void) /*событийная функция для поступления требования */
{
float delay:
/* планируем следующее поступление */
time_next_event[1] = sim_time + expon(mean_interarrival);
/* проверяем, занято ли устройство обслуживания */
if (server_status == BUSY) {
/* устройство занято. увеличиваем число требований в очереди */
++num_in_q:
/* проверяем наличие условия переполнения */
if (num_in_q > Q_LIMIT) {
/* очередь переполнена. прекращаем моделирование */
fprintf(outline. "\n переполнение массива time_arrival в");
fprintf(outline, " момент времени %f", sim_time);
exit(2);
}

/* в очереди все еще остается место. сохраняем время поступления требования в (новом) конце массива time_arrival */
time_arrival[num_in_q] = sim_time;
}
else {
/* устройство свободно. задержка поступившего требования в очереди = 0. (следующие 2 оператора не влияют на результат моделирования) */
delay = 0.0;
total_of_delays += delay;
/* увеличиваем число задержек требований. переводим устройство в состояние занятости */
++num_custs_delayed;
server_status = BUSY;
/*планируем уход требования (завершение обслуживание) */
time_next_event[2] = sim_time + expon(mean_service);
}
}"

код для функции depart
"void depart(void) /* событийная функция для ухода требования */
{
int 1;
float delay;
/* проверяем есть ли требования в очереди */
if (num_in_q == 0) {
/*в очереди нет требований. переводим устройство в состояние незанятости и отменяем учет ухода (завершения обслуживания) */
server_status = IDLE;
time_next_event[2] = 1.0e+30;
}
else {
/* в очереди есть требования. уменьшаем число требований в очереди */
--num_in_q:
/* вычисляем задержку в очереди требования, обслуживание которого началось, и обновляем значение общего накопителя времени задержки */
delay = sim_time - time_arrival[1];
total_of_delays += delay;
/* увеличиваем число задержек требований и планируем время ухода */
++num_custs_delayed;
time_next_event[2] = sim_time + expon(mean_service);
/* переводим каждое требование в очереди на одну позицию вперед */
for (i = 1; 1 <= num_in_q; ++i)
	time_arrival[i] = time_arrival[i + 1];
}
}"

код для функции report
"void report(void) /* функция генератора отчетов */
{
/* вычисляем и записываем исконные критерии оценки работы */
fprintf(outfile, "\n\nсредняя задержка в очереди%11.3f мин\n\n", total_of_delays / num_custs_delayed);
fprintf(outfile, "среднее число требований в очереди%10.3f\n\n", area_num_in_q / sim_time);
fprintf(outfile,"коэффициент занятости устройства обслуживания%15.3f\n\n", area_server_status / sim_time);
fprintf(outfile, "время завершения моделирования%12.3f мин, sim_time);
}"

код для функции time_avg_status
"void time_avg_status(void) /* обновляем накопители площади для статистики среднего времени */
{
float time_since_last_event;
/* вычисляем время, прошедшее после последнего события и обновляем маркер времени последнего события */
time_since_last_event = sim_time - time_last_event;
time_last_event = sim_time;
/* обновляем площадь под функцией определения числа требований в очереди */
area_num_in_q += num_in_q * time_since_last_event;
/* обновляем площадь под функцией определения занятости устройства */
area_server_status += server_status * time_since_last_event;
}"
код для функции expon
"float expon(float mean) /*функция для генерирования экспоненциально распределенной случайной величины */
{ /* возвращаем экспоненциально распределенную случайную величину со средним mean */
return -mean * log(lcgrand(1));
}"