Отчет по курсовой работе по программированию «Моделирование перекрёстка со светофором»
Автор: student \| Категория: Технические науки \| Просмотров: 843 \| Комментирии: 0 \| 05-08-2020 22:28

Скачать: otchet.zip [407,24 Kb] (cкачиваний: 10)

Отчет

по курсовой работе

по программированию

«Моделирование перекрёстка со светофором»

Оглавление

Постановка задачи. 3

Описание классов. 4

Класс Simulation. 4

Класс Mashina. 6

Класс RandomNumber. 7

Взаимосвязь классов. 9

Описание разработанного приложения. 10

Тестирование. 13

Заключение. 15

Список использованной литературы.. 16

Листинг. 17

Постановка задачи

Данное приложение разработано для моделирования перекрёстка со светофором. Программа моделирует движение машин через перекрёсток по четырём направлениям. Моделирование осуществляется N раз (N – количество итераций) и на экран выводятся усреднённые результаты. Таким образом, чем больше N, тем результат более близок к реальному.

Входные данные:

Общие начальные данные для всех направлений:

Продолжительность моделируемого периода (время, в течение которого на перекрёсток буду прибывать машины)
Режим работы светофора: время горения запрещающего и разрешающего сигналов. С разрешающего сигнала светофор начинает работать по 1-му и 2-му направлениям .
Количество программных итераций (N)

Начальные данные по каждому из 4-х направлений:

количество полос для движения (пропускная способность перекрёстка по данному направлению).Максимальное количество полос = 10.
интенсивность движения машин (диапазон времени между прибытием машин)
диапазон времени задержки машин на перекрёстке (т.е. время, которое водитель, при разрешающем сигнале светофора, потратит на то, чтобы освободить перекрёсток )

Результаты моделирования (по каждому направлению):

количество машин, проехавших через перекрёсток
загруженность каждой полосы (количество машин, проехавших по каждой полосе)
среднее время ожидания в пробке
среднее время ожидания на светофоре

Описание классов

Класс Simulation

Назначение класса. Класс предназначен для того, чтобы хранить начальные данные, собирать статистику результатов моделирования, осуществлять запуск моделирования и обрабатывать результаты моделирования.

Данные-элементы класса.

RandomNumber rnd – объект класса RandomNumber, использующийся для рассчёта случайных значений

static int TGlobal – переменная для имитации глобального времени

static int timе - длина моделируемого периода работы

int *kolPol - количество полос для движения по каждому из 4-х направлений

static int *arrivalLow , static int *arrivalHigh - диапазон времени между приходами машин по каждому из 4-х направлений

static int *delayLow, static int *delayHigh - диапазон времени задержки машин на перекрёстке по каждому из 4-х направлений

static int TimeGreen - время горения разрешающего сигнала светофора (в секундах)

static int TimeRed - время горения запрещающего сигнала светофора (в секундах)

static int *countElem - количество машин, проехавших через перекрёсток по каждому из 4-х направлений

Данные-элементы, предназначенные для накопления статистики по каждой машине:

static int **Pol – номер полосы для движения, по которой проехала машина по каждому из 4-х направлений

static int **ojOch - время ожидания в очереди (т.е. в случае, когда при прибытии машины на перекрёсток, предыдущая машина ещё не покинула перекрёсток) по каждому из 4-х направлений

static int *ojSv - время ожидания при запрещающем сигнале светофора по каждому из 4-х направлений

Данные для накопления статистики при N программных итераций

static int **countE - [N][4] - хранит количество машин, проехавших через перекрёсток, для каждой итерации

static int **srTimeOjOch - [N][4] среднее время ожидания в пробке по каждому из 4-х направлений по каждой из N итераций

static int **srTimeOjSv - [N][4] среднее время ожидания на светофоре по каждому из 4-х направлений по каждой из N итераций

Интерфейс класса.

Simulation(int, int*, int*, int*, int*, int*, int, int, int) – конструктор класса. В качестве параметров конструктору передаются следующие значения:

длина моделируемого периода работы
количество полос для движения по каждому из 4-х направлений
диапазон времени между приходами машин по каждому из 4-х направлений
диапазон времени задержки машин на перекрёстке по каждому из 4-х направлений
время горения разрешающего сигнала светофора (в секундах)
время горения запрещающего сигнала светофора (в секундах)
количество программных итераций

Переданные значения помещаются в соответствующие статические переменные, помеченные как защищённые. Метка static используется для того, чтобы значения этих переменных были одинаковы для всех элементов подкласса Mashina, являющегося наследником класса Simulation.

void RunSimulation() – открытая функция-элемент класса, предназначенная для запуска моделирования. Она создаёт массив элементов класса Mashina, представляющий собой двусвязный список и имитирующий очередь машин. Количество элементов в массиве соответствует количеству полос для движения. Затем она вычисляет время прибытия каждой машины и помещает её в соответствующий список.

При помещении машины в список, в специальные данные-члены класса помещается вся информация по данной машине. Так, в этих данных-членах накапливается информация о всех машинах, проехавших через перекрёсток.

Так же здесь происходит изменение глобального времени путём прибавления к нему времени прибытия очередной машины. Моделирование завершается тогда, когда глобальное время становится больше времени моделирования, которое задаётся пользователем.

Весь этот процесс моделирования выполняется в цикле N раз. При каждой итерации заполняются массивы, предназначенные для сбора статистики по всем итерациям.

Функции-утилиты.

int SrTimeOjOch(int h) - возвращает среднее время ожидания в пробке. В качестве аргумента функции передаётся номер направления

int SrTimeOjSv(int h) - возвращает среднее время ожидания на светофоре.

Класс Mashina

Назначение класса. Класс предназначен для имитации очереди машин. Он представляет собой двусвязный список, в который добавляются машины, прибывшие на перекрёсток. На время отбытия прибывшей машины влияет время отбытия предшествующей ей машины, т.к. машина может покинуть перекрёсток только после того, как покинет перекрёсток стоящая перед ней машина.

Данные-элементы класса.

Открытые данные-элементы, обеспечивающие работу двусвязного списка:

Mashina *pHead - указатель на первый элемент списка

Mashina *pPrev - указатель на последний элемент списка

Mashina *next, *pred - указатели на следующий и на предыдущий элементы списка

Закрытые данные-элементы, содержащие всю информацию об элементе списка:

int Tprib - время прибытия

int TojPer - время ожидания на перекрёстке

int TojOch - время ожидания в очереди (т.е. в случае, когда при прибытии машины на перекрёсток, предыдущая машина ещё не покинула перекрёсток)

int TojSv - время ожидания при запрещающем сигнале светофора

int Totb - время отбытия с перекрёстка

Интерфейс класса.

void addToList(int, int, int, int) - функция добавления элемента в список. В качестве параметров функции передаётся время прибытия машины, номер полосы, на которую встала машина, номер направления и номер итерации. Вся остальная информация о машине (время ожидания на перекрёстке, время ожидания в очереди, время ожидания при запрещающем сигнале светофора, время отбытия с перекрёстка) рассчитывается внутри функции. Все данные о машине записываются в статические данные-элементы класса Simulation, которые накапливают информацию о всех машинах, прошедших через перекрёсток.

int KolOstMash(int) - в качестве параметра функции передаётся время прибытия очередной машины. Функция возвращает количество машин, время отбытия которых (Totb) больше, чем время прибытия очередной машины (tprib), т.е. количество машин, ещё не уехавших с перекрёстка в момент прибытия очередной машины. Значение, возвращаемое функцией используется в открытой функции-элементе RunSimulation класса Simulation при выборе полосы, на которую встать машине при подъезде к перекрёстку. Выбирается та полоса, на которой меньше (не уехавших!) машин.

Класс RandomNumber

Назначение класса. Класс предназначен для получения случайных натуральных чисел, которые используются для расчёта времени прибытия машины и времени ожидания машины на перекрёстке.

Данные-элементы класса.

unsigned long randSeed - текущее seed-значение

Интерфейс класса.

RandomNumber () – конструктор. Задаёт seed-значение посредством функции time (0).

unsigned short Random ( unsigned long n ) - функция, которая возвращает целое псевдослучайное число, равномерно распределенное в диапазоне [ 0, n -1 ].

При каждом вызове функция изменяет текущее значение своего параметра (seed-значение) и создает из него случайное число. Функция в силу детерминированной природы алгоритма создает не абсолютно случайные числа, а псевдослучайные числа. Если запускать генератор с одним и тем же начальным seed-значением, то он будет порождать одну и ту же последовательность псевдослучайных чисел. Однако, если его запускать с разными начальными seed-значениями, то он будет создавать уникальные последовательности псевдослучайных чисел.

Взаимосвязь классов

- наследование

- композиция

Описание разработанного приложения

При первом запуске приложения пользователю предлагается ввести исходные данные для моделирования:

Вводим начальные данные и нажимаем кнопку «Запустить моделирование».

На форме появилась надпись «Моделирование успешно завершено!».

Результаты моделирования появились на информационном табло.

При этом в директории, откуда запускалось приложение, создался файл с именем «data.txt», куда записались начальные значения, введённые пользователем.

Теперь, при следующем запуске программы, начальные значения, сохранённые при предыдущем моделировании, автоматически заполнят пустые ячейки:

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

Тестирование

Задаём следующие начальные значения:

Длина моделируемого периода : 3 мин

Время горения разрешающего сигнала светофора :20 сек

Время горения запрещающего сигнала светофора :25 сек

Количество программных итераций : 1000

1-е направление

Интервал времени между прибытием машин : 2 - 3 сек

Интервал времени задержки машин на перекрёстке : 3 - 5 сек

Количество полос : 3

2-е направление

Интервал времени между прибытием машин : 1 - 3 сек

Интервал времени задержки машин на перекрёстке : 2 - 4 сек

Количество полос : 1

3-е направление

Интервал времени между прибытием машин : 4 - 6 сек

Интервал времени задержки машин на перекрёстке : 2 - 12 сек

Количество полос : 5

4-е направление

Интервал времени между прибытием машин : 5 - 10 сек

Интервал времени задержки машин на перекрёстке : 6 - 7 сек

Количество полос : 2

Результаты моделирования:

1-е направление

Количество машин, проехавших через перекрёсток = 71

по 1-ой полосе : 25

по 2-ой полосе : 24

по 3-ой полосе : 21

Среднее время ожидания в пробке = 12 сек

Среднее время ожидания на светофоре = 3 сек

2-е направление

Количество машин, проехавших через перекрёсток = 89

по 1-ой полосе : 89

Среднее время ожидания в пробке = 3 мин 2 сек

Среднее время ожидания на светофоре = 2 сек

3-е направление

Количество машин, проехавших через перекрёсток = 35

по 1-ой полосе : 13

по 2-ой полосе : 9

по 3-ой полосе : 7

по 4-ой полосе : 4

по 5-ой полосе : 2

Среднее время ожидания в пробке = 0 сек

Среднее время ожидания на светофоре = 4 сек

4-е направление

Количество машин, проехавших через перекрёсток = 23

по 1-ой полосе : 13

по 2-ой полосе : 10

Среднее время ожидания в пробке = 1 сек

Среднее время ожидания на светофоре = 3 сек

Вывод: в некоторых случаях суммарное количество машин, проехавших по каждой полосе, не равно общему количеству машин, проехавших по данному направлению. Это можно объяснить тем, что программа считает усреднённые значения по всем итерациям. А при подсчёте среднего значения происходит утечка дробных значений, которая и приводит к погрешности.

Заключение

При выполнении курсовой работы были использованы такие приёмы ООП как композиция, наследование, использование статических данных-элементов при наследовании. В программе реализованы все требования, перечисленные в разделе «Постановка задачи».

Пожелания по дальнейшему развитию проекта:

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

-Предоставить пользователю возможность сымитировать препятствие на какой-либо полосе движения путём увеличения времени задержки машины на этой полосе. Например, это может быть яма или неровность, на преодоление которой требуется некоторое количество времени, которое и предлагается задать пользователю.

-Добавить в программу имитацию пешеходов, которые появляются в случайный момент времени и нажимают на кнопку, которая меняет знак разрешающего сигнала светофора на запрещающий (для автомобилей). Пользователю предлагается ввести интервал времени между появлением пешеходов и время, в течение которого для машин будет гореть запрещающий сигнал светофора в случае нажатия пешеходом кнопки.

Список использованной литературы

Шахмаметов Р.Г. «Программирование на языках высокого уровня. Методические указания» – Новосибирск: кафедра АСУ НГТУ, 2006
Подбельский В.В. «Язык С++» ― Москва: Финансы и статистика, 2004
Б.Страуструп. «Язык программирования С++. Специальное издание» ― Москва: издательство Бином, 2004

Листинг

#include "random.h"

#include <iostream>

#include <fstream>

#include <stdlib.h>

#include <stdio.h>

#include <string>

#include "Form1.h"

using namespace std;

class Simulation{

public:

Simulation();

Simulation(int, int*, int*, int*, int*, int*, int, int, int);//конструктор

void RunSimulation();

//статические переменные используются для того, чтобы из значения, заданные в начале,

//были доступны элементам класса Mashina (когда создаётся элемент класса Mashina,

//то эти переменные не инициализируются, а используются значения, инициализированные

//при создании объекта класса Simulation в функции main)

int N; //количество итераций программы

static int **Pol; //номер полосы

static int *kolPol; //количество полос для движения

static int **countE; // [N][4] - хранит кличество машин, проехавших через перекрёсток, для каждой итерации

static int **srTimeOjOch; // [N][4] среднее время ожидания в пробке по каждому из 4-х направлений по каждой из N-ти итераций

static int **srTimeOjSv;

protected:

RandomNumber rnd;

static int TGlobal;

static int time; // длина моделируемого периода работы

static int *arrivalLow; //диапазон времени между приходами машин

static int *arrivalHigh;

static int *delayLow; //диапазон времени задержки машин на перекрёстке

static int *delayHigh;

static int TimeGreen; //время горения разрешающего сигнала светофора (в секундах)

static int TimeRed; //время горения запрещающего сигнала светофора (в секундах)

//данные-элементы для хранения результатов по всем 4-м направлениям

static int *countElem;

static int **ojOch; //время ожидания в очереди (т.е. в случае, когда при прибытии машины на перекрёсток, предыдущая машина ещё не покинула перекрёсток)

static int **ojSv; //время ожидания при запрещающем сигнале светофора

private:

int SrTimeOjOch(int h); //возвращает среднее время ожидания в пробке.

//В качестве аргумента функции передаётся номер направления

int SrTimeOjSv(int h); //возвращает среднее время ожидания на светофоре.

};

class Mashina : public Simulation{

public:

Mashina();

Mashina *pHead; // указатель на первый элемент списка

Mashina *pPrev; // указатель на последний элемент списка

Mashina *next; // указатели на следующий

Mashina *pred; //и на предыдущий элементы списка

void addToList(int tprib, int nPol, int napr, int iter); //функция добавки элемента в список

//tprib - время прибытия, nPol - номер полосы, napr - номер направления, iter - номер итерации

int KolOstMash(int); //в качестве параметра функции передаётся время пибытия очередной машины.

//Функция возвращает количество машин, время отбытия которых (Totb) больше, чем время прибытия очередной машины (tprib)

//(т.е. количество машин, ещё не уехавших с перекрёстка в момент прибытия очередной машины)

private:

int Tprib; //время прибытия

int TojPer; //время ожидания на перекрёстке

int TojOch; //время ожидания в очереди (т.е. в случае, когда при прибытии машины на перекрёсток, предыдущая машина ещё не покинула перекрёсток)

int TojSv; //время ожидания при запрещающем сигнале светофора

int Totb; //время отбытия с перекрёстка

};

//===================================================

//=====реализация класса Simulation==================

//===================================================

int Simulation::TGlobal = 0;

int Simulation::time = 0;

int *Simulation::kolPol = new int[4];

int *Simulation::countElem = new int[4];

int *Simulation::arrivalLow = new int[4];

int *Simulation::arrivalHigh = new int[4];

int *Simulation::delayLow = new int[4];

int *Simulation::delayHigh = new int[4];

int Simulation::TimeGreen = 0;

int Simulation::TimeRed = 0;

int **Simulation::Pol = new int* [4];

int **Simulation::ojOch = new int* [4];

int **Simulation::ojSv = new int* [4];

int **Simulation::srTimeOjOch = new int*() ;

int **Simulation::srTimeOjSv = new int*() ;

int **Simulation::countE = new int*() ;

//-----------------------------------------------------------------------------------

Simulation::Simulation()

{

}

Simulation::Simulation(int t, int *k, int *al, int *ah, int *dl, int *dh, int tg, int tr, int n)

{

int i,j, ii, jj;

N = n;

time = t;

TimeGreen = tg;

TimeRed = tr;

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

{

kolPol[i] = k[i];

arrivalLow[i] = al[i];

arrivalHigh[i] = ah[i];

delayLow[i] = dl[i];

delayHigh[i] = dh[i];

}

for (int i = 0; i < 4; i++)

{

Pol[i] = new int [1000];

ojOch[i] = new int [1000];

ojSv[i] = new int [1000];

}

srTimeOjOch = new int* [N] ;

srTimeOjSv = new int* [N] ;

countE = new int* [N] ;

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

{

srTimeOjOch[i] = new int [4];

srTimeOjSv[i] = new int [4];

countE[i] = new int [4];

}

//-----------------------------------------------------------------------

void Simulation::RunSimulation(){

Mashina *M;

for (int iter=0; iter<N; iter++) // N итераций. Затем по каждому параметру считается усреднённое значение.

for (int j=0; j<4; j++) // моделирование по j-му направлению

{

M = new Mashina[kolPol[j]];

TGlobal = 0;

countElem[j]=0;

int tprib = rnd.Random(arrivalHigh[j] - arrivalLow[j] + 1) + arrivalLow[j] ;

while (tprib <= time*60)

{

//поиск списка с минимальным количеством не уехавших машин в очереди

int min = M->KolOstMash(tprib);

int min_i = 0;

for (int i = 0; i < kolPol[j]; i++)

if ((M+i)->KolOstMash(tprib) < min)

{

min = (M+i)->KolOstMash(tprib);

min_i = i;

}

(M + min_i)->addToList(tprib, min_i+1, j, iter);

tprib = TGlobal + rnd.Random(arrivalHigh[j] - arrivalLow[j] + 1) + arrivalLow[j] ;

}

countE[iter][j] = countElem[j]; //сбор статистики по каждой из итераций

srTimeOjOch[iter][j] = SrTimeOjOch(j);

srTimeOjSv[iter][j] = SrTimeOjSv(j);

}

return;

}

//среднее время ожидания в очереди по h-му направлению

int Simulation::SrTimeOjOch(int h)

{

int sum = 0, i;

int sr;

for (i = 0 ; i < countElem[h] ; i++)

sum = sum + ojOch[h][i];

sr = sum/countElem[h];

return sr;

}

int Simulation::SrTimeOjSv(int h)

{

int sum = 0, sr, i;

for (i = 0 ; i < countElem[h] ; i++)

sum = sum + ojSv[h][i];

sr = sum/countElem[h];

return sr;

}

//=============================================================================

//--------------------реализация класса Mashina--------------------------------

//=============================================================================

Mashina::Mashina(){

pHead = NULL;

pPrev = NULL;

}

//реализация функции добавления

void Mashina::addToList(int tprib, int nPol, int napr, int iter)

{

int i, j;

Mashina *temp = new Mashina; //создается временный элемент

if(pHead == NULL) //если это первый элемент, то

{

temp->pred = NULL; //обнуляем указатель на предшествующий элемент т.к. его нет

temp->next = NULL; //то же самое с последующим элементом

pHead = temp; //"голова" указывает на созданный элемент

temp->Tprib = tprib;

temp->TojPer = rnd.Random(delayHigh[napr] - delayLow[napr] + 1) + delayLow[napr];

temp->TojOch = 0; //Время ожидания в очереди равно 0, т.к. это первая машина

//расчёт времени ожидания на запрещающем сигнале светофора

int PeriodSv = temp->Tprib / (TimeGreen + TimeRed); //количество периодов смены сигнала светофора, произошедших к моменту прибытия машины

// Green,Red, Green,Red, Green,Red, ...

int Tpr = temp->Tprib - (TimeGreen + TimeRed)*PeriodSv; // время прибытия относительно последнего завершившегося полного периода смены сигнала светофора

if ((napr == 0) || (napr == 1))

{

if (Tpr <= TimeGreen) //если во время прибытия машины горел разрешающий сигнал светофора

temp->TojSv = 0;

else{ //иначе, если во время прибытия машины горел запрещающий сигнал светофора

int Tkr = Tpr - TimeGreen; // время, сколько уже горел запрещающий сигнал светофора к моменту прибытия машины

temp->TojSv = TimeRed - Tkr;

}

else

{

if (Tpr <= TimeGreen)

temp->TojSv = TimeGreen - Tpr;

else temp->TojSv = 0;

}

//конец рассчёта

temp->Totb = temp->Tprib + temp->TojPer + temp->TojSv;

}

else //если не первый, то

{

pPrev->next = temp; //предыдущий указывает на него

temp->Tprib = tprib;

temp->TojPer = rnd.Random(delayHigh[napr] - delayLow[napr] + 1) + delayLow[napr]; //время ожидания на перекрёстке

//рассчёт времени ожидания в очереди

if (pPrev->Totb > temp->Tprib ){ // если время отбытия предыдущей машины больше времени прибытия данной машины

//т.е. данная машина прибыла, а предыдущая ещё не отбыла, то

temp->TojOch = pPrev->Totb - temp->Tprib; //время ожидания в очереди

}

else

{

temp->TojOch = 0;

}

//расчёт времени ожидания на запрещающем сигнале светофора

int PeriodSv = (temp->Tprib + temp->TojOch) / (TimeGreen + TimeRed); //количество периодов смены сигнала светофора, произошедших к моменту прибытия машины

// Green,Red, Green,Red, Green,Red, ...

int Tpr = (temp->Tprib + temp->TojOch) - (TimeGreen + TimeRed)*PeriodSv; // время прибытия относительно последнего завершившегося полного периода смены сигнала светофора

if ((napr == 0) || (napr == 1))

{

if (Tpr <= TimeGreen) //если во время прибытия машины горел разрешающий сигнал светофора

temp->TojSv = 0;

else{ //иначе, если во время прибытия машины горел запрещающий сигнал светофора

int Tkr = Tpr - TimeGreen; // время, сколько уже горел запрещающий сигнал светофора к моменту прибытия машины

temp->TojSv = TimeRed - Tkr;

}

else

{

if (Tpr <= TimeGreen)

temp->TojSv = TimeGreen - Tpr;

else temp->TojSv = 0;

}

//конец рассчёта

temp->Totb = temp->Tprib + temp->TojPer + temp->TojOch + temp->TojSv; //время отбытия с перекрёстка

}

TGlobal = temp->Tprib;

Pol[napr][countElem[napr]] = nPol;

ojOch[napr][countElem[napr]] = temp->TojOch;

ojSv[napr][countElem[napr]] = temp->TojSv;

temp->next = NULL; //последующего элемента нет (добавляем же в конец)

temp->pred = pPrev; //указываем на предыдущий элемент, на который «нацелен» pPrev

pPrev = temp; //а теперь хвостовой элемент указывает на последний (добавленный)

countElem[napr]++; //увеличиваем счетчик элементов в списке

return;

}

int Mashina::KolOstMash(int tprib){

int k = 0;

Mashina *pTemp = pHead; //создается временный элемент

if (pHead) //если список не пуст, то

while(pTemp != NULL) //пока врем. элем. не будет указывать на хвост

{

if (pTemp->Totb > tprib) k++;

pTemp = pTemp->next; //и переходим на следующий за ним элем.

}

return k;

}

//Спецификация класса RandomNumber

//Класс RandomNumber – класс датчиков случайных чисел

# include <time.h>

// эти числа используются для создания случайного числа

// из текущего seed-значения

const unsigned long maxshort = 65536L ;

const unsigned long multiplier = 1194211693L ;

const unsigned long adder = 12345L ;

class RandomNumber

{

private:

unsigned long randSeed; // текущее seed-значение

public:

RandomNumber () ; // конструктор

// функция, которая возвращает целое случайное число,

// равномерно распределенное в диапазоне [ 0, n -1 ]

unsigned short Random ( unsigned long n ) ;

} ;

RandomNumber :: RandomNumber ()

{

randSeed = time ( 0 ) ; // seed-значение, заданное

// посредством функции time ( )

}

unsigned short RandomNumber :: Random ( unsigned long n )

{

randSeed = multiplier * randSeed + adder ; // новое seed-значение

// возврат целого случайного числа в диапазоне [ 0, n -1 ]

return (unsigned short) ( (randSeed >> 16 ) % n ) ;

}

//Спецификация класса Form1

#pragma endregion

//запустить моделирование

private: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) {

int t, tg, tr, n;

int *k = new int[4];

int *al = new int[4];

int *ah = new int[4];

int *dl= new int[4];

int *dh = new int[4];

n = System::Convert::ToInt32(textBox9->Text);

t = System::Convert::ToInt32(textBox1->Text);

tg = System::Convert::ToInt32(textBox7->Text);

tr = System::Convert::ToInt32(textBox8->Text);

k[0] = System::Convert::ToInt32(textBox2->Text);

al[0] = System::Convert::ToInt32(textBox3->Text);

ah[0] = System::Convert::ToInt32(textBox4->Text);

dl[0] = System::Convert::ToInt32(textBox5->Text);

dh[0] = System::Convert::ToInt32(textBox6->Text);

k[1] = System::Convert::ToInt32(textBox14->Text);

al[1] = System::Convert::ToInt32(textBox13->Text);

ah[1] = System::Convert::ToInt32(textBox12->Text);

dl[1] = System::Convert::ToInt32(textBox11->Text);

dh[1] = System::Convert::ToInt32(textBox10->Text);

k[2] = System::Convert::ToInt32(textBox19->Text);

al[2] = System::Convert::ToInt32(textBox18->Text);

ah[2] = System::Convert::ToInt32(textBox17->Text);

dl[2] = System::Convert::ToInt32(textBox16->Text);

dh[2] = System::Convert::ToInt32(textBox15->Text);

k[3] = System::Convert::ToInt32(textBox24->Text);

al[3] = System::Convert::ToInt32(textBox23->Text);

ah[3] = System::Convert::ToInt32(textBox22->Text);

dl[3] = System::Convert::ToInt32(textBox21->Text);

dh[3] = System::Convert::ToInt32(textBox20->Text);

ofstream data("data.txt");

data<<n<<endl;

data<<t<<endl;

data<<tg<<endl;

data<<tr<<endl;

for (int i =0; i<4; i++)

{

data<<k[i]<<endl;

data<<al[i]<<endl;

data<<ah[i]<<endl;

data<<dl[i]<<endl;

data<<dh[i]<<endl;

}

data.close();

Simulation S(t, k, al, ah, dl, dh, tg, tr, n);

S.RunSimulation();

label10->Visible = true;

for (int h=0; h<4; h++)

{

int i, j, sr=0, srsv=0, sum=0;

//рассчёт среднего количества машин, проехавших через переурёсток (за N итераций)

int kolmash[4];

for (i=0; i<S.N; i++)

sum += S.countE[i][h];

kolmash[h] = sum/S.N;

//расчёт среднего количества машин, проехавших по каждой полосе, максимум - 10 полос

int **kolMash = new int*[S.N]; //

for ( i = 0 ; i < S.N ; i++)

kolMash[i] = new int[10];

for ( i = 0 ; i < S.N ; i++)

for ( j = 1 ; j <= S.kolPol[h] ; j++)

kolMash[i][j] = 0;

for (int it=0; it<S.N; it++)

for (i = 0 ; i < S.countE[it][h] ; i++)

for (j = 1 ; j <= S.kolPol[h] ; j++)

if (S.Pol[h][i] == j) kolMash[it][j]++;

int summa[10];

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

summa[i]=0;

for (j = 1 ; j <= S.kolPol[h] ; j++)

for (int it=0; it<S.N; it++)

summa[j] = summa[j] + kolMash[it][j];

int kol[10];

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

kol[i]=0;

for (j = 1 ; j <= S.kolPol[h] ; j++)

kol[j] = summa[j]/S.N;

//рассчёт среднего времени ожидания в пробке (и на светофоре) за 10 итераций моделирования.

for (i=0; i<S.N; i++)

{

sr = sr + S.srTimeOjOch[i][h];

srsv = srsv + S.srTimeOjSv[i][h];

}

sr = sr/S.N;

srsv = srsv/S.N;

switch (h)

{

case 0: richTextBox1->Text =richTextBox1->Text+"Количество машин, проехавших через перекрёсток = " + kolmash[0] + "\r\n";break;

case 1: richTextBox2->Text =richTextBox2->Text+"Количество машин, проехавших через перекрёсток = " + kolmash[1] + "\r\n";break;

case 2: richTextBox3->Text =richTextBox3->Text+"Количество машин, проехавших через перекрёсток = " + kolmash[2] + "\r\n";break;

case 3: richTextBox4->Text =richTextBox4->Text+"Количество машин, проехавших через перекрёсток = " + kolmash[3] + "\r\n";break;

}

for ( i = 1 ; i <= S.kolPol[h] ; i++)

switch (h)

{

case 0: richTextBox1->Text = richTextBox1->Text + "по " + i + "-ой полосе : " + kol[i] + "\r\n";break;

case 1: richTextBox2->Text = richTextBox2->Text + "по " + i + "-ой полосе : " + kol[i] + "\r\n";break;

case 2: richTextBox3->Text = richTextBox3->Text + "по " + i + "-ой полосе : " + kol[i] + "\r\n";break;

case 3: richTextBox4->Text = richTextBox4->Text + "по " + i + "-ой полосе : " + kol[i] + "\r\n";break;

}

switch (h)

{

case 0: richTextBox1->Text=richTextBox1->Text+"\r\n";break;

case 1: richTextBox2->Text=richTextBox2->Text+"\r\n";break;

case 2: richTextBox3->Text=richTextBox3->Text+"\r\n";break;

case 3: richTextBox4->Text=richTextBox4->Text+"\r\n";break;

}

if (sr < 60)

switch (h)

{

case 0: richTextBox1->Text= richTextBox1->Text+"Среднее время ожидания в пробке = " + sr +" сек\r\n";break;

Не Пропустите: