Моделирование СМО

#include<stdio.h>                    // Функции потокового ввода - вывода
#include<conio.h>                   // Формирование экракна
#include<math.h>                    // Математические функции
#include<alloc.h>                    // Функции по работе с динам. памятью
//Прототипы функций
float RND_DIG( void );           // Ф-я генерирует случ. числа
void inf( void);                         // Ф-я сообщает о назн-ии программы
void massive( void );                // Ф-я выделяющая память под массив
float _tau( void );                     // Расчет времени обсл-я клиента у кассы
float time_to ( void );               // Расчет времени входа пассажира в зал
//Объявление переменных
float
    tau_min,                                     // Мин. время обсл-я у касс
    tau_max,                                     // Макс. время обсл-я у касс
    *tau,                                            // Тек. время обсл-я у касс
    current_time,                           // Тек. время
    minutes,                                   // Общ. время работы в минутах
    lambda,                                    // Пар-р закона распр-я Пуассона
    enter_time_,                            // Время входа очередного пассажира
    MO,                                         // Мат. ожид-е времени обсл-я
    SKO,                                       // Среднекв. откл-е времени обсл-я у касс
    t_free,                                      // Общ. время простоя касс
    t_free_av,                                // Ср. время простоя
    serve_av,                                 // Ср. % обслуж-я пассажиров
    refuse_av,                                // Ср. % отказов в обсл-ии
    N0=7836,                                // 1-й множитель для расчета случ. числа
    NI=4792,                                  // 2-й множитель для расчета случ. числа
    N,                                             // Прозведение N0 и NI
    ND;                                           // Средние 4 цифры из числа N
 
int
    m,                                               // Кол-во касс
    i,                                                 // Тек. номер кассы
    enter,                                          // Кол-во вошедших
    hours,                                         // Время работы зала в часах
    serve,                                         // Кол-во обслуж-х пассажиров
    refuse,                                        // Кол-во необслуж-х пассажиров
    stand,                                          // Кол-во стоящих в очереди на момент обслуживания
    INDPAS;                                    // Флаг обслуживания пассажиров
// Главная функция программы
 void main(void)
  {
    inf();                                             // cообщение о назначении программы
    textcolor( 14 );                             //установка цвета и фона
    textbackground( 1 );
    clrscr();                                            //очистка экрана
                  /* Прием данных от пользователя */
    printf("\n████████████████████████████████████████████████████████████████████████████████");
    for(i=1;i<=21;i++)
        printf("█                                                                              █");
    printf("████████████████████████████████████████████████████████████████████████████████");
    gotoxy(10,7);
    do
     {
        printf("\n█\tВведите количество касс в кассовом"
                " зале ж\\д вокзала:");
        scanf( "%d", &m );
     }
    while( (m<=0)||(m>=100) );
    do
     {
        printf( "\n█\tВведите параметр распределения Пуассона для"
                " определения" );
        printf( "\n█\t\tвремени между входами пассажиров в зал:" );
        scanf( "%f", &lambda );
     }while( lambda<=0 );
    clrscr();
                            //Вывод рамки
    printf("\n████████████████████████████████████████████████████████████████████████████████");
    for(i=1;i<=21;i++)
        printf("█                                                                              █");
    printf("████████████████████████████████████████████████████████████████████████████████");
    gotoxy(5,3);
    do
     {
        printf( "\n█\n█\tВведите минимальную продолжительность обслуживания " );
        printf( "\n█\t\t\tу кассами:" );
        scanf( "%f", &tau_min );
     }while( tau_min<=0 );
    do
     {
        printf( "\n█\tВведите максимальную продолжительность обслуживания " );
        printf( "\n█\t\t\tу касс:" );
        scanf( "%f", &tau_max );
     }while( tau_max<=tau_min );
    do
     {
        printf( "\n█\tВведите время моделирования работы зала(в ч.):" );
        scanf( "%d", &hours );
     }while( hours<=0 );
    do
     {
        printf("\n█\tВведите математическое ожидание времени обслуживания");
        printf( "\n█\t\tу касс:");
        scanf( "%f", &MO );
     }while( MO<=0 );
    do
     {
        printf( "\n█\tВведите среднеквадратическое отклонение времени ");
        printf( "\n█\tобслуживания у касс:");
        scanf( "%f", &SKO );
     }while( SKO<=0 );
    massive();                                     // создание и обнуление массива
    minutes=floor( hours*60 );          // переведем время работы в минуты
    enter=0;                                        // никто не входил
    serve=0;                                       // никого не обслужили
    refuse=0;                                      // никому не отказали
    t_free=0;                                      // кассы еще не простаивали
    current_time=0;                           // начало отсчета времени с нуля
    enter_time_=time_to();                // когда зайдет следующий
 
                        /* Цикл моделирования работы зала
    for( current_time=0; current_time<=minutes; current_time++ )
    {
                 /* Коррект-ка времени обсл-я у каждой кассы */
        if( current_time )
            for( i=1; i<=m ;i++)
                if( tau[i] )                                          //Если касса занята, то уменьшим время обсл-я
                    tau[i]--;                           // в ней на 1 мин.
                else                                                   // Если касса свободна, наращиваем общее время
                    t_free++;                         // простоя касс.
        if( enter_time_<=current_time )
         {
            enter++;                                                              // Если входит пассажир, отмечаем это
            enter_time_=time_to();                                       // Узнаем, когда зайдет следующий?
            i=1;                                          // Вошедший подходит к 1-й кассе
            INDPAS=1;                                     // Его еще не обслуживают
            do
             {
                if( tau[i]<=0 )           //Если касса свободна, ставим пассажира на
                 {                            //обсл-е и узнаем, сколько ему стоять у кассы
                    tau[i]=_tau();
                    INDPAS=0;                  //Укажем, что пассажира обслуживают
                 }
                i++;                                    // Подходим к следующей кассе
             }while((i<=m) && (INDPAS==1));
            if( INDPAS==1 )                         // Если клиент не обслужен, отмечаем это
                refuse++;
            if( INDPAS==0)                      // Если клиент обслужен, отмечаем это
                serve++;
        }
    }
    stand=0;                                                 // Пока в очереди никто не стоит
    i=1;                                                        // Начинаем с первой кассы
    do
    {
        if( tau[i]>0 )                         // Если время обсл-я не равно нулю, значит
            stand++;                                           // у кассы кто-то стоит
        i++;                                                   // Смотрим у следующей кассы
    }while( i<=m );
 
    serve-=stand;                          // Корректируем кол-во обслуженных
    t_free_av=(float)t_free/m;               // Вычислим ср. время простоя
    serve_av=(float)serve/enter;            // Вычислим ср. % обслуженных
    refuse_av=(float)refuse/enter;        // Вычислим ср. % необслуженных
    textcolor(1);                                  // Установка параметров текста
    textbackground(2);
    clrscr();
    _setcursortype( _NOCURSOR );
                
                    /*Вывод полученных результатов
                        //Вывод рамки
    printf("\n████████████████████████████████████████████████████████████████████████████████");
    for(i=1;i<=21;i++)
        printf("█                                                                              █");
    printf("████████████████████████████████████████████████████████████████████████████████");
    gotoxy(3,3);
    printf(  "\n█\n█\t╔════════════════════════════════════════════════════════════╗ ");
    printf("     \n█\t║ %d железнодорожных касс работало на протяжении: %d часов.",m,hours );
    gotoxy(70,6);
    printf("║");
    printf("     \n█\t║      В зал зашло %d посетителей.", enter );
    gotoxy(70,7);
    printf("║");
    printf("     \n█\t║");
    gotoxy(70,8);
    printf("║");
    printf("  \n█\t║\n█\t║ Было обслужено                         %d человек(а).", serve);
    gotoxy(70,9);
    printf("║");
    printf("  \n█\n█\t║ Ушли необслуженными                     %d человек(а).", refuse);
    gotoxy(70,10);
    printf("║");
    printf("  \n█\n█\t║ В очереди осталось стоять %d человек(а).      ", stand);
    gotoxy(70,11);
    printf("║");
    printf("  \n█\n█\t║ Средний процент обслуживания пассажиров   %.2f%%", serve_av*100);
    gotoxy(70,12);
    printf("║");
    printf("  \n█\n█\t║ Средний процент отказов в обслуживании    %.2f%%", refuse_av*100);
    gotoxy(70,13);
    printf("║");
    printf("  \n█\n█\t║ Всего кассы простаивали:                 %.0fч. %.0f мин. ",floor( t_free/60 ),
    t_free-floor( t_free/60 )*60 );
    gotoxy(70,14);
    printf("║");
    printf("  \n█\n█\t║ Среднее время простоя 1 кассы:           %.0fч. %.0f мин.",
    floor( t_free_av/60 ), t_free_av-floor( t_free_av/60 )*60);
    gotoxy(70,15);
    printf("║");
    gotoxy(70,16);
    printf("║");
    printf("  \n█\t╚════════════════════════════════════════════════════════════╝ ");
    getch();
  }
 
                    //Функция возвращающая СЧ в диапазоне от 0 до 1
float RND_DIG (void)
  {
    float
        x;                                     //СЧ в диапазоне от 0 до 1
    N=(NI*N0);
    ND=floor(N/100);
    ND=(ND/10000-floor(ND/10000))*10000;         // Отбросим первые 2 цифры
    N0=NI;
    NI=ND;
    x=ND/9999;
    return x;
  }
 
     //Ф-я выделяет память под массив времени обсл-я у каждой из касс
void massive( void )
  {
    int i;
    tau=(float *)malloc( (m+1)*sizeof(float) );
                    /* Обнуление элементов массива */
    for(i=1; i<=m; i++)
        tau[i]=0;
  }
        // Ф-я возвр. время обсл-я у кассы
float _tau( void )
  {
    float
        x,                                             // Случайное число x
        y,                                             // Случайное число y
        z,                                             // Случайное число z
        tau_;                                         // Время обслуживания
                            // Проверка на четность
                            //---------------------
    if( floor ( ( float )i/2 )==ceil( ( float )i/2 ) )
     {
        x=RND_DIG();                           // Запрос случ. числа от ДСЧ
        y=RND_DIG();                           // Запрос случ. числа от ДСЧ
        if( x>=.0001)             // Если х не слишком маленькое, считаем z
            z=sqrt( -2*log( x ) )*sin( 2*M_PI*y );
        else
         {
            if( sin( 2*M_PI*y )<=0 )
                z=0;             // Если оба множителя слишком малы, то z=0
            else
                z=(float)minutes/2;       //Если 2-й множ-ль нормальный, то
         }                    //вел-на z равна половине времени работы зала.
        tau_=MO+z*SKO;    // Вычислим нормально распределенное время обсл-я
        if( tau_<0 )            // Если время отрицательно, оно равно 1 мин.
            tau_=1;
     }
    else
     {
        x=RND_DIG();                        // Запрос случ. величины от ДСЧ
                /* Вычислим равномерно распределенное время обсл-я */
                //--------------------------------------------------
        tau_=floor( tau_min+x*( tau_max-tau_min )+.5);
     }
        return floor( tau_+.5 );                  //Выведем в место запроса
 }
        //  Ф-я определяет время входа след-го клиента. Промежутки
        //  между входами распределены по закону Пуассона с пар-м lambda
        //  ============================================================
 float time_to( void )
  {
    int
      j;                                   // Пар-р закона распр-я Пуассона
    float
        x,                                                  // Случ. вел-на
        tau,                                              // Время до входа
        a,                                          // Пар-р закона распр-я
        n,                                // Половина общего времени работы
        S;                                          // Пар-р закона распр-я
    n=floor( minutes/2+0.5 );
    x=RND_DIG();                                      // Примем случ. число
    tau=0;
    j=0;
    a=exp( (lambda * (-1)) );                // Расчет нач. знач-я пар-ра а
    S=0;
    do
     {
        if( S>=x && x<S+a ) // Проверка х на пренадл-ть промежутку [S ; S+a)
            break;
        tau++;
        j++;
        S+=a;
        a*=lambda/j;
     }
    while( tau<=n );
    return current_time+tau;    // Возвратим время до входа след-го клиента
 }

#include<stdio.h>                    // Ôóíêöèè ïîòîêîâîãî ââîäà - âûâîäà
#include<conio.h>                   // Ôîðìèðîâàíèå ýêðàíà
#include<math.h>                    // Ìàòåìàòè÷åñêèå ôóíêöèè
#include<alloc.h>                   // Ôóíêöèè ïî ðàáîòå ñ äèíàì. ïàìÿòüþ
#include<stdlib.h>                   
#include<graphics.h>
//Ïðîòîòèïû ôóíêöèé 
   float RND_DIG( void ); // Ô-ÿ ãåíåðèðóåò ñëó÷. ÷èñëà 
   int inf( void); // Ô-ÿ ñîîáùàåò î íàçí-èè ïðîãðàììû 
   int massive( void ); // Ô-ÿ âûäåëÿþùàÿ ïàìÿòü ïîä ìàññèâ 
   float _tau( void ); // Ðàñ÷åò âðåìåíè îáñë-ÿ êëèåíòà ó êàññû 
   float time_to ( void ); // Ðàñ÷åò âðåìåíè âõîäà ïàññàæèðà â çàë 
//Îáúÿâëåíèå ïåðåìåííûõ 
    float 
 tau_min, // Ìèí. âðåìÿ îáñë-ÿ ó êàññ 
 tau_max, // Ìàêñ. âðåìÿ îáñë-ÿ ó êàññ 
 *tau, // Òåê. âðåìÿ îáñë-ÿ ó êàññ 
 current_time, // Òåê. âðåìÿ 
 minutes, // Îáù. âðåìÿ ðàáîòû â ìèíóòàõ 
 lambda, // Ïàð-ð çàêîíà ðàñïð-ÿ Ïóàññîíà 
 enter_time_, // Âðåìÿ âõîäà î÷åðåäíîãî ïàññàæèðà 
 MO, // Ìàò. îæèä-å âðåìåíè îáñë-ÿ 
 SKO, // Ñðåäíåêâ. îòêë-å âðåìåíè îáñë-ÿ ó êàññ 
 t_free, // Îáù. âðåìÿ ïðîñòîÿ êàññ 
 t_free_av, // Ñð. âðåìÿ ïðîñòîÿ 
 serve_av, // Ñð. % îáñëóæ-ÿ ïàññàæèðîâ 
 refuse_av, // Ñð. % îòêàçîâ â îáñë-èè 
 N0=7836, // 1-é ìíîæèòåëü äëÿ ðàñ÷åòà ñëó÷. ÷èñëà 
 NI=4792, // 2-é ìíîæèòåëü äëÿ ðàñ÷åòà ñëó÷. ÷èñëà 
 N, // Ïðîçâåäåíèå N0 è NI 
 ND; // Ñðåäíèå 4 öèôðû èç ÷èñëà N 
    int 
 m, // Êîë-âî êàññ 
 i, // Òåê. íîìåð êàññû 
 enter, // Êîë-âî âîøåäøèõ 
 hours, // Âðåìÿ ðàáîòû çàëà â ÷àñàõ 
 serve, // Êîë-âî îáñëóæ-õ ïàññàæèðîâ 
 refuse, // Êîë-âî íåîáñëóæ-õ ïàññàæèðîâ 
 stand, // Êîë-âî ñòîÿùèõ â î÷åðåäè íà ìîìåíò îáñëóæèâàíèÿ 
 INDPAS; // Ôëàã îáñëóæèâàíèÿ ïàññàæèðîâ 
// Ãëàâíàÿ ôóíêöèÿ ïðîãðàììû 
     int main(void) 
 { 
    inf(); // cîîáùåíèå î íàçíà÷åíèè ïðîãðàììû 
    int textcolor(int color);
    textcolor( 14 ); //óñòàíîâêà öâåòà è ôîíà 
    int textbackground(int color);
    textbackground( 1 ); 
   // system('cls');//î÷èñòêà ýêðàíà 
/* Ïðèåì äàííûõ îò ïîëüçîâàòåëÿ */ 
printf("\n--------------------------------------------------------------------------------"); 
for(i=1;i<=21;i++) 
printf("- -"); 
printf("--------------------------------------------------------------------------------"); 
void gotoxy(int x, int y);
gotoxy(10,7); 
   do 
   { 
printf("\n-\tÂâåäèòå êîëè÷åñòâî êàññ â êàññîâîì" 
" çàëå æ\\ä âîêçàëà:"); 
scanf( "%d", &m ); 
   } 
   while( (m<=0)||(m>=100) ); 
     do 
      { 
printf( "\n-\tÂâåäèòå ïàðàìåòð ðàñïðåäåëåíèÿ Ïóàññîíà äëÿ" 
" îïðåäåëåíèÿ" ); 
printf( "\n-\t\tâðåìåíè ìåæäó âõîäàìè ïàññàæèðîâ â çàë:" ); 
scanf( "%f", &lambda ); 
      }
  while( lambda<=0 ); 
  //system('cls'); 
//Âûâîä ðàìêè 
printf("\n--------------------------------------------------------------------------------"); 
for(i=1;i<=21;i++) 
printf("- -"); 
printf("--------------------------------------------------------------------------------"); 
gotoxy(5,3); 
   do 
   { 
printf( "\n-\n-\tÂâåäèòå ìèíèìàëüíóþ ïðîäîëæèòåëüíîñòü îáñëóæèâàíèÿ " ); 
printf( "\n-\t\t\tó êàññàìè:" ); 
scanf( "%f", &tau_min ); 
   }
while( tau_min<=0 ); 
       do 
       { 
printf( "\n-\tÂâåäèòå ìàêñèìàëüíóþ ïðîäîëæèòåëüíîñòü îáñëóæèâàíèÿ " ); 
printf( "\n-\t\t\tó êàññ:" ); 
scanf( "%f", &tau_max ); 
       }
while( tau_max<=tau_min ); 
    do 
    { 
printf( "\n-\tÂâåäèòå âðåìÿ ìîäåëèðîâàíèÿ ðàáîòû çàëà(â ÷.):" ); 
scanf( "%d", &hours ); 
    }
while( hours<=0 ); 
         do 
         { 
printf("\n-\tÂâåäèòå ìàòåìàòè÷åñêîå îæèäàíèå âðåìåíè îáñëóæèâàíèÿ"); 
printf( "\n-\t\tó êàññ:"); 
scanf( "%f", &MO ); 
          }
while( MO<=0 ); 
     do 
     { 
printf( "\n-\tÂâåäèòå ñðåäíåêâàäðàòè÷åñêîå îòêëîíåíèå âðåìåíè "); 
printf( "\n-\tîáñëóæèâàíèÿ ó êàññ:"); 
scanf( "%f", &SKO ); 
     }
  while( SKO<=0 ); 
massive(); // ñîçäàíèå è îáíóëåíèå ìàññèâà 
minutes=floor( hours*60 ); // ïåðåâåäåì âðåìÿ ðàáîòû â ìèíóòû 
enter=0; // íèêòî íå âõîäèë 
serve=0; // íèêîãî íå îáñëóæèëè 
refuse=0; // íèêîìó íå îòêàçàëè 
t_free=0; // êàññû åùå íå ïðîñòàèâàëè 
current_time=0; // íà÷àëî îòñ÷åòà âðåìåíè ñ íóëÿ 
enter_time_=time_to(); // êîãäà çàéäåò ñëåäóþùèé 
/* Öèêë ìîäåëèðîâàíèÿ ðàáîòû çàëà */
          for( current_time=0; current_time<=minutes; current_time++ ) 
       { 
/* Êîððåêò-êà âðåìåíè îáñë-ÿ ó êàæäîé êàññû */ 
if( current_time ) 
for( i=1; i<=m ;i++) 
if( tau[i] ) //Åñëè êàññà çàíÿòà, òî óìåíüøèì âðåìÿ îáñë-ÿ 
tau[i]--; // â íåé íà 1 ìèí. 
else // Åñëè êàññà ñâîáîäíà, íàðàùèâàåì îáùåå âðåìÿ 
t_free++; // ïðîñòîÿ êàññ. 
if( enter_time_<=current_time ) 
{ 
enter++; // Åñëè âõîäèò ïàññàæèð, îòìå÷àåì ýòî 
enter_time_=time_to(); // Óçíàåì, êîãäà çàéäåò ñëåäóþùèé? 
i=1; // Âîøåäøèé ïîäõîäèò ê 1-é êàññå 
INDPAS=1; // Åãî åùå íå îáñëóæèâàþò 
do 
{ 
if( tau[i]<=0 ) //Åñëè êàññà ñâîáîäíà, ñòàâèì ïàññàæèðà íà 
{ //îáñë-å è óçíàåì, ñêîëüêî åìó ñòîÿòü ó êàññû 
tau[i]=_tau(); 
INDPAS=0; //Óêàæåì, ÷òî ïàññàæèðà îáñëóæèâàþò 
} 
i++; // Ïîäõîäèì ê ñëåäóþùåé êàññå 
}while((i<=m) && (INDPAS==1)); 
if( INDPAS==1 ) // Åñëè êëèåíò íå îáñëóæåí, îòìå÷àåì ýòî 
refuse++; 
if( INDPAS==0) // Åñëè êëèåíò îáñëóæåí, îòìå÷àåì ýòî 
serve++; 
} 
} 
stand=0; // Ïîêà â î÷åðåäè íèêòî íå ñòîèò 
i=1; // Íà÷èíàåì ñ ïåðâîé êàññû 
do 
{ 
if( tau[i]>0 ) // Åñëè âðåìÿ îáñë-ÿ íå ðàâíî íóëþ, çíà÷èò 
stand++; // ó êàññû êòî-òî ñòîèò 
i++; // Ñìîòðèì ó ñëåäóþùåé êàññû 
}while( i<=m ); 
serve-=stand; // Êîððåêòèðóåì êîë-âî îáñëóæåííûõ 
t_free_av=(float)t_free/m; // Âû÷èñëèì ñð. âðåìÿ ïðîñòîÿ 
serve_av=(float)serve/enter; // Âû÷èñëèì ñð. % îáñëóæåííûõ 
refuse_av=(float)refuse/enter; // Âû÷èñëèì ñð. % íåîáñëóæåííûõ 
int textcolor(int color);
textcolor(1); // Óñòàíîâêà ïàðàìåòðîâ òåêñòà 
textbackground(2); 
//system('cls'); 
void _setcursortype(int type);
_setcursortype( _NOCURSOR ); 
 
//Âûâîä ïîëó÷åííûõ ðåçóëüòàòîâ 
//Âûâîä ðàìêè 
printf("\n--------------------------------------------------------------------------------"); 
for(i=1;i<=21;i++) 
printf("- -"); 
printf("--------------------------------------------------------------------------------"); 
gotoxy(3,3); 
printf( "\n-\n-\tã============================================================¬ "); 
printf(" \n-\t¦ %d æåëåçíîäîðîæíûõ êàññ ðàáîòàëî íà ïðîòÿæåíèè: %d ÷àñîâ.",m,hours ); 
gotoxy(70,6); 
printf("¦"); 
printf(" \n-\t¦ Â çàë çàøëî %d ïîñåòèòåëåé.", enter ); 
gotoxy(70,7); 
printf("¦"); 
printf(" \n-\t¦"); 
gotoxy(70,8); 
printf("¦"); 
printf(" \n-\t¦\n-\t¦ Áûëî îáñëóæåíî %d ÷åëîâåê(à).", serve); 
gotoxy(70,9); 
printf("¦"); 
printf(" \n-\n-\t¦ Óøëè íåîáñëóæåííûìè %d ÷åëîâåê(à).", refuse); 
gotoxy(70,10); 
printf("¦"); 
printf(" \n-\n-\t¦  î÷åðåäè îñòàëîñü ñòîÿòü %d ÷åëîâåê(à). ", stand); 
gotoxy(70,11); 
printf("¦"); 
printf(" \n-\n-\t¦ Ñðåäíèé ïðîöåíò îáñëóæèâàíèÿ ïàññàæèðîâ %.2f%%", serve_av*100); 
gotoxy(70,12); 
printf("¦"); 
printf(" \n-\n-\t¦ Ñðåäíèé ïðîöåíò îòêàçîâ â îáñëóæèâàíèè %.2f%%", refuse_av*100); 
gotoxy(70,13); 
printf("¦"); 
printf(" \n-\n-\t¦ Âñåãî êàññû ïðîñòàèâàëè: %.0f÷. %.0f ìèí. ",floor( t_free/60 ), 
t_free-floor( t_free/60 )*60 ); 
gotoxy(70,14); 
printf("¦"); 
printf(" \n-\n-\t¦ Ñðåäíåå âðåìÿ ïðîñòîÿ 1 êàññû: %.0f÷. %.0f ìèí.", 
floor( t_free_av/60 ), t_free_av-floor( t_free_av/60 )*60); 
gotoxy(70,15); 
printf("¦"); 
gotoxy(70,16); 
printf("¦"); 
printf(" \n-\tL============================================================- "); 
getch(); 
} 
//Ôóíêöèÿ âîçâðàùàþùàÿ Ñ× â äèàïàçîíå îò 0 äî 1 
float RND_DIG (void) 
{ 
float 
x; //Ñ× â äèàïàçîíå îò 0 äî 1 
N=(NI*N0); 
ND=floor(N/100); 
ND=(ND/10000-floor(ND/10000))*10000; // Îòáðîñèì ïåðâûå 2 öèôðû 
N0=NI; 
NI=ND; 
x=ND/9999; 
return x; 
} 
//Ô-ÿ âûäåëÿåò ïàìÿòü ïîä ìàññèâ âðåìåíè îáñë-ÿ ó êàæäîé èç êàññ 
int massive( void ) 
{ 
int i; 
tau=(float *)malloc( (m+1)*sizeof(float) ); 
/* Îáíóëåíèå ýëåìåíòîâ ìàññèâà */ 
for(i=1; i<=m; i++) 
tau[i]=0; 
} 
// Ô-ÿ âîçâð. âðåìÿ îáñë-ÿ ó êàññû 
float _tau( void ) 
{ 
float 
x, // Ñëó÷àéíîå ÷èñëî x 
y, // Ñëó÷àéíîå ÷èñëî y 
z, // Ñëó÷àéíîå ÷èñëî z 
tau_; // Âðåìÿ îáñëóæèâàíèÿ 
// Ïðîâåðêà íà ÷åòíîñòü 
//--------------------- 
if( floor ( ( float )i/2 )==ceil( ( float )i/2 ) ) 
{ 
x=RND_DIG(); // Çàïðîñ ñëó÷. ÷èñëà îò ÄÑ× 
y=RND_DIG(); // Çàïðîñ ñëó÷. ÷èñëà îò ÄÑ× 
if( x>=.0001) // Åñëè õ íå ñëèøêîì ìàëåíüêîå, ñ÷èòàåì z 
z=sqrt( -2*log( x ) )*sin( 2*M_PI*y ); 
else 
{ 
if( sin( 2*M_PI*y )<=0 ) 
z=0; // Åñëè îáà ìíîæèòåëÿ ñëèøêîì ìàëû, òî z=0 
else 
z=(float)minutes/2; //Åñëè 2-é ìíîæ-ëü íîðìàëüíûé, òî 
} //âåë-íà z ðàâíà ïîëîâèíå âðåìåíè ðàáîòû çàëà. 
tau_=MO+z*SKO; // Âû÷èñëèì íîðìàëüíî ðàñïðåäåëåííîå âðåìÿ îáñë-ÿ 
if( tau_<0 ) // Åñëè âðåìÿ îòðèöàòåëüíî, îíî ðàâíî 1 ìèí. 
tau_=1; 
} 
else 
{ 
x=RND_DIG(); // Çàïðîñ ñëó÷. âåëè÷èíû îò ÄÑ× 
/* Âû÷èñëèì ðàâíîìåðíî ðàñïðåäåëåííîå âðåìÿ îáñë-ÿ */ 
//-------------------------------------------------- 
tau_=floor( tau_min+x*( tau_max-tau_min )+.5); 
} 
return floor( tau_+.5 ); //Âûâåäåì â ìåñòî çàïðîñà 
} 
// Ô-ÿ îïðåäåëÿåò âðåìÿ âõîäà ñëåä-ãî êëèåíòà. Ïðîìåæóòêè 
// ìåæäó âõîäàìè ðàñïðåäåëåíû ïî çàêîíó Ïóàññîíà ñ ïàð-ì lambda 
// ============================================================ 
float time_to( void ) 
{ 
int 
j; // Ïàð-ð çàêîíà ðàñïð-ÿ Ïóàññîíà 
float 
x, // Ñëó÷. âåë-íà 
tau, // Âðåìÿ äî âõîäà 
a, // Ïàð-ð çàêîíà ðàñïð-ÿ 
n, // Ïîëîâèíà îáùåãî âðåìåíè ðàáîòû 
S; // Ïàð-ð çàêîíà ðàñïð-ÿ 
n=floor( minutes/2+0.5 ); 
x=RND_DIG(); // Ïðèìåì ñëó÷. ÷èñëî 
tau=0; 
j=0; 
a=exp( (lambda * (-1)) ); // Ðàñ÷åò íà÷. çíà÷-ÿ ïàð-ðà à 
S=0; 
do 
{ 
if( S>=x && x)
break; 
tau++; 
j++; 
S+=a; 
a*=lambda/j; 
} 
while( tau<=n ); 
return current_time+tau; // Âîçâðàòèì âðåìÿ äî âõîäà ñëåä-ãî êëèåíòà 
}