РГЗ по теории вычислительных процессов

Подождите немного. Документ загружается.

Список использованных источников

1. Методические рекомендации к выполнению расчётно-графического

задания по дисциплине «Теория вычислительных процессов».

2. Учебное пособие по дисциплине «Теория вычислительных процессов».

Е.Н. Ишакова. – Оренбург: ГОУ ОГУ, 2007. – 160 с.

3. Корнеев В.В.. Параллельные вычислительные системы. - М.: Нолидж,

1999.

Лист

Приложение А

Текст программы

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

#include <vcl.h>

#pragma hdrstop

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

USEFORM("Unit2.cpp", Form2);

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

WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)

{

try

{

Application->Initialize();

SetApplicationMainFormOnTaskBar(Application, true);

Application->CreateForm(__classid(TForm2), &Form2);

Application->Run();

}

catch (Exception &exception)

{

Application->ShowException(&exception);

}

catch (...)

{

try

{

throw Exception("");

}

catch (Exception &exception)

{

Application->ShowException(&exception);

}

return 0;

}

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

#pragma hdrstop

#include <stddef.h>

#include "MatrixTVPUnit.h"

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

#pragma package(smart_init)

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

matrix::matrix(int iSize)

{

size = iSize;

data = new int*[iSize];

int n, i;

for (n = 0; n < iSize; ++n)

{

Лист

data[n] = new int[iSize];

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

data[n][i] = 0;

}

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

matrix::matrix(matrix *matr)

{

size = matr->size;

data = new int*[size];

int n, i;

for (n = 0; n < size; ++n)

{

data[n] = new int[size];

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

data[n][i] = matr->data[n][i];

}

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

matrix::~matrix()

{

int n;

for (n = 0; n < size; ++n)

delete[] data[n];

delete[] data;

}

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

void BuildTransitLink(matrix *matr, matrix *matrT)

{

int size = matr->size;

int *Rows = new int[size];

int row, col, n, rowCount, result;

for (row = 1; row < size; ++row)

for (col = 0; col < size; ++col)

matrT->data[row][col] = matr->data[row][col];

for (row = 1; row < size; ++row)

{

for (n = 0; n < size; ++n)

Rows[n] = 0;

rowCount = 0;

for (col = 0; col < row; ++col)

if (matrT->data[row][col])

Rows[rowCount++] = col;

for (col = 0; col < row; ++col)

{

result = matrT->data[row][col];

for (n = 0; n < rowCount; ++n)

result = result || matrT->data[Rows[n]][col];

if ( result )

matrT->data[row][col] = 1;

}

Лист

delete[] Rows;

}

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

void BuildMatrixL(matrix *matr, matrix *matrL)

{

int size = matr->size;

int *byControl = new int[size];

int row, col, i, j, iCount;

for (col = 0; col < size; ++col)

{

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

byControl[i] = 0;

iCount = 0;

for (row = col; row < size; ++row)

if ( matr->data[row][col] == 2 )

byControl[iCount++] = row;

for (i = 0; i < iCount-1; ++i)

{

for (j = i+1; j < iCount; ++j)

{

matrL->data[byControl[i]][byControl[j]] = 1;

matrL->data[byControl[j]][byControl[i]] = 1;

}

delete[] byControl;

}

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

void BuildMatrixLt(matrix *matrT, matrix *matrLt)

{

int size = matrLt->size;

int row, col, n, result;

//ищем входы в матрице транзитивных связей

list entries;

for (row = size-1; row >= 0; --row)

{

result = 0;

for (col = 0; col <= row; ++col)

result |= matrT->data[row][col];

if ( result == 0 )

entries.add(row);

}

int iCount;

int *Rows = new int[size];

for (row = 0; row < size; ++row)

{

iCount = 0;

for (col = 0; col < row; ++col)

{

if ( matrT->data[row][col] && (!entries.inList(col)) )

Rows[iCount++] = col;

}

Лист

if ( iCount )

{

for (col = 0; col < size; ++col)

{

result = 1;

for (n = 0; n < iCount; ++n)

result &= matrLt->data[Rows[n]][col];

result |= matrLt->data[row][col];

if ( result )

{

matrLt->data[row][col] = 1;

matrLt->data[col][row] = 1;

}

delete[] Rows;

}

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

void BuildMatrixM(matrix *matrT, matrix *matrLt, matrix *matrM)

{

int size = matrT->size;

int row, col;

for (row = 1; row < size; ++row)

for (col = 0; col < row; ++col)

{

matrM->data[row][col] = matrT->data[row][col];

matrM->data[col][row] = matrT->data[row][col];

}

for (row = 0; row < size; ++row)

for (col = 0; col < size; ++col)

{

if ( matrM->data[row][col] || matrLt->data[row][col] )

matrM->data[row][col] = 1;

}

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

list::list()

{

count = 0;

head = NULL;

current = NULL;

}

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

list::~list()

{

if ( count )

{

node *node;

while ( head->next != NULL )

{

node = head;

Лист

head = node->next;

delete node;

}

delete head;

}

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

void list::add(int val)

{

node *new_node = new node;

new_node->value = val;

new_node->next = head;

head = new_node;

++count;

}

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

void list::toHead()

{

current = head;

}

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

bool list::next(int &val)

{

if ( current == NULL )

{

val = 0;

return false;

}

val = current->value;

current = current->next;

return true;

}

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

bool list::inList(int val)

{

if ( count == 0 )

return false;

node *cur;

cur = head;

bool bOk = false;

while ( cur != NULL )

{

if ( cur->value == val )

{

bOk = true;

break;

}

cur = cur->next;

}

return bOk;

}

Лист

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

#include <vcl.h>

#pragma hdrstop

#include <Math.hpp>

#include "MainUnit.h"

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

#pragma package(smart_init)

#pragma resource "*.dfm"

TMainForm *MainForm;

int iStage, iSize;

matrix *Matrix0;

matrix *MatrixT;

matrix *MatrixL;

matrix *MatrixLt;

matrix *MatrixM;

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

__fastcall TMainForm::TMainForm(TComponent* Owner)

: TForm(Owner)

{

}

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

void __fastcall TMainForm::FormShow(TObject *Sender)

{

MatrixGrid->Cells[1][2] = "*";

MatrixGrid->Cells[1][3] = "*";

MatrixGrid->Cells[1][4] = "*";

MatrixGrid->Cells[2][5] = "1";

MatrixGrid->Cells[3][6] = "1";

MatrixGrid->Cells[4][7] = "1";

MatrixGrid->Cells[2][8] = "1";

MatrixGrid->Cells[3][8] = "1";

MatrixGrid->Cells[5][9] = "1";

MatrixGrid->Cells[6][9] = "1";

MatrixGrid->Cells[8][9] = "*";

MatrixGrid->Cells[7][10] = "1";

MatrixGrid->Cells[8][10] = "*";

iSize = 10;

iStage = 1;

EditSize->Visible = false;

ButtonStart->OnClick = ButtonStartClick2;

ShowMatrixGrid();

iStage = 0;

}

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

void __fastcall TMainForm::FormClose(TObject *Sender, TCloseAction &Action)

{

if ( iStage > 1 )

Лист

{

delete Matrix0;

delete MatrixT;

if ( iStage > 3 )

delete MatrixL;

if ( iStage > 4 )

delete MatrixLt;

if ( iStage > 5 )

delete MatrixM;

}

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

void __fastcall TMainForm::EditSizeKeyPress(TObject *Sender, char &Key)

{

if ( Key < 0 )

Key = 0;

else if ( (Key > 31) && ( Key < 48 || Key > 57 ))

Key = 0;

}

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

void __fastcall TMainForm::ButtonStartClick(TObject *Sender)

{

iSize = EditSize->Text.ToIntDef(0);

if ( iSize > 0 )

{

EditSize->Visible = false;

LabelSize->Caption = "Заполните матрицу следования:";

ShowMatrixGrid();

ButtonStart->OnClick = ButtonStartClick2;

iStage = 1;

}

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

void __fastcall TMainForm::ButtonStartClick2(TObject *Sender)

{

int row, col;

switch (iStage)

{

case 1 :

{

Matrix0 = new matrix(iSize);

MatrixT = new matrix(iSize);

for (col = 1; col <= iSize; ++col)

for (row = 1; row <= iSize; ++row)

{

if ( MatrixGrid->Cells[col][row] == "1" )

Matrix0->elem(row-1,col-1) = 1;

else if ( MatrixGrid->Cells[col][row] == "*" )

Matrix0->elem(row-1,col-1) = 2;

else

Лист

Matrix0->elem(row-1,col-1) = 0;

}

iStage = 2;

for (col = 1; col <= iSize; ++col)

for (row = 1; row <= iSize; ++row)

{

if ( Matrix0->elem(row-1,col-1) == 1 )

MatrixGrid->Cells[col][row] = "1";

else if ( Matrix0->elem(row-1,col-1) == 2 )

MatrixGrid->Cells[col][row] = "2";

else

MatrixGrid->Cells[col][row] = "";

}

LabelSize->Caption = "Матрица следования:";

}

break;

case 2 :

{

BuildTransitLink(Matrix0, MatrixT);

iStage = 3;

ShowMatrix(MatrixT);

LabelSize->Caption = "Матрица транзитивных связей:";

}

break;

case 3 :

{

MatrixL = new matrix(iSize);

iStage = 4;

BuildMatrixL(Matrix0, MatrixL);

ShowMatrix(MatrixL);

LabelSize->Caption = "Матрица L:";

}

break;

case 4 :

{

MatrixLt = new matrix(MatrixL);

iStage = 5;

BuildMatrixLt(MatrixT, MatrixLt);

ShowMatrix(MatrixLt);

LabelSize->Caption = "Матрица Lt:";

}

break;

case 5 :

{

MatrixM = new matrix(iSize);

iStage = 6;

BuildMatrixM(MatrixT, MatrixLt, MatrixM);

ShowMatrix(MatrixM);

Лист

LabelSize->Caption = "Матрица M:";

}

ButtonStart->Enabled = false;

}

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

void __fastcall TMainForm::ShowMatrix(matrix *matr)

{

int row, col;

for (col = 1; col <= iSize; ++col)

for (row = 1; row <= iSize; ++row)

{

if ( matr->elem(row-1,col-1) )

MatrixGrid->Cells[col][row] = "1";

else

MatrixGrid->Cells[col][row] = "";

}

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

void __fastcall TMainForm::MatrixGridClick(TObject *Sender)

{

if ( iStage > 1 )

return;

AnsiString asMess = "Row = " + AnsiString(MatrixGrid->Row) + "; Col = " +

AnsiString(MatrixGrid->Col);

Application->MessageBoxA(asMess.c_str(),"Cell",MB_OK);

if ( MatrixGrid->Row > MatrixGrid->Col )

LinkPopup->Popup(Mouse->CursorPos.x, Mouse->CursorPos.y);

}

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

void __fastcall TMainForm::miInformClick(TObject *Sender)

{

MatrixGrid->Cells[MatrixGrid->Col][MatrixGrid->Row] = "1";

}

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

void __fastcall TMainForm::miControlClick(TObject *Sender)

{

MatrixGrid->Cells[MatrixGrid->Col][MatrixGrid->Row] = "*";

}

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

void __fastcall TMainForm::miDeleteClick(TObject *Sender)

{

MatrixGrid->Cells[MatrixGrid->Col][MatrixGrid->Row] = "";

}

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

void __fastcall TMainForm::ShowMatrixGrid()

{

MatrixGrid->RowCount = iSize + 1;

MatrixGrid->ColCount = iSize + 1;

MatrixGrid->Top = LabelSize->Height + 16;

Лист