Исследование модели фрактального броуновского движения

2. Методические указания к организационно-экономической части дипломных проектов и работ - М.: МАИ, 1996.

3. Ширяев А.Н. Основы стохастической финансовой математики. Том 1. Факты и модели. - М.: ФАЗИС, 1998.

4. Миллер Б.М., Панков А.Р. Теория случайных процессов в примерах и задачах. - М.: ФИЗМАТЛИТ, 2002.

5. Ширяев А.Н. Вероятность.

6. Панков А.Р., Платонов Е.Н. Практикум по математической статистике. -М.: МАИ, 2006.

7. T.E. Duncan. Some Martingales from a Fractional Brownian Motion and Applications. Proceedings of the 44th IEEE Conference on Decision and Control, and the European Control Conference 2005.

8. Колмогоров А.Н. Интерполирование и экстраполирование ССП. Известия Академии наук СССР. Серия математическая. Том 5, №1. 1941.

9. Иванов В.В., Ковалев А.М., Тарасова Е.В. Методические указания к РГР по курсу «Организация, планирование и управление работой ИВЦ НПО». -М.: , 1989.

10. Методические указания к организационно-экономической части дипломных проектов и работ - М.: МАИ, 1996.

11. Бобков Н.И., Голованова Т.В. Охрана труда на ВЦ: Методические указания к дипломному проектированию. -М.: МАИ, 1995.

12. Березин В.М., Дайнов М.И. Защита от вредных производственных факторов при работе с ПЭВМ. Учебное пособие. -М.: МАИ, 2003.

Приложение

Исходный код программы (выполнено на C++ Builder 5.0):

#include <vcl.h>

#pragma hdrstop

#include "MainUnit.h"

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

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

double H = 0.8; // Параметр Харста

const int N = 1000; // Количество отрезков разбиения [-pi; pi]

const int L = 1000; // Количество слагаемых в формуле вычисления спектральной плотности

const double P = 1000000;

const int n=200;

double B[n+1];

double Bw1[n+1];

double Bw2[n+1];

double X[n+1];

double Y[n+1];

double M[n+1];

double d = 0.01;

double alpha = 1.0;

double sigma = 0.05;

int ind = 0;

int ind2 = 0;

double g0 = 1.0;

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

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

lblHurst->Caption = "H = " + AnsiString(H);

}

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

double TForm1::Cov(double x)

// Вычисление точного значения ковариационной функции

{

double res = 0.5*(pow(fabs(x+1),2*H)-2*pow(fabs(x),2*H)+pow(fabs(x-1),2*H));

return res;

}

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

double TForm1::Fspectr(double x)

// Вычисление значения оценки спектральной плотности

{

double res = cos(0)*Cov(0);

for (int i=1; i<=L; i++) {

res += 2*cos(x*i)*Cov(i);

}

res = res/(2*M_PI);

return res;

}

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

void TForm1::CanvasClear()

// Очистка области построения графиков

{

Image1->Canvas->Pen->Color = clWhite;

Image1->Canvas->Pen->Mode = pmCopy;

for (int i=0; i<Image1->Height; i++) {

Image1->Canvas->MoveTo(0,i);

Image1->Canvas->LineTo(Image1->Width-1,i);

}

}

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

void TForm1::ScaleMotion()

// Масштабирование ФБД по выборочному второму моменту

{

// Вычисление выборочного второго момента

double dev = 0;

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

dev += pow(B[j]-B[j-1],2);

}

dev = dev/n;

// ShowMessage("dev = " + AnsiString(dev));

// Вычисление коэффициента масштабирования по выборочному второму моменту

double coef = sqrt(1.0/dev);

// Масштабирование ФБД

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

B[j] = B[j]*coef;

}

}

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

void __fastcall TForm1::Button1Click(TObject *Sender)

// Построение спектральной плотности

{

Memo1->Clear();

CanvasClear();

// Отрисовка осей координат

Image1->Canvas->Pen->Color = clSilver;

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(505,250);

Image1->Canvas->LineTo(505,255);

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(5,255);

Image1->Canvas->MoveTo(255,300);

Image1->Canvas->LineTo(255,5);

Image1->Canvas->MoveTo(255,50);

Image1->Canvas->LineTo(250,50);

Image1->Canvas->Pen->Color = clBlack;

double lambda[N+1];

double f[N+1];

for (int i=0; i<=N; i++) {

lambda[i] = -M_PI + (2*M_PI/N)*i;

f[i] = Fspectr(lambda[i]);

}

// Построение графика спектральной плотности

int c = 200;

Image1->Canvas->MoveTo(5,250-floor(f[0]*c));

Memo1->Lines->Add(AnsiString(f[0]));

for (int i=1; i<=N; i++) {

Image1->Canvas->LineTo(5+i*(500.0/N),250-floor(f[i]*c));

Memo1->Lines->Add(AnsiString(Fspectr(lambda[i])));

}

}

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

void __fastcall TForm1::Button2Click(TObject *Sender)

// Моделирование ФБД

{

Memo1->Clear();

CanvasClear();

double lambda[N+1];

double f[N+1];

double Vk[N+1];

double beta[n+1];

AnsiString buf;

// Считывание значений Lambda[k] для данного N и параметра Харста H

for (int i=0; i<=N; i++) {

buf = Memo2->Lines->Strings[i];

lambda[i] = StrToFloat(buf);

}

// Генерирование случайных величин V[k]

randomize();

for (int i=0; i<=N; i++) {

Vk[i] = RandG(0,1)/sqrt(N);

}

// Вычисление реализаций ФГШ

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

beta[i]=0;

for (int j=1; j<=N; j++) {

beta[i] += cos(lambda[j]*i)*Vk[j];

}

}

// Вычисление значений ФБД

B[0] = 0;

Memo1->Lines->Add(AnsiString(B[0]));

for (int i=1; i<=n; i++) {

B[i] = B[i-1] + beta[i-1];

Memo1->Lines->Add(AnsiString(B[i]));

}

//ScaleMotion();

// Вычисление масштаба шкалы значений ФБД

double maxb = 0;

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

if (maxb < fabs(B[i])) {

maxb = fabs(B[i]);

}

}

int scale = floor(250/maxb);

if (scale > 249 ) {

scale = 249;

}

// Отрисовка осей координат

Image1->Canvas->Pen->Color = clSilver;

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(405,250);

Image1->Canvas->MoveTo(405,250);

Image1->Canvas->LineTo(405,255);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(5,250+scale);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(10,250-scale);

Image1->Canvas->MoveTo(5,250+scale);

Image1->Canvas->LineTo(10,250+scale);

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->Pen->Color = clBlack;

// Построение графика ФБД

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

Image1->Canvas->LineTo(5+i*2,250-B[i]*scale);

}

}

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

void __fastcall TForm1::btnLoadClick(TObject *Sender)

// Загрузка значений Lambda[k] из внешнего файла

{

Memo2->Clear();

char p[100];

if(OpenDialog1->Execute()){

AnsiString PathName = OpenDialog1->FileName;

using namespace std;

fstream myfile(PathName.c_str());

while (!myfile.eof()) {

myfile.getline(p,100);

Memo2->Lines->Add(AnsiString(p));

}

}

}

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

void __fastcall TForm1::btnSaveClick(TObject *Sender)

// Сохранение вычисленных значений Lambda[k] во внешний файл

{

if ( SaveDialog1->Execute() ) {

AnsiString PathName = SaveDialog1->FileName;

using namespace std;

fstream myfile(PathName.c_str());

myfile << Memo2->Text.c_str();

myfile.close();

}

}

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

void __fastcall TForm1::btnCalcClick(TObject *Sender)

// Вычисление значений Lambda[k] для заданного N и параметра Харста H

{

double lambda[N+1];

double delta = 0.00001;

lambda[0] = -M_PI;

Memo2->Lines->Add(AnsiString(lambda[0]));

double I, I2;

double x = -M_PI;

int k = 0;

I = 0;

while (x<0) {

I2 = I;

I = (x + M_PI)/(2*M_PI);

for (int i=1; i<=L; i++) {

I+= (Cov(i)*(sin(x*i)+sin(M_PI*i)))/(M_PI*i);

}

if ( (I2 < (1.0/N)*(k+1)) && (I >= (1.0/N)*(k+1)) ) {

lambda[k+1] = x;

k++;

Memo2->Lines->Add(AnsiString(x));

}

x += delta;

}

lambda[N/2] = 0;

Memo2->Lines->Add(AnsiString(lambda[N/2]));

for (int i=1; i<=N/2; i++) {

lambda[N/2+i] = fabs(lambda[N/2-i]);

Memo2->Lines->Add(AnsiString(lambda[N/2+i]));

}

}

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

void __fastcall TForm1::btnHurstClick(TObject *Sender)

// Изменение значения параметра Харста

{

H = StrToFloat(editHurst->Text);

lblHurst->Caption = "H = " + AnsiString(H);

Memo2->Clear();

}

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

void __fastcall TForm1::btnCovClick(TObject *Sender)

// Построение оценки ковариационной функции

{

CanvasClear();

const int nn = 21; // количество вычисляемых значений

// Вычисление точного значения ковариационной функции

double Cv[nn];

for (int i=0; i<nn; i++) {

Cv[i] = Cov(i);

}

// Построение массива реализаций ФГШ

double beta[n];

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

beta[i] = B[i+1]-B[i];

}

Memo1->Lines->Add(" ");

Memo1->Lines->Add("cov = ");

// Вычисление оценки ковариационной функции по реализациям ФГШ

double Cv2[nn];

for (int i=0; i<nn; i++) {

Cv2[i] = 0;

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

Cv2[i] += beta[i+j]*beta[j];

}

Cv2[i] = Cv2[i]/(n-i);

Memo1->Lines->Add(FloatToStr(Cv2[i]));

}

// Вычисление масштаба шкалы значений ковариационной функции

double maxb = 0;

for (int i=0; i<nn-1; i++) {

if (maxb < fabs(Cv2[i])) {

maxb = fabs(Cv2[i]);

}

}

int scale = ceil(250/maxb);

if (scale > 249 ) {

scale = 249;

}

// Отрисовка осей координат

Image1->Canvas->Pen->Color = clSilver;

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(5+10*(nn-1),250);

Image1->Canvas->LineTo(5+10*(nn-1),255);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(5,250+scale);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(10,250-scale);

Image1->Canvas->MoveTo(5,250+scale);

Image1->Canvas->LineTo(10,250+scale);

Image1->Canvas->Pen->Color = clBlack;

// Построение графика точного значения ковариационной функции

Image1->Canvas->MoveTo(5,250-scale*Cv[0]);

for (int i=1; i<nn; i++) {

Image1->Canvas->LineTo(5+i*10,250-scale*Cv[i]);

}

// Построение графика оценки ковариационной функции

Image1->Canvas->Pen->Color = clRed;

Image1->Canvas->MoveTo(5,250-scale*Cv2[0]);

for (int i=1; i<nn; i++) {

Image1->Canvas->LineTo(5+i*10,250-scale*Cv2[i]);

}

double He = 0.5*log(Cv2[1]+1.0)/log(2) + 0.5;

Label2->Caption = "[H] = "+AnsiString(floor(He*10000.0)/10000.0);

}

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

void __fastcall TForm1::btnLoadSignalClick(TObject *Sender)

// Загрузка сигнала, построенного в Matlab

{

Memo1->Clear();

CanvasClear();

// Считывание значений из внешнего файла

char p[100];

int i = 0;

if(OpenDialog1->Execute()){

AnsiString PathName = OpenDialog1->FileName;

using namespace std;

fstream myfile(PathName.c_str());

while (!myfile.eof()) {

myfile.getline(p,100);

Memo1->Lines->Add(AnsiString(p));

B[i] = StrToFloat(AnsiString(p));

i++;

}

}

ScaleMotion();

// Вычисление масштаба шкалы значений ФБД

double maxb = 0;

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

if (maxb < fabs(B[i])) {

maxb = fabs(B[i]);

}

}

int scale = floor(250/maxb);

if (scale > 249 ) {

scale = 249;

}

// Отрисовка осей координат

Image1->Canvas->Pen->Color = clSilver;

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(505,250);

Image1->Canvas->MoveTo(505,250);

Image1->Canvas->LineTo(505,255);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(5,250+scale);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(10,250-scale);

Image1->Canvas->MoveTo(5,250+scale);

Image1->Canvas->LineTo(10,250+scale);

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->Pen->Color = clBlack;

// Построение ФБД

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

Image1->Canvas->LineTo(5+i,250-B[i]*scale);

}

}

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

void __fastcall TForm1::btnBMClick(TObject *Sender)

// Построение стандартного броуновского движения

{

Memo1->Clear();

CanvasClear();

double f[N+1];

double beta[n+1];

randomize();

beta[0] = 0;

for (int i=1; i<=n; i++) {

beta[i]=RandG(0,1);

}

B[0] = 0;

Memo1->Lines->Add(AnsiString(B[0]));

for (int i=1; i<=n; i++) {

B[i] = B[i-1] + beta[i];

Memo1->Lines->Add(AnsiString(B[i]));

}

double maxb = 0;

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

if (maxb < fabs(B[i])) {

maxb = fabs(B[i]);

}

}

int scale = floor(250/maxb);

if (scale > 249 ) {

scale = 249;

}

Image1->Canvas->Pen->Color = clSilver;

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(505,250);

Image1->Canvas->MoveTo(505,250);

Image1->Canvas->LineTo(505,255);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(5,250+scale);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(10,250-scale);

Image1->Canvas->MoveTo(5,250+scale);

Image1->Canvas->LineTo(10,250+scale);

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->Pen->Color = clBlack;

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

Image1->Canvas->LineTo(5+i*2,250-B[i]*scale);

}

}

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

void __fastcall TForm1::btnBetaClick(TObject *Sender)

// Построение функции beta при неслучайных V[k]

// Просто для наблюдения за ее структурой

{

Memo1->Clear();

CanvasClear();

double lambda[N+1];

double f[N+1];

double beta[n+1];

AnsiString buf;

for (int i=0; i<=N; i++) {

buf = Memo2->Lines->Strings[i];

lambda[i] = StrToFloat(buf);

}

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

beta[i]=0;

for (int j=1; j<=N; j++) {

beta[i] += cos(lambda[j]*i)*(1.0/N);

}

}

double maxb = 0;

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

if (maxb < fabs(beta[i])) {

maxb = fabs(beta[i]);

}

}

int scale = floor(250/maxb);

if (scale > 249 ) {

scale = 249;

}

Image1->Canvas->Pen->Color = clSilver;

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(505,250);

Image1->Canvas->MoveTo(505,250);

Image1->Canvas->LineTo(505,255);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(5,250+scale);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(10,250-scale);

Image1->Canvas->MoveTo(5,250+scale);

Image1->Canvas->LineTo(10,250+scale);

Image1->Canvas->MoveTo(5,250-beta[0]*scale);

Image1->Canvas->Pen->Color = clBlack;

for (int i=1; i<n; i++) {

Image1->Canvas->LineTo(5+i,250-beta[i]*scale);

}

}

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

void __fastcall TForm1::btnSolveClick(TObject *Sender)

// Решение диффура

{

CanvasClear();

randomize();

X[0] = RandG(0,g0);

Y[0] = 0;

// Моделирование ФБД

double mu[N/2+1];

double Ak1[N/2+1];

double Bk1[N/2+1];

double Ak2[N/2+1];

double Bk2[N/2+1];

double beta1[n+1];

double beta2[n+1];

AnsiString buf;

// Считывание значений Mu[k] для данного N и параметра Харста H

for (int i=0; i<=N/2; i++) {

buf = Memo2->Lines->Strings[i];

mu[i] = StrToFloat(buf);

}

// Генерирование случайных величин V[k]

for (int i=0; i<=N/2; i++) {

Ak1[i] = RandG(0,1)/sqrt(N);

Bk1[i] = RandG(0,1)/sqrt(N);

Ak2[i] = RandG(0,1)/sqrt(N);

Bk2[i] = RandG(0,1)/sqrt(N);

}

// Вычисление реализаций ФГШ

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

beta1[i]=0;

beta2[i]=0;

for (int j=1; j<=N/2; j++) {

beta1[i] += cos(mu[j]*i)*Ak1[j] + sin(mu[j]*i)*Bk1[j];

beta2[i] += cos(mu[j]*i)*Ak2[j] + sin(mu[j]*i)*Bk2[j];

}

}

// Масштабирование beta1

double dev = 0;

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

dev += pow(beta1[j],2);

}

dev = dev/n;

double coef = sqrt(1.0/dev);

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

beta1[j] = beta1[j]*coef;

}

// Масштабирование beta2

dev = 0;

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

dev += pow(beta2[j],2);

}

dev = dev/n;

coef = sqrt(1.0/dev);

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

beta2[j] = beta2[j]*coef;

}

// Решение системы диффуров с помощью конечных разностей

for (int i=1; i<=n; i++) {

X[i] = X[i-1]*(1.0-alpha*d) + beta1[i]*pow(d,H);

Y[i] = Y[i-1] + X[i-1]*d + sigma*beta2[i]*pow(d,H);

}

M[0] = 0;

double bbeta = sqrt(pow(alpha,2)+1/pow(sigma,2));

for (int i=1; i<=n; i++) {

M[i] = M[i-1]*(1.0-bbeta*d) + (bbeta-alpha)*(Y[i]-Y[i-1]);

}

// Вычисление масштаба шкалы значений функций

double maxb = 0;

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

if (maxb < fabs(X[i])) {

maxb = fabs(X[i]);

}

if (maxb < fabs(Y[i])) {

maxb = fabs(Y[i]);

}

if (maxb < fabs(M[i])) {

maxb = fabs(M[i]);

}

}

int scale = floor(250/maxb);

if (scale > 249 ) {

scale = 249;

}

Image1->Canvas->Pen->Color = clSilver;

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(405,250);

Image1->Canvas->MoveTo(405,250);

Image1->Canvas->LineTo(405,255);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(5,250+scale);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(10,250-scale);

Image1->Canvas->MoveTo(5,250+scale);

Image1->Canvas->LineTo(10,250+scale);

Image1->Canvas->MoveTo(5,250-Y[0]*scale);

Image1->Canvas->Pen->Color = clBlue;

for (int i=1; i<=n; i++) {

Image1->Canvas->LineTo(5+i*2,250-Y[i]*scale);

}

Image1->Canvas->MoveTo(5,250-X[0]*scale);

Image1->Canvas->Pen->Color = clBlack;

for (int i=1; i<=n; i++) {

Image1->Canvas->LineTo(5+i*2,250-X[i]*scale);

}

Image1->Canvas->MoveTo(5,250-M[0]*scale);

Image1->Canvas->Pen->Color = clRed;

for (int i=1; i<=n; i++) {

Image1->Canvas->LineTo(5+i*2,250-M[i]*scale);

}

}

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

void __fastcall TForm1::btnShowClick(TObject *Sender)

{

CanvasClear();

// Вычисление масштаба шкалы значений ФБД

double maxb = 0;

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

if (maxb < fabs(B[i])) {

maxb = fabs(B[i]);

}

}

int scale = floor(250/maxb);

if (scale > 249 ) {

scale = 249;

}

// Отрисовка осей координат

Image1->Canvas->Pen->Color = clSilver;

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(405,250);

Image1->Canvas->MoveTo(405,250);

Image1->Canvas->LineTo(405,255);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(5,250+scale);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(10,250-scale);

Image1->Canvas->MoveTo(5,250+scale);

Image1->Canvas->LineTo(10,250+scale);

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->Pen->Color = clBlack;

// Построение графика ФБД

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

Image1->Canvas->LineTo(5+i*2,250-B[i]*scale);

}

}

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

void __fastcall TForm1::btnFBM2Click(TObject *Sender)

// Моделирование ФБД (альтернативный вариант)

{

Memo1->Clear();

CanvasClear();

double mu[N/2+1];

double Ak[N/2+1];

double Bk[N/2+1];

double beta[n+1];

AnsiString buf;

// Считывание значений Mu[k] для данного N и параметра Харста H

for (int i=0; i<=N/2; i++) {

buf = Memo2->Lines->Strings[i];

mu[i] = StrToFloat(buf);

}

// Генерирование случайных величин V[k]

randomize();

for (int i=0; i<=N/2; i++) {

Ak[i] = sqrt(2.0)*RandG(0,1)/sqrt(N);

Bk[i] = sqrt(2.0)*RandG(0,1)/sqrt(N);

}

// Вычисление реализаций ФГШ

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

beta[i]=0;

for (int j=1; j<=N/2; j++) {

beta[i] += cos(mu[j]*i)*Ak[j] + sin(mu[j]*i)*Bk[j];

}

}

// Вычисление значений ФБД

B[0] = 0;

Memo1->Lines->Add(AnsiString(B[0]));

for (int i=1; i<=n; i++) {

B[i] = B[i-1] + beta[i-1];

Memo1->Lines->Add(AnsiString(i)+" : "+AnsiString(B[i]));

}

//ScaleMotion();

// Вычисление масштаба шкалы значений ФБД

double maxb = 0;

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

if (maxb < fabs(B[i])) {

maxb = fabs(B[i]);

}

}

int scale = floor(250/maxb);

if (scale > 249 ) {

scale = 249;

}

// Отрисовка осей координат

Image1->Canvas->Pen->Color = clSilver;

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(405,250);

Image1->Canvas->MoveTo(405,250);

Image1->Canvas->LineTo(405,255);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(5,250+scale);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(10,250-scale);

Image1->Canvas->MoveTo(5,250+scale);

Image1->Canvas->LineTo(10,250+scale);

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->Pen->Color = clBlack;

// Построение графика ФБД

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

Image1->Canvas->LineTo(5+i*2,250-B[i]*scale);

}

}

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

void __fastcall TForm1::btnErrClick(TObject *Sender)

{

double maxb;

int scale;

Memo1->Clear();

CanvasClear();

if (ind2 == 0) {

double eps[n+1];

double maxe=0;

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

eps[i] = X[i] - M[i];

if (i>10) {

if (fabs(eps[i]) > maxe) {

maxe = fabs(eps[i]);

}

}

}

// Вычисление масштаба шкалы значений функций

maxb = 0;

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

if (maxb < fabs(eps[i])) {

maxb = fabs(eps[i]);

}

}

scale = floor(250/maxb);

if (scale > 249 ) {

scale = 249;

}

Image1->Canvas->Pen->Color = clSilver;

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(405,250);

Image1->Canvas->MoveTo(405,250);

Image1->Canvas->LineTo(405,255);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(5,250+scale);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(10,250-scale);

Image1->Canvas->MoveTo(5,250+scale);

Image1->Canvas->LineTo(10,250+scale);

Image1->Canvas->Pen->Color = clRed;

Image1->Canvas->MoveTo(5,250-maxe*scale);

Image1->Canvas->LineTo(405,250-maxe*scale);

Image1->Canvas->MoveTo(5,250+maxe*scale);

Image1->Canvas->LineTo(405,250+maxe*scale);

Image1->Canvas->MoveTo(5,250-eps[0]*scale);

Image1->Canvas->Pen->Color = clBlack;

for (int i=1; i<=n; i++) {

Image1->Canvas->LineTo(5+i*2,250-eps[i]*scale);

}

ind2 = 1;

ShowMessage("maxe = "+AnsiString(maxe));

}

else {

maxb = 0;

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

if (maxb < fabs(X[i])) {

maxb = fabs(X[i]);

}

if (maxb < fabs(Y[i])) {

maxb = fabs(Y[i]);

}

if (maxb < fabs(M[i])) {

maxb = fabs(M[i]);

}

}

scale = floor(250/maxb);

if (scale > 249 ) {

scale = 249;

}

Image1->Canvas->Pen->Color = clSilver;

Image1->Canvas->MoveTo(5,250);

Image1->Canvas->LineTo(405,250);

Image1->Canvas->MoveTo(405,250);

Image1->Canvas->LineTo(405,255);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(5,250+scale);

Image1->Canvas->MoveTo(5,250-scale);

Image1->Canvas->LineTo(10,250-scale);

Image1->Canvas->MoveTo(5,250+scale);

Image1->Canvas->LineTo(10,250+scale);

Image1->Canvas->MoveTo(5,250-Y[0]*scale);

Image1->Canvas->Pen->Color = clBlue;

for (int i=1; i<=n; i++) {

Image1->Canvas->LineTo(5+i*2,250-Y[i]*scale);

}

Image1->Canvas->MoveTo(5,250-X[0]*scale);

Image1->Canvas->Pen->Color = clBlack;

for (int i=1; i<=n; i++) {

Image1->Canvas->LineTo(5+i*2,250-X[i]*scale);

}

Image1->Canvas->MoveTo(5,250-M[0]*scale);

Image1->Canvas->Pen->Color = clRed;

for (int i=1; i<=n; i++) {

Image1->Canvas->LineTo(5+i*2,250-M[i]*scale);

}

ind2=0;

}

}

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

Размещено на Allbest.ru