Добавил:
Upload Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:
Скачиваний:
22
Добавлен:
12.02.2015
Размер:
497.5 Кб
Скачать

Министерство образования и науки Российской Федерации Саратовский государственный технический университет

М.Ф.Степанов

ПРИЛОЖЕНИЕ

кметодическим указаниям

квыполнению работ

по дисциплине

Системное программное обеспечение

для студентов специальности 210100 ("Управление и информатика в технических системах")

Одобрено редакционно–издательским Советом Саратовского государственного технического университета

Саратов 2010

Системное программное обеспечение

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

ЛИСТИНГИ ИСХОДНЫХ ТЕКСТОВ ПРОГРАММ

Листинг 1. Тестовая программа на входном языке системы МАТЛАБ

a=[0 1 0;0 0 1;-1 -2 -3] b=[0;0;1]

c=[1 0 0;0 1 0;0 0 1] sys=ss(a,b,c,0) x0=[1;0;0] initial(sys,x0)

Листинг 2. Объявление структуры task

struct task

{

int n; double *dA; double *dx0;

double t0, tk; double h;

int N; double *at; double *ax;

}

Листинг 3. Объявление класса TTask (файл TTask.h)

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

#ifndef TTaskH #define TTaskH

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

class TTask

{

private:

int n; double *dA; double *dx0;

double t0, tk; double h;

int N; double *at;

double *ax; char *szText;

public:

TTask();

TTask(int n, double t0, double tk, double h); ~TTask();

void setSizeX(int n); int getSizeX();

void setElemA(int iRow, int jCol, double aij); double getElemA(int iRow, int jCol);

void setElemX0(int iRow, double xi); double getElemX0(int iRow);

void setT0(double _t0); double getT0();

void setTk(double _tk); double getTk();

void setH(double _h); double getH();

int getN();

void setElemAx(int iNum, int k, double xik); double getElemAx(int iNum, int k);

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

2

М.Ф.Степанов

Создание распределенной системы решения задач

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

void setElemAt(int k, double _tk); double getElemAt(int k);

const char* getText();

}; //---------------------------------------------------------------------------

#endif

Листинг 4. Реализация класса TTask (файл TTask.cpp)

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

#pragma hdrstop #include "TTask.h" #include <stdio.h>

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

#pragma package(smart_init) //---------------------------------------------------------------------------

TTask::TTask()

{

dA = 0; dx0 = 0; at = 0; ax = 0;

szText = 0;

n = 0; t0 = 0.0; tk = 0.0; h = 0.0; N = 0;

}

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

TTask::TTask(int _n, double _t0, double _tk, double _h)

{

dA = 0; dx0 = 0; at = 0; ax = 0;

szText = 0;

n = _n; t0 = _t0; tk = _tk; h = _h;

if (h < 0.00000001) h = 0.00000001; N = ((tk-t0)/h)+2;

int nn = n*n; int nN = n*N;

dA = new double[nn]; for (int i=0; i<nn; i++)

dA[i] = 0.0;

dx0 = new double[n]; for (int i=0; i<n; i++)

dx0[i] = 0.0;

at = new double[N]; for (int i=0; i<N; i++)

at[i] = 0.0;

ax = new double[nN]; for (int i=0; i<nN; i++)

ax[i] = 0.0;

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

Методические указания к выполнению курсовой работы

3

Системное программное обеспечение

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

}

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

TTask::~TTask()

{

if (dA != 0) delete[] dA;

dA = 0;

if (dx0 != 0) delete[] dx0;

dx0 = 0; if (at != 0)

delete[] at; at = 0;

if (ax != 0) delete[] ax;

ax = 0;

if (szText != 0) delete[] szText;

szText = 0;

}

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

void TTask::setSizeX(int _n)

{

n = _n;

int nn = n*n; if (dA != 0)

delete[] dA;

dA = new double[nn]; for (int i=0; i<nn; i++)

dA[i] = 0.0; if (dx0 != 0)

delete[] dx0;

dx0 = new double[n]; for (int i=0; i<n; i++)

dx0[i] = 0.0;

}

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

int TTask::getSizeX()

{

return n;

}

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

void TTask::setElemA(int iRow, int jCol, double aij)

{

if (dA != 0) { if (iRow < n) {

if (jCol < n) { dA[iRow+jCol*n] = aij;

}

}

}

}

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

double TTask::getElemA(int iRow, int jCol)

{

double d = 0.0; if (dA != 0) {

if (iRow < n) { if (jCol < n) {

d = dA[iRow+jCol*n];

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

4

М.Ф.Степанов

Создание распределенной системы решения задач

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

}

}

}

return d;

}

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

void TTask::setElemX0(int iRow, double xi)

{

if (dx0 != 0) { if (iRow < n) {

dx0[iRow] = xi;

}

}

}

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

double TTask::getElemX0(int iRow)

{

double d = 0.0; if (dx0 != 0) { if (iRow < n) {

d = dx0[iRow];

}

}

return d;

}

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

void TTask::setT0(double _t0)

{

t0 = _t0;

}

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

double TTask::getT0()

{

return t0;

}

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

void TTask::setTk(double _tk)

{

tk = _tk;

}

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

double TTask::getTk()

{

return tk;

}

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

void TTask::setH(double _h)

{

h = _h;

if (h < 0.00000001) h = 0.00000001;

N = ((tk-t0)/h)+2; int nN = n*N;

if (at != 0) delete[] at;

at = new double[N]; for (int i=0; i<N; i++)

at[i] = 0.0;

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

Методические указания к выполнению курсовой работы

5

Системное программное обеспечение

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

if (ax != 0) delete[] ax;

ax = new double[nN]; for (int i=0; i<nN; i++)

ax[i] = 0.0;

}

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

double TTask::getH()

{

return h;

}

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

int TTask::getN()

{

return N;

}

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

void TTask::setElemAx(int iNum, int k, double xik)

{

if (ax != 0) {

if (iNum < n) { if (k < N) {

ax[iNum+k*n] = xik;

}

}

}

}

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

double TTask::getElemAx(int iNum, int k)

{

double d = 0.0; if (ax != 0) {

if (iNum < n) { if (k < N) {

d = ax[iNum+k*n];

}

}

}

return d;

}

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

void TTask::setElemAt(int k, double _tk)

{

if (at != 0) { if (k < N) {

at[k] = _tk;

}

}

}

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

double TTask::getElemAt(int k)

{

double d = 0.0; if (at != 0) {

if (k < N) { d = at[k];

}

}

return d;

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

6

М.Ф.Степанов

Создание распределенной системы решения задач

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

}

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

const char* TTask::getText()

{

if (n > 0) {

int iLen = 25+2*(n-1) + (4+n+n*n)*33; if (szText != 0)

delete[] szText;

szText = new char[iLen+1]; char c[33];

int iPos = 0; int ic = 0;

szText[iPos++] = 'n'; szText[iPos++] = '='; sprintf(c,"%i",n,'\0'); ic = 0;

while (szText[iPos++] = c[ic++]); szText[--iPos] = ';'; szText[++iPos] = '\r'; szText[++iPos] = '\n'; szText[++iPos] = 'A'; szText[++iPos] = '='; szText[++iPos] = '[';

for (int i=0; i<n; i++) { for (int j=0; j<n; j++) {

sprintf(c,"%g",getElemA(i,j),'\0'); ic = 0;

while (szText[++iPos] = c[ic++]); szText[iPos] = ' ';

}

if (i<n-1) szText[iPos] = ';';

else iPos--;

}

szText[++iPos] = ']'; szText[++iPos] = ';'; szText[++iPos] = '\r'; szText[++iPos] = '\n'; szText[++iPos] = 'x'; szText[++iPos] = '0'; szText[++iPos] = '='; szText[++iPos] = '['; for (int i=0; i<n; i++) {

sprintf(c,"%g",getElemX0(i),'\0'); ic = 0;

while (szText[++iPos] = c[ic++]); if (i<n-1)

szText[iPos] = ';'; else

iPos--;

}

szText[++iPos] = ']'; szText[++iPos] = ';'; szText[++iPos] = '\r'; szText[++iPos] = '\n'; szText[++iPos] = 't'; szText[++iPos] = '0'; szText[++iPos] = '='; sprintf(c,"%g",getT0(),'\0');

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

Методические указания к выполнению курсовой работы

7

Системное программное обеспечение

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

ic = 0;

while (szText[++iPos] = c[ic++]); szText[iPos] = ';'; szText[++iPos] = '\r'; szText[++iPos] = '\n'; szText[++iPos] = 't'; szText[++iPos] = 'k'; szText[++iPos] = '='; sprintf(c,"%g",getTk(),'\0');

ic = 0;

while (szText[++iPos] = c[ic++]); szText[iPos] = ';'; szText[++iPos] = '\r'; szText[++iPos] = '\n'; szText[++iPos] = 'h'; szText[++iPos] = '='; sprintf(c,"%g",getH(),'\0');

ic = 0;

while (szText[++iPos] = c[ic++]); szText[iPos] = ';'; szText[++iPos] = '\r'; szText[++iPos] = '\n';

szText[++iPos] = '\0';

}

return szText;

}

Листинг 5. Заголовочный файл функционального программного модуля (файл MFSmodule.h)

#ifndef MFSmoduleH #define MFSmoduleH #include "..\class\TTask.h"

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

extern "C" int MFSmodule(TTask *tsk);

extern "C" int MFSyFunc(TTask *tsk, double *x, double *dx);

extern "C" int MFSintegral(TTask *tsk, double *x, double *dx, double *dx1, double h); //-------------------------------------------------------------------------

#endif

Листинг 6. Исходный текст функционального программного модуля

(файл MFSmodule.cpp)

#pragma hdrstop #include "MFSmodule.h"

#pragma package(smart_init) //-------------------------------------------------------------------------

int MFSmodule(TTask *tsk)

{

int iRet = -1; if (tsk != 0) {

int n = tsk->getSizeX();

double *x = new double[n]; // выделение памяти double *dx = new double[n];

double *dx1 = new double[n]; for (int i=0; i<n; i++) {

x[i] = tsk->getElemX0(i); dx[i] = 0.0;

dx1[i] = 0.0;

}

int N = tsk->getN(); int k = 0;

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

8

М.Ф.Степанов

Создание распределенной системы решения задач

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

double t = tsk->getT0(); double tk = tsk->getTk(); double h = tsk->getH();

tsk->setElemAt(k,t); // сохранение начальных значений for (int i=0; i<n; i++) {

tsk->setElemAx(i,k,x[i]);

}

iRet = MFSyFunc(tsk,x,dx1); // начальный шаг методом Эйлера for (int i=0; i<n; i++) {

x[i] += dx1[i]*h/100.0;

}

do

{ // основной цикл

iRet = MFSintegral(tsk,x,dx,dx1,h); t += h;

k++;

tsk->setElemAt(k,t); // сохранение текущих значений for (int i=0; i<n; i++) {

tsk->setElemAx(i,k,x[i]);

}

} while (t <= tk); if (x != 0)

delete[] x; x = 0;

if (dx != 0) delete[] dx;

dx = 0;

if (dx1 != 0) delete[] dx1;

dx1 = 0;

}

return iRet;

}

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

int MFSyFunc(TTask *tsk, double *x, double *dx)

{

int iRet = -1; if (tsk != 0) {

int n = tsk->getSizeX(); if (x != 0) {

if (dx != 0) { iRet = 0;

for (int i=0; i<n; i++) { dx[i] = 0.0;

double aij = 0.0;

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

aij = tsk->getElemA(i,j); dx[i] += aij*x[j];

}

}

}

else

iRet = -3;

}

else

iRet = -2;

}

else

iRet = -1;

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

Методические указания к выполнению курсовой работы

9

Системное программное обеспечение

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

return iRet;

}

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

int MFSintegral(TTask *tsk, double *x, double *dx, double *dx1, double h)

{

int iRet = -1; if (tsk != 0) {

int n = tsk->getSizeX(); if (x != 0) {

if (dx != 0) {

if (dx1 != 0) {

iRet = MFSyFunc(tsk,x,dx); for (int i=0; i<n; i++) {

x[i] += (3.0*dx[i] - dx1[i])*h/2.0; dx1[i] = dx[i];

}

}

else

iRet = -4;

}

else

iRet = -3;

}

else

iRet = -2;

}

else

iRet = -1; return iRet;

}

Листинг 7. Исходный программный код функции обработки щелчка на кнопке "Решение задачи" экранной формы тестового приложения (файл

TFormTaskSolve.cpp)

void __fastcall TFormTaskSolve::SolveBitBtnClick(TObject *Sender)

{

LexTabSheet->TabVisible = false; TaskResultTabSheet->TabVisible = false; TaskTextTabSheet->TabVisible = false; TaskTextMemo->Visible = false; startSolveTime = GetTickCount(); RunProgressBar->Visible = true; RunProgressBar->Position = 0; RunProgressBar->StepIt();

setTask(&tsk); // формирование постановки задачи

RunProgressBar->StepIt();

int iRet = MFSmodule(&tsk); // решение задачи RunProgressBar->StepIt();

endSolveTime = GetTickCount();

int iSolveTime = endSolveTime - startSolveTime; TimeSolveEdit->Text = iSolveTime;

if (iRet == 0) { viewResultSolveTask(); RunProgressBar->StepIt();

}

RunProgressBar->Visible = false;

}

Листинг 8. Исходный код функции формирования постановки задачи в виде экземпляра класса TTask (файл TFormTaskSolve.cpp)

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

10

М.Ф.Степанов

Соседние файлы в папке Системное программирование