Geum.ru

Методические указания и примеры выполнения задания №6 " Моделирование процессов принятия решений"

Вид материалаМетодические указания

Содержание


Цель: ограничения
Подобный материал:
1   2   3   4   5   6   7   8   9   10

ЦЕЛЬ:

ОГРАНИЧЕНИЯ:

АЛЬТЕРНАТИВЫ:

ТИП:


Исходный текст программы ( Реализовано на С++ ):


#include

#include

#include

#include

#include

#include


struct way{

int from; //(участок пути)

int to;

};

struct item // элемент списка

{ way del; // удаляемый путь

int value; // оценка стоимости

item * next; // указатель на след. элемент

item * negnext; // указатель на след. элемент (времено отбрасываемый)

item * prev; // указатель на пред. элемент

};


struct List{ // Элемент списка (хранит путь)

way road;

List *next;

};


// определение класса для работы с деревом поиска

class Graph {

List * First; // начало списка пути

item *Root; // корень дерева поиска

int nmap; // размер исходной матрицы

int nduble; // размер изменяемой матрицы

unsigned Prise[8][8]; // матрица стоимостей проезда

unsigned Time[8][8]; // маирица затрат времени

unsigned map[8][8]; // исходная матрица

unsigned duble[8][8]; // изменяемая маирица (по ней находится путь)

public:

Graph();

int prived (int); // приведение матрицы

int zeros (int ,int&, int &); // "оценка нулей"

int del (int, int, int); // удаление строки и тсолбца

void find (); // нахождение пути

void print(); // вывод матрицы и найденного пути

void sortlist(); // сортировка пути

item* lasttwo(item *); // обработка матрицы 2х2

List* Clear(List*); // очистка списка пути

void sum(); // получение матрицы переходов после сложения

};


// определение функций-членов класса

Graph::Graph()

{ cout<<"Введите количество городов (4..7)"<
do

nmap=getche()-48;

while ((nmap>7)||(nmap<4));

nduble=nmap;

randomize();

//Стоимость пути

for (int i=1; i<=nmap; i++)

for (int j=1; j<=nmap; j++)

{ if (i!=j)

Prise[i][j]=random(100);

else

Prise[i][j]=32000;

}

//Затраты времени

for (i=1; i<=nmap; i++)

for (int j=1; j<=nmap; j++)

{ if (i!=j)

Time[i][j]=random(100);

else

Time[i][j]=32000;

}

}

void Graph::sum()

{ float k1,k2;

k1=k2=1;

cout<
cin>>k1;

cout<
cin>>k2;

//нормализация

if (k1>k2)

{k2=k2/k1;

k1=1;

}

else

{k1=k1/k2;

k2=1;

}

for (int i=1; i<=nmap; i++) //сложение матриц

for (int j=1; j<=nmap; j++)

{if (i!=j)

map[i][j]=duble[i][j]=(int)(Prise[i][j]*k1)+(int)(Time[i][j]*k2);

else map[i][j]=duble[i][j]=32000;

}

for (i=0; i<=nmap; i++) //№ городов

{map[0][i]=map[i][0]=duble[0][i]=duble[i][0]=i;

Prise[0][i]=Prise[i][0]=Time[0][i]=Time[i][0]=i;

}

Root=new item; //начальная инициализация дерева поиска

Root->del.from=Root->del.to=32000;

Root->next=Root->negnext=Root->prev=NULL;


}


int Graph::prived(int razm) // после работы функции в каждом

{ int i, j, delta=0, find=0; // сстолбце и строке матрицы есть

for (i=1; i<=razm; i++) // хотябы 1 нуль

{ for (j=1; j<=razm; j++) // функция возвращает стоимоссть данного

if (duble[i][j]==0) // преобразования (сумма всех

{ find=1; // уменьшаемых

break;

}

if (!find)

{ int min;

min=duble[i][1];

for (j=1; j<=razm; j++)

if (duble[i][j]
delta=delta+min;

for (j=1; j<=razm; j++)

duble[i][j]=duble[i][j]-min;

}

find=0;

}

for (j=1;j<=razm; j++)

{ for (i=1; i<=razm; i++)

if (duble[i][j]==0)

{ find=1;

break;

}

if (!find)

{ int min;

min=duble[1][j];

for (i=1; i<=razm; i++)

if (duble[i][j]
delta=delta+min;

for (i=1; i<=razm; i++)

duble[i][j]=duble[i][j]-min;

}

find=0;

}

return delta;

}


int Graph::zeros (int razm,int &x, int &y) // функция возвращает оценку

{ int i, j, maxprise=0; // самого "дорогого нуля"

x=y=100; // и помещает в x и y номер

for (i=1; i<=razm; i++) // строки и столбца с

for (j=1; j<=razm; j++) // максимальной оценкой

if (duble[i][j]==0)

{ int min, prise=0;

min=32000;

for (int k=1; k<=razm; k++)

if ((duble[i][k]
prise=prise+min;

min=32000;

for (k=1; k<=razm; k++)

if ((duble[k][j]
prise=prise+min;

if (prise>maxprise)

{ maxprise=prise;

x=duble[i][0];

y=duble[0][j];

}

}

return maxprise;

}


void Graph::print()

{

cout<
for (int i=0; i<=nmap; i++)

{ for (int j=0; j<=nmap; j++)

{ cout.flags(ios::left);

cout.width(6);

cout.fill(' ');

cout<

}

cout<
}

cout<
for (i=0; i<=nmap; i++)

{ for (int j=0; j<=nmap; j++)

{ cout.flags(ios::left);

cout.width(6);

cout.fill(' ');

cout<
}

cout<
}

getch();

clrscr();

cout<
for (i=0; i<=nmap; i++)

{ for (int j=0; j<=nmap; j++)

{ cout.flags(ios::left);

cout.width(6);

cout.fill(' ');

cout<
}

cout<
}

List *point=First;

cout<
cout<
road.from<<" ";

while (point)

{

cout<
road.to<<" ";

point=point->next;

}

}


void Graph::sortlist() // ф-я расставляет элементы

{ List *tmp,*point=First, *point1=First; // списка (путь) так, чтобы

int find=1, n=0, i=0; // поле to элеемнта

while (point) // было равно полю from

{ n++; // следующего элемента

point=point->next; // т. е. расстановка по местам

} // переходов между городами

while (point1)

{

find=0;

point=First;

while (point)

{ if (point1->road.to==point->road.from)

{

tmp=point1;

while ((tmp->next!=point)&&(tmp))

tmp=tmp->next;

if (!tmp)

{ tmp=First;

while (tmp->next!=point1)

tmp=tmp->next;

List *tmp1=First;

if (point!=First)

while (tmp1->next!=point)

tmp1=tmp1->next;

tmp->next=point1->next;

point1->next=point;

if (tmp1==First) First=point1;

else tmp1->next=point1;

find=1;

point1=tmp;

}

else

{ tmp->next=point->next;

point->next=point1->next;

point1->next=point;

find=1;

}

break;

}

point=point->next;

}

if ((!find)&&(point1==First))

{ i++;

tmp=point=First;

while (point->next)

point=point->next;

point->next=tmp;

First=First->next;

tmp->next=NULL;

if (First)

if (i<=n) point1=First;

else point1=point->next;

}

else

point1=point1->next;

}


}


List* Graph::Clear(List*p) // очистка списка найденного пути

{ List*point;

while (p)

{ point=p;

p=point->next;

delete point;

}

return p;

}


int Graph::del (int razm, int x, int y) // удаление строки и столбца,

{ int i, j, k; // содержащих самый дорогой нуль

for (i=1; i<=razm; i++) // также запрещается переход,

if (duble[i][0]==x) k=i; // замыкающий найденный путь

for (i=k; i
for (j=0; j<=razm; j++) // из которого уже вышел

duble[i][j]=duble[i+1][j];

for (j=1; j<=razm; j++)

if (duble[0][j]==y) k=j;

for (j=k; j
for (i=0; i<=razm; i++)

duble[i][j]=duble[i][j+1];

for (i=1; i
for (j=1; j
if ((duble[i][0]==y)&&(duble[0][j]==x))

duble[i][j]=32000;

sortlist();

List *point=First;

if (point)

while (point->next)

{ if (point->road.to!=point->next->road.from) break;

point=point->next;

}

for (i=1; i
for (j=1; j
if ((duble[i][0]==point->road.to)&&(duble[0][j]==First->road.from))

duble[i][j]=32000;


return --razm;

}


item* Graph::lasttwo(item *p) // обработка случая, когда в матице остается

{ List *point; // лишь два перехода

item *tmp1, *tmp2;

tmp2=new item;

tmp1=new item;

p->next=tmp1;

tmp1->prev=p;

tmp1->next=tmp1->negnext=NULL;

tmp1->value=p->value;

tmp1->del.from=duble[1][0];

tmp2->del.from=duble[2][0];

if ((duble[1][1]==0)&&(duble[2][2]==0))

{

tmp1->del.to=duble[0][1];

tmp2->del.to=duble[0][2];

}

else

{

tmp1->del.to=duble[0][2];

tmp2->del.to=duble[0][1];

}

p=p->next;

p->next=tmp2;

tmp2->prev=p;

tmp2->next=tmp2->negnext=NULL;

tmp2->value=p->value;

point=new List;

point->road.from=tmp1->del.from;

point->road.to=tmp1->del.to;

List *t=First;

if (t)

{

while(t->next)

t=t->next;

point->next=NULL;

t->next=point;

}

else

{ First=point;

point->next=NULL;

}

point=new List;

point->road.from=tmp2->del.from;

point->road.to=tmp2->del.to;

t=First;

if (t)

{

while(t->next)

t=t->next;

point->next=NULL;

t->next=point;

}

else

{ First=point;

point->next=NULL;

}

return p;

}


void Graph::find() // поиск пути

{ First=NULL; // рпоходит до конца по левой ветке

int maxvalue; // дерева. Запоминается путь и его

Root->value=prived(nduble); // стоимость. Все вершины с такой же

item *tmp; // или более дорогой стоимостью удаляются (при возврате).

int line=1, stolb=1; // После возвращения к корню, проходит по

tmp=Root; // неудаленному пути и если матрица не

while (nduble>2) // полностьью удалена, то создаеься

{ List *point; // дальнейший путь (если ст-ть созданной

item *tmp1, *tmp2; // вершины больше стоимости пути, то

tmp1=new item; // верршина удаляется и дальше не

tmp2=new item; // просматрривается). Если путь меньше

tmp->negnext=tmp2; // старого, то он запоминается. Так продолж.

tmp2->prev=tmp; // пока все вершины кроме корня не удалены

tmp2->next=tmp2->negnext=NULL;

tmp2->value=zeros(nduble,line,stolb)+tmp->value;

point=new List;

point->road.from=line;

point->road.to=stolb;

List *t=First;

if (t)

{

while(t->next)

t=t->next;

point->next=NULL;

t->next=point;

}

else

{ First=point;

point->next=NULL;

}

nduble=del(nduble,line,stolb);

tmp2->del.from=-line;

tmp2->del.to=-stolb;

tmp->next=tmp1;

tmp1->prev=tmp;

tmp1->next=tmp1->negnext=NULL;

tmp1->value=prived(nduble)+tmp->value;

tmp1->del.from=line;

tmp1->del.to=stolb;

tmp=tmp->next;

}

tmp=lasttwo(tmp);

sortlist();

maxvalue=tmp->next->value;

List *First1=First;

First=NULL;

maxvalue=tmp->value;

while ((Root->next)||(Root->negnext))

{ int i,j;

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

for (j=0; j<=nmap; j++)

duble[i][j]=map[i][j];

nduble=nmap;

while (tmp!=Root)

{ if (tmp->next)

if (tmp->next->value>=maxvalue)

{ delete tmp->next;

tmp->next=NULL;

}

if (tmp->negnext)

if (tmp->negnext->value>=maxvalue)

{ delete tmp->negnext;

tmp->negnext=NULL;

}

if ((!tmp->next)&&(!tmp->negnext))

{ item *tmp1=tmp;

tmp=tmp->prev;

if (tmp->next==tmp1) tmp->next=NULL;

else tmp->negnext=NULL;

delete tmp1;

}

else tmp=tmp->prev;

}

if ((Root->negnext)&&(Root->negnext->value>=maxvalue))

{ delete Root->negnext;

Root->negnext=NULL;

continue;

}

Root->value=prived(nduble);

int line=1, stolb=1;

int exit;

tmp=Root;

while (nduble>2)

{ List *point;

item *tmp1, *tmp2;

exit=0;

tmp1=tmp->next;

if (tmp1)

{ zeros(nduble,line,stolb);

nduble=del(nduble,line,stolb);

prived(nduble)+tmp->value;

tmp=tmp->next;

point=new List;

point->road.from=tmp->del.from;

point->road.to=tmp->del.to;

List *t=First;

if (t)

{

while(t->next)

t=t->next;

point->next=NULL;

t->next=point;

}

else

{ First=point;

point->next=NULL;

}

continue;

}

tmp2=tmp->negnext;

if (tmp2)

{ tmp=tmp->negnext;

for (i=1; i
for (j=1; j
if ((duble[i][0]==-tmp->del.from)&&(duble[0][j]==-tmp->del.to))

duble[i][j]=32000;

prived(nduble);

continue;

}

if ((!tmp->next)&&(!tmp->negnext)&&(tmp->value
{ if (tmp==Root)

{ exit=1;

break;

}

tmp1=new item;

tmp2=new item;

tmp->negnext=tmp2;

tmp2->prev=tmp;

tmp2->next=tmp2->negnext=NULL;

tmp2->value=zeros(nduble,line,stolb)+tmp->value;

nduble=del(nduble,line,stolb);

tmp2->del.from=-line;

tmp2->del.to=-stolb;

tmp->next=tmp1;

tmp1->prev=tmp;

tmp1->next=tmp1->negnext=NULL;

tmp1->value=prived(nduble)+tmp->value;

tmp1->del.from=line;

tmp1->del.to=stolb;

if (tmp1->value>=maxvalue)

{ delete tmp->next;

tmp->next=NULL;

}

else

{ point=new List;

point->road.from=tmp1->del.from;

point->road.to=tmp1->del.to;

List *t=First;

if (t)

{

while(t->next)

t=t->next;

point->next=NULL;

t->next=point;

}

else

{ First=point;

point->next=NULL;

}

}

if (tmp2->value>=maxvalue)

{ delete tmp->negnext;

tmp->negnext=NULL;

}

if ((!tmp->next)&&(!tmp->negnext))

{ exit=1;

First=Clear(First);

break;

} else

{ if (tmp->next)

{ tmp=tmp->next;

continue;

}

if (tmp->next)

tmp=tmp->next;

}

}

}

if(!exit)

{ //List *point;

tmp=lasttwo(tmp);

if (maxvalue>tmp->value)

{ First1=Clear(First1);

First1=First;

First=NULL;

sortlist();

maxvalue=tmp->value;

}

}

}

List *point;

while (First)

{ point=First;

First=point->next;

delete point;

}

First=First1;

sortlist();

print();

delete Root;

First=Clear(First);

cout<
}

void main()

{ clrscr();

randomize();

Graph a; //получение матриц

int kod=0;

int t=random (10); // время начала принятия решения

//коэффициент готовности оператора

int k=100*(exp(-t/7)+0.12*(-11.9*exp(-t/5)+exp(-12*t)*0.1+11.8*exp(-t/7)));

int l=random(100);

if (k>l)

{while (kod!=27)

{clrscr();

a.sum();

a.find();

cout<
cout<
<<"любую другую клавишу."<
kod=getch();

}

}

else

{

cout<
getch();

}

}


Оптимизация размещения данных на жёстком диске.


ЦЕЛЬ:

ОГРАНИЧЕНИЯ:

АЛЬТЕРНАТИВЫ:

ТИП:


Исходный текст программы ( Реализовано на С++ ):


#include

#include

#include

#include

#include

#include

#include


#include "myconio.h"

#include "txtmenu.h"

#define MINDRVSPACE 100L

#define MAXDRVSPACE 100000L

#define MINDRVSPEED 100L

#define MAXDRVSPEED 50000L

#define MINSYSREQ 0

#define MAXSYSREQ 1000

#define MINTIME 0.5

#define MAXTIME 24


// Данные для организации меню программы

MenuItem MenuItems[3]={{ 3,2," Моделирование ",0x2F00,1,2,1},

{20,2," Настройка " ,0x1500,1,2,1},

{34,2," Выход " ,0x2000,1,2,1}};

TextMenu MainMenu(MenuItems,3);

int FileReportFlag=1; // флаг дозволения записи отчета по моделированию

char fname[]="report.dat"; // в файл "REPORT.DAT"


// Начальные условия и ограничения:

long DiskSpace; // общий объем диска (в информационной смысле), Мб

long DiskSpeed; // скорость доступа к данным на диске, Кб/сек

long SysReq; // минимум свободного пространства, необходимый для

// функционирования системы

long FreeSpace; // свободное пространство на диске к моменту работы

float MaxTime; // максимальное время, выделенное для

// управляющей деятельности оператора


// Показать на экране окно с информацией о программе

void AboutPut()

{

for (int w=2,h=2; w<35; w++,h=2+w*6/35) {

textattr(0x70);

BorderPut(62-w/2,5-h/2,62-w/2+w,5-h/2+h,2);

delay(20);

textattr(0x00);

window(62-w/2,5-h/2,62-w/2+w,5-h/2+h);

clrscr();

}

textattr(0x70);

BorderPut(62-w/2,5-h/2,62-w/2+w,5-h/2+h,2);

w--,h=2+w*7/36;

window(63-w/2,6-h/2,63-w/2+w,5-h/2+h);

textattr(0x7F);

PutCLine(32,6);

cputs("Лабораторная работа N6\n\n\r");

PutCLine(32,3);

textattr(0x7E);

cputs("\"Моделирование работы\n\r");

PutCLine(32,11);

cputs("человека-оператора\"\n\n\r");

textattr(0x71);

cputs(" Сделал Ильдюков Д.М.\n\r ЭВМд-32 1999");

window(1,1,80,25);

}


// Инициализация экрана в текстовом режиме

void ScreenInit(char* buf, text_info& ti)

{

gettextinfo(&ti);

gettext(1,1,ti.screenwidth,ti.screenheight,buf);

textmode(C80);

window(1,1,80,25);

textattr(0x00);

clrscr();

_setcursortype(_NOCURSOR);

MainMenu.SetNAttr(0x71);

MainMenu.SetLAttr(0x1F);

MainMenu.SetLWAttr(0x1E);

MainMenu.DelFlags(SINGLE_BORDER);

MainMenu.SetBorderPos(1,1,44,3);

MainMenu.SetDownKey(0x4d00);

MainMenu.SetUpKey(0x4b00);

MainMenu.SetTopKey(0x4700);

MainMenu.SetBottomKey(0x4F00);

MainMenu.SetExitCode(0);

AboutPut();

MainMenu.ShowObj();

ClearKeyBuf();

}


// Восстановление состояния экрана

void ScreenRestore(char* buf, text_info& ti)

{

textmode(ti.currmode);

puttext(1,1,ti.screenwidth,ti.screenheight,buf);

gotoxy(ti.curx,ti.cury);

_setcursortype(_NORMALCURSOR);

}


// Установка параметров системы в случайные величины в определенном диапазоне

void RandomParam()

{

randomize();

DiskSpace=long(4*(unsigned)random((MAXDRVSPACE-MINDRVSPACE+1)/4)+MINDRVSPACE);

DiskSpeed=long(2*(unsigned)random((MAXDRVSPEED-MINDRVSPEED+1)/2)+MINDRVSPEED);

if (DiskSpeed>MAXSYSREQ)

SysReq=long((unsigned)random(MAXSYSREQ-MINSYSREQ+1)+MINSYSREQ);

else SysReq=long(random(DiskSpace-MINSYSREQ)+MINSYSREQ);

FreeSpace=DiskSpace-SysReq-random(DiskSpace-SysReq);

MaxTime=float(random(int((MAXTIME-MINTIME)*100.0)+1))/100.0+MINTIME;

}


// Вывод на экран сообщения об ошибке

void MessageBox(char* text)

{

char buf[80*5*2];

char buf2[80*2];

gettext(1,11,80,15,buf);

gettext(1,25,80,25,buf2);

window(1,1,80,25);

int l=strlen(text);

textattr(0x70);

gotoxy(2,25);

cputs("Нажмите любую клавишу для продолжения");

clreol();

textattr(0x4F);

BorderPut(41-l/2-2,11,41-l/2+l+2,15,2);

gotoxy(41-l/2,13);

cputs(text);

ClearKeyBuf();

ReadKey();

puttext(1,11,80,15,buf);

puttext(1,25,80,25,buf2);

}


// Настройка некоторых параметров системы

void GoSetup()

{

gotoxy(1,25);

textattr(0x70);

cputs(" Для перемещения по элементам окна используйте клавишу TAB, для выхода - ESC");

clreol();

char scrbuf[36*15*2];

gettext(45,10,80,24,scrbuf);

textattr(0x7F);

BorderPut(45,10,80,24,2);

window(47,11,78,23);

textattr(0x70);

cputs("Физический объем диска, Мб:\n\r");

textattr(0x1F);

PutCLine(32,78-47+1);

textattr(0x70);

cputs("Мин. скорость доступа к данным:\n\r");

textattr(0x1F);

PutCLine(32,78-47+1);

textattr(0x70);

cputs("Минимальное пустое пространство:");

textattr(0x1F);

PutCLine(32,78-47+1);

textattr(0x70);

cputs("Свободное пространство на диске:");

textattr(0x1F);

PutCLine(32,78-47+1);

textattr(0x70);

cputs("Максимальное время работы, час:\n\r");

textattr(0x1F);

PutCLine(32,78-47+1);

textattr(0x70);

cputs("\nЗаписывать результаты моделиро- вания в файл REPORT.DAT? ");

textattr(0x71);

PutCLine(32,4);

int pos=0;

char temp[50];

int key;

long tmpDSc=DiskSpace;

long tmpDSd=DiskSpeed;

long tmpSRQ=SysReq;

long tmpFLS=FreeSpace;

float tmpMT=MaxTime;

int tmpFRF=FileReportFlag;

textattr(0x1F);

ltoa(tmpDSc,temp,10);

gotoxy(2,2);

cputs(temp);

ltoa(tmpDSd,temp,10);

gotoxy(2,4);

cputs(temp);

ltoa(tmpSRQ,temp,10);

gotoxy(2,6);

cputs(temp);

ltoa(tmpFLS,temp,10);

gotoxy(2,8);

cputs(temp);

sprintf(temp,"%2.3f",tmpMT);

gotoxy(2,10);

cputs(temp);

do {

_setcursortype(_NORMALCURSOR);

textattr((pos==5)?0x0F:0x71);

gotoxy(27,13);

if (tmpFRF) strcpy(temp,"Да ");

else strcpy(temp,"Нет");

cputs(temp);

switch (pos) {

case 0: ltoa(tmpDSc,temp,10);

gotoxy(2,2);

break;

case 1: ltoa(tmpDSd,temp,10);

gotoxy(2,4);

break;

case 2: ltoa(tmpSRQ,temp,10);

gotoxy(2,6);

break;

case 3: ltoa(tmpFLS,temp,10);

gotoxy(2,8);

break;

case 4: sprintf(temp,"%2.3f",tmpMT);

gotoxy(2,10);

break;

}

if (pos!=5) {

textattr(0x1F);

cputs(" \r ");

cputs(temp);

}

key=ReadKey();

if (key==27) continue;

if (key==9) (pos==5)?pos=0:pos++;

else if (pos==5) {

if (key==32 || key==13) tmpFRF=!tmpFRF;

}

else {

gotoxy(1,wherey());

if (key>0xFF) ungetc(key/0xFF,stdin);

ungetc(key|0x00FF,stdin);

key=EditStr(temp,78-47+1,10);

switch (pos) {

case 0: tmpDSc=atol(temp);

break;

case 1: tmpDSd=atol(temp);

break;

case 2: tmpSRQ=atol(temp);

break;

case 3: tmpFLS=atol(temp);

break;

case 4: tmpMT=atof(temp);

}

key=9;

ungetc(key,stdin);

}

} while (key!=27);

if (tmpDSc
else if (tmpDSc>MAXDRVSPACE) MessageBox("Слишком велик первый параметр!");

else DiskSpace=tmpDSc;

if (tmpDSd
else if (tmpDSd>MAXDRVSPEED) MessageBox("Слишком велик второй параметр!");

else DiskSpeed=tmpDSd;

if (tmpSRQ
else if (tmpSRQ>MAXSYSREQ) MessageBox("Слишком велик третий параметр!");

else SysReq=tmpSRQ;

if (tmpFLS<0) MessageBox("Слишком мал четвертый параметр!");

else if (tmpFLS>DiskSpace-SysReq) MessageBox("Слишком велик четвертый параметр!");

else FreeSpace=tmpFLS;

if (tmpMT
else if (tmpMT>MAXTIME) MessageBox("Слишком велик пятый параметр!");

else MaxTime=tmpMT;

FileReportFlag=tmpFRF;

window(1,1,80,25);

_setcursortype(_NOCURSOR);

puttext(45,10,80,24,scrbuf);

}


// Функция выводит в файл *f заголовок

void WriteTitelToFile(FILE* f)

{

static char Days[7][15]={"Воскресенье","Понедельник","Вторник","Среда",

"Четверг","Пятница","Суббота"};

time_t t;

tm* tim;

t=time(NULL);

tim=gmtime(&t);

fprintf(f,"\n==================== РЕЗУЛЬТАТЫ МОДЕЛИРОВАНИЯ ====================\n");

fprintf(f,"Дата запуска моделирующей программа: %02d/%02d/%d %s\n",

tim->tm_mday,tim->tm_mon+1,tim->tm_year+1900,Days[tim->tm_wday]);

fprintf(f,"Время запуска моделирующей программы: %02d:%02d:%02d\n",

tim->tm_hour,tim->tm_min,tim->tm_sec);

fprintf(f," Начальные условия и ограничения:\n");

fprintf(f,"- емкость винчестера %ld Мбайт\n",DiskSpace);

fprintf(f,"- скорость доступа к данным на диске %ld Кбайт/сек\n",DiskSpeed);

fprintf(f,"- обязательный минимум свободного \"места\" %ld Мбайт\n",SysReq);

fprintf(f,"- величина свободного пространства на диске %ld Мбайт\n",FreeSpace);

fprintf(f,"- время, предоставленное оператору на данную задачу %f часов\n",MaxTime);


cprintf(" Начальные условия и ограничения:\n\r");

cprintf("- емкость винчестера %ld Мбайт\n\r",DiskSpace);

cprintf("- скорость доступа к данным на диске %ld Кбайт/сек\n\r",DiskSpeed);

cprintf("- обязательный минимум свободного \"места\" %ld Мбайт\n\r",SysReq);

cprintf("- величина свободного пространства на диске %ld Мбайт\n\r",FreeSpace);

cprintf("- время, предоставленное оператору на данную задачу %f часов\n\r",MaxTime);

}


// Функция моделирования

void GoModel()

{

float t=0.0; // счетчик времени, не должен быть больше MaxTime

float Gotov; // коэффициент готовности человека-оператора к данной работе

long CurFree; // текущее свободное пространство жесткого диска

long CurSpeed; // текущая скорость доступа к данным винчестера

const float Lambda[2] = {5.7, 1};

int EndOfWork=0; // флаг завершения работы


/* 1 - NC, VC, DN...

2 - NDD, ScanDisk...

3 - DS, Defrag...

4 - DblSpace, Stak, DrvSpace...

5 - ARJ, ARC...

6 - PC-CACHE, NWCACHE, SmartDrv...

*/

float ppMethods[6]={0.14, 0.23, 0.70, 0.54, 0.45};// вероятности успешного

// результата для каждой альтернативы решения (оценки эффективности

// всех вариантов поведения)

int CurMet; // индекс текущего метода из указанных альтернатив

char MethodsEnable[6]; // вектор "известности" каждой из альтернатив

// оператору: в зависимости от степени его готовности

float MethodsTime[6]; // оценки времени для каждого варианта решения с

// учетом текущей ситуации и некоторого случайного фактора


FILE* f; // файловый манипулятор

window(1,10,80,24);

textattr(0x02);

clrscr();

f=fopen(fname,"a+");

if (f==NULL) {

MessageBox("Не могу открыть файл \"REPORT.DAT\" на запись!");

FileReportFlag=0;

}

else WriteTitelToFile(f);

Gotov=random(900*0.9)/1000.0+0.05;

CurFree=FreeSpace;

CurSpeed=DiskSpeed;


// Цикл выполнения человеком-оператором действий

for (; t<= MaxTime && EndOfWork==0; ) {

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

MethodsEnable[i]=random(150)/100.0
int Count=0;

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

if (MethodsEnable[i]) Count++;


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

// Человек еще не готов к выполнению заданной работы, так как "не знает"

// ни одного варианта решения подобной задачи.

if (Count==0) {

if (FileReportFlag) fprintf(f,"Человек-оператор пока не готов к "

"данной работе.\nЕму не известен ни один вариант решения "

"поставленной задачи\n");

cprintf("Человек-оператор пока не готов к данной работе.\n\r"

"Ему не известен ни один вариант решения поставленной задачи\n\r");

Gotov+=random(int(1000*(1-Gotov-0.1)))/1000.0;

t+=sqrt(abs(random(int(100*(MaxTime-t)))/1000.0));

continue;

}

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

// Хотя бы с одним из предложенных инструментов человек-оператор знаком

else {

for (Count=0,i=0; i<6; i++)

if (MethodsEnable[i]) {

if (i!=5 && i!=0)

MethodsTime[i]=1024*(DiskSpace-CurFree-SysReq)/

(15*CurSpeed*random(200)/100.0+5);

else if (i==0) MethodsTime[i]=MaxTime-t-random(10)/37.2;

else MethodsTime[i]=0.3;

if (MethodsTime[i]>MaxTime-t) MethodsEnable[i]=0;

else Count++;

}

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

// Разбор альтернатив решения:

// - увеличение свободного дискового пространства;

// - увеличение скорости доступа к данным на диске.

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

// Оставшегося времени не хватает на реализацию ни одного известного

// оператору варианта альтернативы

if (Count==0) {

if (FileReportFlag) fprintf(f,"Не хватит времени для реализации "

"какого-либо варианта\nрешения поставленной задачи\n");

cprintf("Не хватит времени для реализации какого-либо варианта\n\r"

"решения поставленной задачи\n\r");

Gotov+=random(int(1000*(1-Gotov-0.1)))/1000.0;

t+=random(int(700*(MaxTime-t)))/1000.0;

CurMet=-1;

break;

}

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

// Оставшегося времени достаточно для реализации какого-либо варианта

else {

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

// Есть единственный вариант - сжатие диска, но он существенно замедляет

// скорость доступа к данным на диске

if (Count==1 && MethodsEnable[3]) {

CurMet=3;

t+=MethodsTime[i];

Gotov+=(1-Gotov)*(random(100)-10)/100.0;

CurFree+=random(DiskSpace-SysReq-CurFree)*ppMethods[CurMet]/17;

continue;

}

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

// Иначе смотрим другие варианты:

float Sum=0.0;

Sum=(Lambda[random(2)]<-2)?(Lambda[0]-random(120-MAXTIME)):0.0;

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

if (MethodsEnable[i]) Sum+=ppMethods[i];

float ppp=random(1000*Sum)/1000.0;

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

if (MethodsEnable[i]) {

ppp-=ppMethods[i];

if (ppp<=0) {

CurMet=i;

break;

}

}

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

// Выбран номер используемого варианта решения данной ЗПР

t+=MethodsTime[CurMet];

// Существенное

if (CurMet==5) CurSpeed+=random(MAXDRVSPEED-CurSpeed)/2.5;

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

else if (CurMet==2) CurSpeed+=random(MAXDRVSPEED-CurSpeed)/7;

else CurSpeed+=(random((MAXDRVSPEED-CurSpeed)/2)-(MAXDRVSPEED-CurSpeed)/2)/20;

// Увеличение количества свободного места на диске

CurFree+=(random(DiskSpace-SysReq-CurFree)-33)*ppMethods[CurMet]/48;

// Корректируем коэффициент готовности человека-оператора

Gotov+=(random(1000*(1-Gotov))-43)/1000.0;

}

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

// Выводим промежуточные итоги моделирования

if (FileReportFlag) {

if (CurMet>=0 && CurMet<6)

fprintf(f,"\nВыбранная альтернатива из 6 возможных: %d\n",CurMet+1);

fprintf(f,"Прошедшее время с начала принятия решения: %f\n",t);

fprintf(f,"Новое свободное пространство диска: %ld\n",CurFree);

fprintf(f,"Новая скорость доступа к данным на диске: %ld\n",CurSpeed);

fprintf(f,"Коэффициент готовности оператора: %f\n",Gotov);

}

if (CurMet>=0 && CurMet<6)

cprintf("\n\rВыбранная альтернатива из 6 возможных: %d\n\r",CurMet+1);

cprintf("Прошедшее время с начала принятия решения: %f\n\r",t);

cprintf("Новое свободное пространство диска: %ld\n\r",CurFree);

cprintf("Новая скорость доступа к данным на диске: %ld\n\r",CurSpeed);

cprintf("Коэффициент готовности оператора: %f\n\r",Gotov);

}

}


// Закрываем файл отчета:

cprintf("======== МОДЕЛИРОВАНИЕ ЗАВЕРШЕНО ========\n\r");

if (FileReportFlag) {

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

fclose(f);

cprintf("Результаты моделирования находятся в файле REPORT.DAT\n\r\r");

}

window(1,1,80,25);

}


int main()

{

RandomParam();

int p;

char ScrBuf[50*80*2];

text_info oldti;

ScreenInit(ScrBuf,oldti);

do {

gotoxy(1,25);

textattr(0x70);

cputs(" Для перемещения по меню используйте навигационные клавиши");

clreol();

p=MainMenu.Work();

// Проводим моделирование:

if (p==0) GoModel();

// Иначе переходим к настройке параметров системы

else if (p==1) GoSetup();

MainMenu.PutOnePos(p);

} while (p==0 || p==1);

ScreenRestore(ScrBuf,oldti);

return 0;

}


Модель принятия решения при покупке компьютера в г. Ульяновске.