W = - среднее время пребывания заявки в очереди

U = - среднее время пребывания заявки в системе

L = - среднее число заявок в системе

Скорость работы канала

5

10

15

20

25

30

35

40

45

50

Среднее время пребывания заявки в очереди

385.0188

178.8058

110.0682

75.7287

55.1668

41.4589

31.6675

24.3240

18.6123

14.0430

Среднее время пребывания заявки в системе

393.3088

182.9508

112.8315

77.8012

56.8248

42.8405

32.8518

25.3602

19.5334

14.8720

Среднее число заявок в системе

47.4438

44.1377

40.8317

37.5344

34.2546

30.9773

27.7027

24.4307

21.1613

17.8944

Как и в предыдущих случаях, построим графики исследуемых зависимостей:

Из анализа графиков видно, что среднее время пребывания заявки как в очереди, так и в системе с увеличением скорости работы канала убывает. Среднее количество заявок в системе также уменьшается при большой скорости работы канала.

Исходный текст программы:

#include <stdio.h>

#include <conio. h>

#include <math. h>

struct Msg {

int type;

int len;

double time;

} msg;

struct Demand {

int type;

int len;

double inSystem;

double outQueue;

double outSystem;

};

const int N = 100;

const int N_TYPE = 3;

Demand DemandArray[N];

void loadArray() {

FILE * fin = fopen("mod3.txt", "rb");

for (int i = 0; i < N; i++) {

fread(&msg, sizeof(Msg), 1, fin);

DemandArray[i].type = msg. type;

DemandArray[i].len = msg. len;

НЕ нашли? Не то? Что вы ищете?

DemandArray[i].inSystem = msg. time;

DemandArray[i].outQueue = 0;

DemandArray[i].outSystem = 0;

}

fclose(fin);

}

void treatment(FILE * fout, int V) {

double v[N_TYPE], D[N_TYPE], sigma[N_TYPE];

double mu[N_TYPE], lambda1[N_TYPE];

double ro[N_TYPE], eta[N_TYPE];

double R, Lambda;

double r[N_TYPE], lambda2[N_TYPE], p[N_TYPE];

double w[N_TYPE], u[N_TYPE], l[N_TYPE];

double W, U, L;

double array[N];

int numMsg[N_TYPE];

int i;

for (i = 0; i < N_TYPE; i++) {

v[i] = D[i] = sigma[i] = mu[i] = lambda1[i] = ro[i] = eta[i] = r[i] = 0;

lambda2[i] = p[i] = w[i] = u[i] = l[i] = 0;

numMsg[i] = 0;

}

R = Lambda = W = U = L = 0;

for (i = 0; i < 100; i++)

numMsg[DemandArray[i].type - 1]++;

for (i = 0; i < 100; i++)

array[i] = DemandArray[i].outSystem - DemandArray[i].outQueue;

for (i = 0; i < 100; i++)

v[DemandArray[i].type - 1] += array[i];

for (i = 0; i < N_TYPE; i++)

v[i] /= numMsg[i];

for (i = 0; i < 100; i++)

D[DemandArray[i].type - 1] += array[i] * array[i];

for (i = 0; i < N_TYPE; i++) {

D[i] /= numMsg[i];

D[i] -= v[i] * v[i];

}

for (i = 0; i < N_TYPE; i++)

sigma[i] = sqrt(D[i]);

for (i = 0; i < N_TYPE; i++)

mu[i] = 1.0 / v[i];

double totalTime = DemandArray[99].outSystem;

for (i = 0; i < N_TYPE; i++)

lambda1[i] = 1.0 * numMsg[i] / totalTime;

for (i = 0; i < N_TYPE; i++)

ro[i] = lambda1[i] / mu[i];

for (i = 0; i < N_TYPE; i++)

eta[i] = 1.0 - ro[i];

for (i = 0; i < N_TYPE; i++)

R += ro[i];

for (i = 0; i < N_TYPE; i++)

Lambda += lambda1[i];

for (i = 0; i < N_TYPE; i++) {

int j = 0;

while ((DemandArray[j].type - 1) != i) j++;

double start = DemandArray[j].inSystem;

j = 99;

while ((DemandArray[j].type - 1) != i) j--;

double end = DemandArray[j].inSystem;

r[i] = (end - start) / (numMsg[i] - 1);

}

for (i = 0; i < N_TYPE; i++)

lambda2[i] = 1.0 / r[i];

for (i = 0; i < N_TYPE; i++)

p[i] = lambda1[i] / Lambda;

for (i = 0; i < 100; i++)

array[i] = DemandArray[i].outQueue - DemandArray[i].inSystem;

for (i = 0; i < 100; i++)

w[DemandArray[i].type - 1] += array[i];

for (i = 0; i < N_TYPE; i++)

w[i] /= numMsg[i];

for (i = 0; i < 100; i++)

array[i] = DemandArray[i].outSystem - DemandArray[i].inSystem;

for (i = 0; i < 100; i++)

u[DemandArray[i].type - 1] += array[i];

for (i = 0; i < N_TYPE; i++)

u[i] /= numMsg[i];

for (i = 0; i < N_TYPE; i++)

l[i] = w[i] * lambda1[i];

for (i = 0; i < N_TYPE; i++)

W += p[i] * w[i];

for (i = 0; i < N_TYPE; i++)

U += p[i] * u[i];

for (i = 0; i < N_TYPE; i++)

L += lambda1[i] * u[i];

fprintf(fout, "======================================================\n");

fprintf(fout, "Скорость работы канала равна %d\n", V);

fprintf(fout, "Среднее время обслуживания заявки i-го типа:\n");

for (i = 0; i < N_TYPE; i++)

fprintf(fout, "%6.4f\t%6.4f\t%6.4f\n", v[i], D[i], sigma[i]);

fprintf(fout, "\n\n");

fprintf(fout, "Интенсивность обслуживания:\n");

for (i = 0; i < N_TYPE; i++)

fprintf(fout, "%6.4f\n", mu[i]);

fprintf(fout, "\n\n");

fprintf(fout, "Среднее число заявок i-го типа, поступающих во время работы системы:\n");

for (i = 0; i < N_TYPE; i++)

fprintf(fout, "%6.4f\n", lambda1[i]);

fprintf(fout, "\n\n");

fprintf(fout, "Коэффициенты загрузки и простоя:\n");

for (i = 0; i < N_TYPE; i++)

fprintf(fout, "%6.4f\t%6.4f\n", ro[i], eta[i]);

fprintf(fout, "\n\n");

fprintf(fout, "Коэффициент загрузки и интенсивность:\n");

fprintf(fout, "%6.4f\t%6.4f\n", R, Lambda);

fprintf(fout, "\n\n");

fprintf(fout, "Ср. промежутки времени, интенсивность поступления и вероятность поступления:\n");

for (i = 0; i < N_TYPE; i++)

fprintf(fout, "%6.4f\t%6.4f\t%6.4f\n", r[i], lambda2[i], p[i]);

fprintf(fout, "\n\n");

fprintf(fout, "Время пребывания заявки в очереди, системе, длина очереди (i-го типа заявок):\n");

for (i = 0; i < N_TYPE; i++)

fprintf(fout, "%6.4f\t%6.4f\t%6.4f\n", w[i], u[i], l[i]);

fprintf(fout, "\n\n");

fprintf(fout, "Время пребывания заявки в очереди, системе, длина очереди:\n");

fprintf(fout, "%6.4f\t%6.4f\t%6.4f\n", W, U, L);

fprintf(fout, "\n\n");

}

void main() {

clrscr();

FILE * fout = fopen("modelir4.txt", "wt");

for (int V = 10; V <= 100; V += 10) {

int i;

loadArray();

double curTime = 0;

for (i = 0; i < 100; i++) {

if (DemandArray[i].inSystem > curTime)

curTime = DemandArray[i].inSystem;

DemandArray[i].outQueue = curTime;

curTime += 1.0 * DemandArray[i].len / V;

DemandArray[i].outSystem = curTime;

}

treatment(fout, V);

}

fclose(fout);

printf("Test done!");

if (getch() == 0) getch();

}

Из за большого объема этот материал размещен на нескольких страницах:
1 2 3 4