Список литературы

1. Советов Б. Я., Яковлев С. А. Моделирование систем: Учеб. Для вузов 3-е издание, перераб. И доп. – М: Высш. Школа, 2001 – 343 с.

2. Советов Б. Я., Яковлев С. А. Моделирование систем: Курсовое проектирование: Учеб. Пособие по специальности АСУ. – М: Высш. Школа, 1988 м – 135 с.

Приложение А (обязательное) Псевдокод моделирующего алгоритма

структура Request

начало

скаляр State - целое;

скаляр MakeTime- целое;

скаляр ProcessingTime- целое;

конец;

структура Executor

начало

скаляр IsFree- целое;

скаляр EndTime- целое;

Request *ProcessingRequest - указатель;

алгоритм Load(*req, current_t)

начало

EndTime = ExecTime+current_t+random(2*MistakeTime+1)-MistakeTime;

ProcessingRequest = req;

ProcessingRequest->ProcessingTime = ProcessingRequest->ProcessingTime+ EndTime-current_t;

IsFree = 0;

ProcessingRequest->State++;

конец

Request *Extract()

начало IsFree=1;

возврат ProcessingRequest;

конец

скаляр ExecTime - целое;

скаляр MistakeTime- целое;

конец;

структура Storage

начало

Request **m_storage - указатель;

public:

скаляр MaxVolume - целое;

скаляр Volume- целое;

скаляр IsFull- целое;

алгоритм Add(Request *req) - целое

начало

если Volume)

начало

m_storage[MaxVolume-Volume]=req;

Volume--;

если Volume==0) IsFull = 1;

иначе IsFull =0;

возврат 1;

конец

возврат 0;

конец

Request *Extract()

начало

если Volume!=MaxVolume)

начало

Volume++;

Request *tmp;

tmp = m_storage[MaxVolume-Volume];

m_storage[MaxVolume-Volume] = NULL;

если Volume==0) IsFull = 1;

иначе IsFull =0;

возврат tmp;

конец

если Volume==0) IsFull = 1;

иначе IsFull =0;

возврат NULL;

конец

конец;

структура Generator

начало

Request *CurrentRequest;

Generator(скаляр Time, скаляр Mistake)

начало

GenTime = Time;

MistakeTime = Mistake;

NextTime=1;

конец

алгоритм Generate(скаляр t)

начало

если t==NextTime)

начало

CurrentRequest = new Request(t);

скаляр RndMstk = random(2*MistakeTime+1)-MistakeTime;

NextTime = NextTime+GenTime+RndMstk;

возврат 1;

конец

иначе

начало

возврат 0;

конец

конец

private:

скаляр NextTime;

скаляр GenTime;

скаляр MistakeTime;

конец;

алгоритм ГлавнаяПрорамма

начало

скаляр RequestTime = StrToInt(edtRequestTime->Text);

скаляр RequestMistake = StrToInt(edtRequestMistake->Text);

скаляр CementationTime = StrToInt(edtCementationTime->Text);

скаляр CementationMistake = StrToInt(edtCementationMistake->Text);

скаляр TemperingTime = StrToInt(edtTemperingTime->Text);

скаляр TemperingMistake = StrToInt(edtTemperingMistake->Text);

скаляр RequestQuantity = StrToInt(edtRequestQuantity->Text);

скаляр StorageVolume = StrToInt(edtStorageVolume->Text);

скаляр Denied =0;

скаляр FstSort =0;

скаляр SecSort =0;

скаляр MaxTime =2*(CementationTime + CementationMistake+

TemperingTime + TemperingMistake+1);

Generator *G; G = new Generator(RequestTime,RequestMistake);

Storage *S1; S1 = new Storage(StorageVolume);

Storage *S2; S2 = new Storage(StorageVolume);

Executor *E1; E1 = new Executor(CementationTime,CementationMistake);

Executor *E2; E2 = new Executor(TemperingTime,TemperingMistake);

скаляр t=1;

int *data; data = new int[MaxTime+1];

для ( i=0;i<MaxTime;i++) data[i]=0;

Series1->Clear();

randomize();

while (Denied+FstSort+SecSort<RequestQuantity)начало

если (E2->EndTime==t)&&(E2->ProcessingRequest!=NULL))

начало

Request *tmp = E2->ProcessingRequest;

если (tmp->ProcessingTime>=25)&&(tmp->State==2))

начало

FstSort++;

data[tmp->ProcessingTime]++;

E2->Extract();

конец

если (tmp->State>2)&&(tmp->ProcessingTime<20))

начало

SecSort++;

data[tmp->ProcessingTime]++;

E2->Extract();

конец

если (tmp->State>2)&&(tmp->ProcessingTime>=20))

начало

FstSort++;

data[tmp->ProcessingTime]++;

E2->Extract();

конец

если (tmp->ProcessingTime<20)&&(tmp->State==2))

начало

если !S1->IsFull)

S1->Add(E2->Extract());

конец

если (tmp->ProcessingTime <25)&&

(tmp->ProcessingTime>=20)&&

(tmp->State==2))

начало

если !S2->IsFull) S2->Add(E2->Extract());

конец

конец

если (E2->IsFree)&&(S2->Volume!=S2->MaxVolume)) E2->Load(S2->Extract(),t);

если (E1->EndTime==t)&&(E1->ProcessingRequest!=NULL)) если !S2->IsFull) S2->Add(E1->Extract());

если (E1->IsFree)&&((S1->Volume)!=(S1->MaxVolume))) E1->Load(S1->Extract(),t);

если G->Generate(t))начало

если !S1->IsFull) S1->Add(G->CurrentRequest);

иначе

начало

Denied++;

data[0]++;

data[1]=1;

конец

конец

t++;

конец

для ( i =0;i<MaxTime;i++)

Series1->AddXY(i,data[i],"",clBlue);

double tmp = FstSort;

tmp = tmp/RequestQuantity;

edtFstSortPossibility->Text = FloatToStr((double)FstSort/(double)RequestQuantity);

edtSecSortPossibility->Text = FloatToStr((double)SecSort/(double)RequestQuantity);

edtDeniedPossibility->Text = FloatToStr((double)Denied/(double)RequestQuantity);

edtSecSort->Text = IntToStr(SecSort);

edtFstSort->Text = IntToStr(FstSort);

edtDenied ->Text = IntToStr(Denied);

delete G;

delete E1;

delete E2;

delete S1;

delete S2;

конец

Приложение Б (обязательное) Листинг программы

Main.h

#ifndef MainH

#define MainH

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include <Chart.hpp>

#include <ExtCtrls.hpp>

#include <Series.hpp>

#include <TeEngine.hpp>

#include <TeeProcs.hpp>

#include <jpeg.hpp>

#include <Buttons.hpp>

#include <Graphics.hpp>

class TfrmMain : public TForm

{

__published: // IDE-managed Components

TButton *btnStart;

TButton *btnClose;

TMemo *mmTask;

TGroupBox *gbInputParameters;

TLabel *Label1;

TLabel *Label2;

TLabel *Label4;

TLabel *Label5;

TLabel *Label6;

TLabel *Label3;

TEdit *edtRequestTime;

TEdit *edtRequestMistake;

TEdit *edtCementationTime;

TEdit *edtCementationMistake;

TEdit *edtTemperingTime;

TEdit *edtTemperingMistake;

TEdit *edtRequestQuantity;

TEdit *edtStorageVolume;

TGroupBox *gbResults;

TEdit *edtSecSort;

TEdit *edtDenied;

TEdit *edtFstSort;

TChart *Chart1;

TLineSeries *Series1;

TEdit *edtFstSortPossibility;

TEdit *edtSecSortPossibility;

TEdit *edtDeniedPossibility;

TButton *btnQSheme;

TImage *imgPicture;

TStaticText *StaticText1;

void __fastcall btnStartClick(TObject *Sender);

void __fastcall btnCloseClick(TObject *Sender);

void __fastcall btnQShemeClick(TObject *Sender);

void __fastcall edtRequestMistakeChange(TObject *Sender);

void __fastcall edtTemperingMistakeChange(TObject *Sender);

void __fastcall edtCementationMistakeChange(TObject *Sender);

private: // User declarations

public: // User declarations

__fastcall TfrmMain(TComponent* Owner);

};

extern PACKAGE TfrmMain *frmMain;

#endif

Main.cpp

#include <vcl.h>

#pragma hdrstop

#include "Main.h"

#include "QSheme.cpp"

#include <stdlib.h>

#include <time.h>

#pragma package(smart_init)

#pragma resource "*.dfm"

class Request

{

public:

unsigned long int State;

unsigned long int MakeTime;

unsigned long int ProcessingTime;

Request(unsigned long int Time)

{

State = 0;

ProcessingTime = 0;

MakeTime = Time;

}

};

class Executor

{

public:

unsigned long int IsFree;

unsigned long int EndTime;

Request *ProcessingRequest;

Executor(unsigned long int Time, int Mistake)

{

ExecTime = Time;

MistakeTime = Mistake;

IsFree = 1;

ProcessingRequest = NULL;

EndTime = 0;

}

void Load(Request *req, unsigned long int current_t)

{

EndTime = ExecTime+current_t+random(2*MistakeTime+1)-MistakeTime;

ProcessingRequest = req;

ProcessingRequest->ProcessingTime = ProcessingRequest->ProcessingTime+ EndTime-current_t;

IsFree = 0;

ProcessingRequest->State++;

}

Request *Extract()

{ IsFree=1;

return ProcessingRequest;

}

private:

unsigned long int ExecTime;

unsigned long int MistakeTime;

};

class Storage{

private:

Request **m_storage;

public:

unsigned long int MaxVolume;

unsigned long int Volume;

unsigned long int IsFull;

Storage(unsigned long int maximum_volume)

{

Volume = maximum_volume;

MaxVolume = maximum_volume;

IsFull = 0;

m_storage = new Request *[maximum_volume];

for (int i=0;i<maximum_volume;i++) m_storage[i]=NULL;

}

int Add(Request *req)

{

if(Volume){

m_storage[MaxVolume-Volume]=req;

Volume--;

if (Volume==0) IsFull = 1;

else IsFull =0;

return 1;

}

return 0;

}

Request *Extract()

{

if(Volume!=MaxVolume)

{

Volume++;

Request *tmp;

tmp = m_storage[MaxVolume-Volume];

m_storage[MaxVolume-Volume] = NULL;

if (Volume==0) IsFull = 1;

else IsFull =0;

return tmp;

}

if (Volume==0) IsFull = 1;

else IsFull =0;

return NULL;

}

};

class Generator

{

public:

Request *CurrentRequest;

Generator(unsigned long int Time, unsigned long int Mistake)

{

GenTime = Time;

MistakeTime = Mistake;

NextTime=1;

}

unsigned long int Generate(unsigned long int t)

{

if (t==NextTime)

{

CurrentRequest = new Request(t);

unsigned long int RndMstk = random(2*MistakeTime+1)-MistakeTime;

NextTime = NextTime+GenTime+RndMstk;

return 1;

}

else

{

return 0;

}

}

private:

unsigned long int NextTime;

unsigned long int GenTime;

unsigned long int MistakeTime;

};

TfrmMain *frmMain;

__fastcall TfrmMain::TfrmMain(TComponent* Owner): TForm(Owner)

{

}

void __fastcall TfrmMain::btnStartClick(TObject *Sender)

{

unsigned long int RequestTime = StrToInt(edtRequestTime->Text);

unsigned long int RequestMistake = StrToInt(edtRequestMistake->Text);

unsigned long int CementationTime = StrToInt(edtCementationTime->Text);

unsigned long int CementationMistake = StrToInt(edtCementationMistake->Text);

unsigned long int TemperingTime = StrToInt(edtTemperingTime->Text);

unsigned long int TemperingMistake = StrToInt(edtTemperingMistake->Text);

unsigned long int RequestQuantity = StrToInt(edtRequestQuantity->Text);

unsigned long int StorageVolume = StrToInt(edtStorageVolume->Text);

unsigned long int Denied =0;

unsigned long int FstSort =0;

unsigned long int SecSort =0;

unsigned long int MaxTime =2*(CementationTime + CementationMistake+

TemperingTime + TemperingMistake+1);

Generator *G; G = new Generator(RequestTime,RequestMistake);

Storage *S1; S1 = new Storage(StorageVolume);

Storage *S2; S2 = new Storage(StorageVolume);

Executor *E1; E1 = new Executor(CementationTime,CementationMistake);

Executor *E2; E2 = new Executor(TemperingTime,TemperingMistake);

unsigned long int t=1;

int *data; data = new int[MaxTime+1];

for (int i=0;i<MaxTime;i++) data[i]=0;

Series1->Clear();

randomize();

while (Denied+FstSort+SecSort<RequestQuantity){

if ((E2->EndTime==t)&&(E2->ProcessingRequest!=NULL))

{

Request *tmp = E2->ProcessingRequest;

if ((tmp->ProcessingTime>=25)&&(tmp->State==2)){

FstSort++;

data[tmp->ProcessingTime]++;

E2->Extract();

}

if ((tmp->State>2)&&(tmp->ProcessingTime<20)){

SecSort++;

data[tmp->ProcessingTime]++;

E2->Extract();

}

if ((tmp->State>2)&&(tmp->ProcessingTime>=20)){

FstSort++;

data[tmp->ProcessingTime]++;

E2->Extract();

}

if ((tmp->ProcessingTime<20)&&(tmp->State==2)){

if (!S1->IsFull)

S1->Add(E2->Extract());

}

if ((tmp->ProcessingTime <25)&&

(tmp->ProcessingTime>=20)&&

(tmp->State==2))

{

//Заявка 20<=t<25 второго класса. Отправить на S2

if (!S2->IsFull) S2->Add(E2->Extract());

}

}

if ((E2->IsFree)&&(S2->Volume!=S2->MaxVolume)) E2->Load(S2->Extract(),t);

if ((E1->EndTime==t)&&(E1->ProcessingRequest!=NULL)) if (!S2->IsFull) S2->Add(E1->Extract());

if ((E1->IsFree)&&((S1->Volume)!=(S1->MaxVolume))) E1->Load(S1->Extract(),t);

if (G->Generate(t)){

if (!S1->IsFull) S1->Add(G->CurrentRequest);

else

{

Denied++;

data[0]++;

data[1]=1;

}

}

t++;

}

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

Series1->AddXY(i,data[i],"",clBlue);

double tmp = FstSort;

tmp = tmp/RequestQuantity;

edtFstSortPossibility->Text = FloatToStr((double)FstSort/(double)RequestQuantity);

edtSecSortPossibility->Text = FloatToStr((double)SecSort/(double)RequestQuantity);

edtDeniedPossibility->Text = FloatToStr((double)Denied/(double)RequestQuantity);

edtSecSort->Text = IntToStr(SecSort);

edtFstSort->Text = IntToStr(FstSort);

edtDenied ->Text = IntToStr(Denied);

delete G;

delete E1;

delete E2;

delete S1;

delete S2;

}

void __fastcall TfrmMain::btnCloseClick(TObject *Sender){

Close();

}

void __fastcall TfrmMain::btnQShemeClick(TObject *Sender){

frmQSheme->Show();

}

void __fastcall TfrmMain::edtRequestMistakeChange(TObject *Sender)

{

if (StrToInt(edtRequestMistake->Text)>=StrToInt(edtRequestTime->Text)){

edtRequestMistake->Text = "0";

}

}

void __fastcall TfrmMain::edtTemperingMistakeChange(TObject *Sender)

{

if (StrToInt(edtTemperingMistake->Text)>=StrToInt(edtTemperingTime->Text)){

edtTemperingMistake->Text = "0";

}

}

void __fastcall TfrmMain::edtCementationMistakeChange(TObject *Sender){

if (StrToInt(edtCementationMistake->Text)>=StrToInt(edtCementationTime->Text)){

edtCementationMistake->Text = "0";

}

}