 |
Блок-схема решения задачи Коши неявной схемой Адамса 3-го порядка.
|
|
|
|
Блок-схема алгоритма преобразования строки в обратную польскую запись:
Блок-схема вычисления функций:
Приложение 2
Листинг программы
Главная программа (Unit 1. cpp):
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
#include "math.h"
#include "stdio.h"
#include "Unit3.h"
#include "Unit5.h"
#include "fstream.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
char *opz(char *); // ф-ия преобразования в обратную польскую запись;
double fpr(char *str,double u, double v,double x); // обратный ход польской
int p=1,s=1,j=1,o=0; // записи;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::N5Click(TObject *Sender)
{
Form1->Close();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
Form1->Close();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::N7Click(TObject *Sender)
{
Form2->Show();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::N2Click(TObject *Sender) // очистка формы
{
Edit1->Clear();
Edit2->Clear();
Edit3->Clear();
Edit4->Clear();
Edit5->Clear();
Edit6->Clear();
Edit7->Clear();
Edit8->Clear();
Edit9->Clear();
Memo1->Clear();
Series1->Clear();
Series2->Clear();
Series3->Clear();
Series4->Clear();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
Edit1->Text="10";
Edit2->Text="1";
Edit3->Text="2";
Edit4->Text="4";
Edit5->Text="0,0001";
Edit6->Text="4";
Edit7->Text=FloatToStrF(exp(2),ffFixed,20,18);
Memo1->Text="результаты программы";
Button1->Show();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender) //обработка события нажатия кнопки «выполнить»
{
//---------------------------------------------------------------------------
|
|
|
int nx,np,k,i,n;
double a,b,e,h,d,de,z,x;
double y[2],yp[2],f[2],fm[2],fp[2],fp1[2],fp2[2];
unsigned long int time=GetTickCount();
unsigned long int time1=0;
a=StrToFloat(Edit3->Text);
b=StrToFloat(Edit4->Text);
e=StrToFloat(Edit5->Text);
nx=StrToInt(Edit1->Text);
np=StrToInt(Edit2->Text);
Memo1->Clear();
Memo1->Lines->Add("Входные данные:");
Memo1->Lines->Add("");
Memo1->Lines->Add("du/dx="+Edit8->Text+";");
Memo1->Lines->Add("dv/dx="+Edit9->Text+";");
Memo1->Lines->Add("Интервал: ["+Edit3->Text+";"+Edit4->Text+"]");
Memo1->Lines->Add("Допустимая погрешность: е="+Edit5->Text);
Memo1->Lines->Add("Начальные условия:");
Memo1->Lines->Add("u="+Edit6->Text);
Memo1->Lines->Add("v="+Edit7->Text);
Memo1->Lines->Add("Количество шагов сетки: "+Edit1->Text);
Memo1->Lines->Add("Шаг вывода: "+Edit2->Text);
Memo1->Lines->Add("");
Memo1->Lines->Add("");
char *u1 =(char *)malloc(strlen(Edit8->Text.c_str())+1);
char *v1 =(char *)malloc(strlen(Edit9->Text.c_str())+1);
strcpy(u1,Edit8->Text.c_str());
strcpy(v1,Edit9->Text.c_str());
char *u =(char *)malloc(strlen(u1)+1); //динамическое выделение памяти
char *v =(char *)malloc(strlen(v1)+1);
strcpy(u,opz(&(u1[0]))); // преобразование в обратную польскую запись
strcpy(v,opz(&(v1[0])));
do {
h=(b-a)/nx;
x=a;
y[0]=StrToFloat(Edit6->Text);
y[1]=StrToFloat(Edit7->Text);
if(np!=0&&s==0){
Memo1->Lines->Add("Результаты:");
Memo1->Lines->Add(" x | u(x) | точное | разн. | v(x) | точное | разн. | ");
Memo1->Lines->Add("-----------------------------------------------------");
Memo1->Lines->Add(FloatToStrF(x,ffFixed,5,3)+" "+FloatToStrF(y[0],ffFixed,8,4)+" "+FloatToStrF(2*x,ffFixed,8,4)+" "+FloatToStrF(y[0]-2*x,ffFixed,8,4)+" "+FloatToStrF(y[1],ffFixed,8,4)+" "+FloatToStrF(exp(x),ffFixed,8,4)+" "+FloatToStrF(y[1]-exp(x),ffFixed,8,4));
}
Series1->Clear();
Series2->Clear();
Series3->Clear();
Series4->Clear();
Series1->AddXY(x,y[0]);
Series2->AddXY(x,2*x);
Series3->AddXY(x,y[1]);
Series4->AddXY(x,exp(x));
fm[0]=fpr(u,y[0],y[1],x);
fm[1]=fpr(v,y[0],y[1],x);
for(i=0;i<2;i++)
{
yp[i]=y[i]+h/2*fm[i];
}
x=x+h/2;
fp1[0]=fpr(u,yp[0],yp[1],x);
fp1[1]=fpr(v,yp[0],yp[1],x);
for(i=0;i<2;i++)
{
yp[i]=y[i]+h/2*fp1[i];
}
fp2[0]=fpr(u,yp[0],yp[1],x);
fp2[1]=fpr(v,yp[0],yp[1],x);
for(i=0;i<2;i++)
{
yp[i]=y[i]+h*fp2[i];
}
x=x+h/2;
fp[0]=fpr(u,yp[0],yp[1],x);
fp[1]=fpr(v,yp[0],yp[1],x);
for(i=0;i<2;i++)
{
yp[i]=y[i]+h*(fm[i]+2*fp1[i]+2*fp2[i]+fp[i])/6;
}
fp[0]=fpr(u,yp[0],yp[1],x);
fp[1]=fpr(v,yp[0],yp[1],x);
for(n=2;n<=nx;n++)
{
for(i=0;i<2;i++)
{
y[i]=yp[i]+h*(1.5*fp[i]-0.5*fm[i]);
};
x=x+h;
|
|
|
f[0]=fpr(u,y[0],y[1],x);
f[1]=fpr(v,y[0],y[1],x);
k=0;
do
{
k=k+1;
de=0;
for(i=0;i<2;i++)
{
z=yp[i]+h*(5*f[i]+8*fp[i]-fm[i])/12;
d=fabs(z-y[i]);
y[i]=z;
if(d>de) de=d;
};
f[0]=fpr(u,y[0],y[1],x);
f[1]=fpr(v,y[0],y[1],x);
} while(de>e);
for(i=0;i<2;i++)
{
yp[i]=y[i];
fm[i]=fp[i];
fp[i]=f[i];
}
Series1->AddXY(x,y[0]); //вывод графиков функций
Series2->AddXY(x,2*x);
Series3->AddXY(x,y[1]);
Series4->AddXY(x,exp(x));
if((fmod(n,np)==0)&&s==0) { //вывод результатов
Memo1->Lines->Add(FloatToStrF(x,ffFixed,5,3)+" "+FloatToStrF(y[0],ffFixed,8,4)+" "+FloatToStrF(2*x,ffFixed,8,4)+" "+FloatToStrF(y[0]-2*x,ffFixed,8,4)+" "+FloatToStrF(y[1],ffFixed,8,4)+" "+FloatToStrF(exp(x),ffFixed,8,4)+" "+FloatToStrF(y[1]-exp(x),ffFixed,8,4));
p=1;
o=1;
}
else o=0;
}
nx=nx*2;
np=np*2;
time1=GetTickCount();
if (o==1) {
Memo1->Lines->Add("------------------------------------------------------");
Memo1->Lines->Add("Время выполнения:"+FloatToStrF((time1-time)/1000.,ffFixed,6,3)+"мс");
}
if(CheckBox1->Checked) y[1]=exp(x);
} while(fabs(y[1]-exp(x))>e);
j++;
s=1;
if(p==1&&(fmod(j,2)==0))
{
Memo1->Lines->Add("Рекомендуемое значение шага сетки:"+FloatToStrF(nx/2,ffFixed,6,0));
Edit1->Text=FloatToStrF(nx/2,ffFixed,5,0);
Edit2->Text=FloatToStrF(np/2,ffFixed,5,0);
s=0;
p=0;
}
free(u); // освобождение памяти
free(v);
free(u1);
free(v1);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::N4Click(TObject *Sender) //Сохранение в файл
{
SaveDialog1->Title="Save File";
if (SaveDialog1->Execute())
{
Memo1->Lines->SaveToFile(SaveDialog1->FileName);
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::N3Click(TObject *Sender) // Загрузка из файла функций
{
if(OpenDialog1->Execute())
{
FILE *fl;
fl=fopen(OpenDialog1->FileName.c_str(),"r");
char ch=getc(fl);
char str[30];
str[0]='\0';
int k=0;
while (ch!=EOF)
{
if(ch=='=') { k++;
while (ch!=';'){ ch=getc(fl);
int n=strlen(str);
str[n]=ch;
str[n+1]='\0';
}
switch (k)
{
case 1: Edit8->Text=str; str[0]='\0'; break;
case 2: Edit9->Text=str; break;
}
}
ch=getc(fl);
}
fclose(fl);
}
}
//---------------------------------------------------------------------------
Модуль преобразования строки в обратную польскую запись (Unit 3. cpp):
//---------------------------------------------------------------------------
#pragma hdrstop
#include "Unit3.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
struct st {
char c;struct st *next;
};
struct st *push(struct st *,char);
char DEL(struct st **);
int PRIOR(char);
char* opz(char *a)
{
struct st *OPERS=NULL;
char *outstring= new char [30]; // динамическое выделение памяти
int k,point;
k=point=0;
while((*(a+k)!='\0')&&(*(a+k)!='=')){
if(*(a+k)==')'){
while((OPERS->c)!='(')
outstring[point++]=DEL(&OPERS);
DEL(&OPERS);
}
if((*(a+k)>='a'&&(*(a+k))<='z')||(*(a+k)>='1'&&(*(a+k))<='9'))
outstring[point++]=*(a+k);
if(a[k]=='(')
OPERS=push(OPERS,'(');
if(*(a+k)=='+'||*(a+k)=='-'||*(a+k)=='/'||*(a+k)=='*'||*(a+k)=='^'){
if(OPERS==NULL)
OPERS=push(OPERS,*(a+k));
else
if(!PRIOR(OPERS->c))
|
|
|
OPERS=push(OPERS,*(a+k));
else{
while((OPERS!=NULL)&&(PRIOR(OPERS->c)>=PRIOR(*(a+k))))
outstring[point++]=DEL(&OPERS);
OPERS=push(OPERS,*(a+k));
}
}
k++;
}
while(OPERS!=NULL)
outstring[point++]=DEL(&OPERS);
outstring[point]='\0';
return outstring;
}
struct st *push(struct st *HEAD,char a) /* Функция записывает в стек,на веpшину котоpого указывает HEAD,символ a.
Возвpащает указатель на новую веpшину стека*/
{
struct st *PTR;
PTR=new st ();
PTR->c=a;
PTR->next=HEAD;
return PTR;
}
char DEL(struct st **HEAD){ /* функция удаляет символ с веpшины стека. Возвpащает удаляемый символ.
Изменяет указатель на веpшину стека*/
struct st *PTR;
char a;
if(*HEAD==NULL)
return '\0';
PTR=*HEAD;
a=PTR->c;
*HEAD=PTR->next;
free(PTR);
return a;
}
int PRIOR(char a) //функция возвpащает пpиоpитет аpифметической опеpации
{
switch(a){
case '^':
return 4;
case '*':
case '/':
return 3;
case '-':
case '+':
return 2;
case '(':
return 1;
}
}
Модуль расчёта функции, записанной в постфиксной форме (Unit 5. cpp):
//---------------------------------------------------------------------------
#pragma hdrstop
#include "Unit5.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#include<conio.h>
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
double fpr(char *str,double u, double v,double x)
{
int n,i,d=0;
double th[30],g[30];
n=strlen(str);
for (i=0;i<n;i++)
{
switch (*(str+i))
{
case 'x': *(th+i)=x; break;
case 'u': *(th+i)=u; break;
case 'v': *(th+i)=v; break;
case 'e': *(th+i)=exp(1); break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '0': char p[1]; p[0]=str[i]; th[i]=atoi(p); break;
}
}
for(i=0;i<n;i++)
{
if(*(str+i)=='x'||*(str+i)=='v'||*(str+i)=='u'||*(str+i)=='e'||*(str+i)=='1'||*(str+i)=='2'||*(str+i)=='3'||*(str+i)=='4'||*(str+i)=='5'||*(str+i)=='6'||*(str+i)=='7'||*(str+i)=='8'||*(str+i)=='9')
{
*(g+d)=*(th+i);
d++;
}
else {
switch (*(str+i))
{
case '-': *(g+d-2)=*(g+d-2)-*(g+d-1); break;
case '+': *(g+d-2)=*(g+d-2)+*(g+d-1); break;
case '/': *(g+d-2)=*(g+d-2)/(*(g+d-1)); break;
case '*': *(g+d-2)=*(g+d-2)*(*(g+d-1)); break;
case '^': *(g+d-2)=pow(*(g+d-2),*(g+d-1)); break;
};
d--;
}
}
return *g;
}
Приложение 3
Рис 1. Общий вид программы
Рис 2. Организация решения системы
Рис 3. Организация меню
|
|
|
