Имитационное моделирование на основании предварительно установленных зависимостей

         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;    // Возвратим время до входа след-го клиента

 }

Страницы: 1, 2