Разработка программы на языке C++

Тип работы:
Курсовая
Предмет:
Программирование


Узнать стоимость

Детальная информация о работе

Выдержка из работы

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

Федеральное государственное бюджетное образовательное

учреждение высшего профессионального образования

«Комсомольский-на-Амуре государственный технический университет»

Факультет электротехнический

Кафедра «Теоретические основы электротехники»

ПОЯСНИТЕЛЬНАЯ ЗАПИСКА

к курсовому проекту

по дисциплине «Программирование и основы алгоритмизации»

Разработка программы на языке C++

Студент группы 9ИНб-1 М. А. Путинцева

Преподаватель А. В. Купова

Нормоконтролер А. В. Купова

2011

Содержание

Введение

1. Задание

2. С++ Builder что это?

3. Численные методы

4. Разработка программы на языке C++

Заключение

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

Приложение, А Программа на языке C++

Приложение Б Блок-схемы метода Рунге-Кутта 4 порядка для решения ОДУ

Введение

Программирование — это процесс создания (написания) программ для компьютера. На самом деле программы можно писать не только для компьютера, но и для других устройств, у которых есть микропроцессорное устройство, способное производить математические вычисления (сложение, вычитание, умножение, деление и т. д.) и выполнять логические операции (если выполняется какое-либо условие, то делаем это (набор действий), иначе делаем то (набор альтернативных действий)).

Программирование основывается на специальных алгоритмических языках, с помощью которых и задаются инструкции компьютеру (вернее, его процессору), законченный набор которых называется программой. Алгоритмических языков в данное время имеется большое множество, каждый из которых служит для решения своих задач. В то же время есть и языки общего назначения, на которых пишется большое количество современных приложений для компьютера. К этим языкам можно отнести такие, как C++, Java, C#, Delphi и другие.

Программы, которые мы пишем на алгоритмических языках, непосредственно не понятны компьютеру (процессору), т.к. на самом низком уровне он может воспринимать и понимать лишь два числа: ноль и единицу. Иными словами, процессор оперирует лишь значениями и командами в двоичном коде (а двоичный код, как вы знаете, состоит из нулей и единиц). Для того чтобы текст составленной программы смог выполняться компьютером, его нужно преобразовать к понятному компьютеру формату. Для этой цели служат, так называемые трансляторы, у которых в свою очередь есть тоже две разновидности: компиляторы и интерпретаторы. Разница между ними в том, что компиляторы полностью преобразуют код к формату, понятному компьютеру, а затем уже он выполняется. Интерпретаторы построчно преобразуют код к понятному компьютеру формату, которые он так же построчно и выполняет. Вторым способом выполнение программы будет происходить несколько медленнее, нежели первым. В то же время программы, написанные на интерпретируемых языках программирования, могут быть легко перенесены в другую программную среду. К примеру, могут выполняться как на компьютерах, так и на смартфонах. Все вы, наверное, слышали о java-приложениях, которые могут работать в разных средах, за счет того, что java является интерпретируемым языком и выполняется специальной джава-машиной.

1. Задание

программирование язык си дифференциальное уравнение

Разработать программу на языке С++, в которой реализовано:

1) решение дифференциального уравнения с начальными условиями на интервале.

2) аппроксимация полученного решения параболой методом наименьших квадратов.

3) расчет погрешности аппроксимации.

4) построение графиков решения дифференциального уравнения, аппроксимирующей функции и погрешности аппроксимации.

Программа должна сопровождаться понятным пользователю интерфейсом.

Исходные данные

Вариант: 2

Выражение:

Начальные условия: 0,6

Интервал:

Шаг: 0,1

2. C++ Builder — что это?

Интерес к программированию постоянно растет. Это связано с развитием и внедрением в повседневную жизнь информационных технологий. Если человек имеет дело с компьютером, то рано или поздно у него возникает желание, а иногда и необходимость, научиться программировать. Среди пользователей персональных компьютеров в настоящее время наиболее популярна операционная система Windows, и естественно, что тот, кто хочет программировать, хочет и писать программы, которые будут работать в Windows.

Несколько лет назад рядовому программисту оставалось только мечтать о создании своих собственных программ, работающих в Windows. Единственным средством разработки был Borland C++ for Windows, явно ориентированный на профессионалов, обладающих серьезными знаниями и опытом. Бурное развитие вычислительной техники, потребность в эффективных средствах разработки программного обеспечения привели к появлению на рынке целого ряда систем программирования, ориентированных на так называемую «быструю разработку», среди которых особо следует отметить Microsoft Visual Basic и Borland Delphi. В основе систем быстрой разработки (RAD-систем, Rapid Application Development -- среда быстрой разработки приложений) лежит технология визуального проектирования и событийного программирования, суть которой заключается в том, что среда разработки берет на себя большую часть работы по генерации кода программы, оставляя программисту работу по конструированию диалоговых окон и написанию функций обработки событий. Производительность программиста при использовании RAD систем фантастическая!

Успех и популярность Delphi вызвал желание фирмы Borland распространить методы быстрой разработки на область профессионального программирования, что и привело к появлению Borland C++ Builder.

C++ Builder -- это среда быстрой разработки, в которой в качестве языка программирования используется язык C++ Builder (C++ Builder Language). Не вдаваясь в подробности, можно сказать, что язык C++ Builder -- это расширенный C++. Например, в C++ Builder есть строковый (AnsiString) и логический (bool) типы, которых нет в классическом C++.

В настоящее время программистам стала доступна очередная, шестая версия пакета -- Borland C++ Builder 6. Как и предыдущие версии, Borland C++ Builder 6 позволяет создавать различные программы: от простейших однооконных приложений до программ управления распределенными базами.

Borland C++ Builder может работать в среде операционных систем от Windows 98 до Windows XP. Особых требований, по современным меркам, к ресурсам компьютера пакет не предъявляет: процессор должен быть типа Pentium или Celeron (рекомендуется Pentium II 400 МГц); объем оперативной памяти должен составлять не менее 128 Мбайт (рекомендуется 256 Мбайт) и свободное дисковое пространство должно быть достаточным (для полной установки версии Enterprise необходимо приблизительно 750 Мбайт).

3. Численные методы

Вычислительная математика -- раздел математики, включающий круг вопросов, связанных с производством вычислений и использованием компьютеров. В более узком понимании вычислительная математика -- теория численных методов решения типовых математических задач.

К задачам вычислительной математики относят:

решение систем линейных уравнений

нахождение собственных значений и векторов матрицы

нахождение сингулярных значений и векторов матрицы

решение нелинейных алгебраических уравнений

решение систем нелинейных алгебраических уравнений

решение дифференциальных уравнений (как обыкновенных дифференциальных уравнений, так и уравнений с частными производными)

решение систем дифференциальных уравнений

решение интегральных уравнений

задачи аппроксимации

задачи интерполяции

задачи экстраполяции

задачи численной оптимизации

Основное отличие вычислительной математики заключается в том, что при решении вычислительных задач человек оперирует машинными числами, которые являются дискретной проекцией вещественных чисел на конкретную архитектуру компьютера. Так, например если взять машинное число длиной в 8 байт, то в нём можно запомнить только 264 разных чисел, поэтому важную роль в вычислительной математике играют оценки точности алгоритмов и их устойчивость к представлениям машинных чисел в компьютере. Именно поэтому, например, для решения линейной системы алгебраических уравнений очень редко используется вычисление обратной матрицы, так как этот метод может привести к ошибочному решению в случае с сингулярной матрицей, а очень распространённый в линейной алгебре метод, основанный на вычислении определителя матрицы и её дополнения требует, гораздо больше арифметических операций, чем любой устойчивый метод решения линейной системы уравнений.

Дифференциамльное уравнемние -- уравнение, связывающее значение некоторой неизвестной функции в некоторой точке и значение её производных различных порядков в той же точке. Дифференциальное уравнение содержит в своей записи неизвестную функцию, ее производные и независимые переменные; однако не любое уравнение, содержащее производные неизвестной функции, является дифференциальным уравнением. Например, не является дифференциальным уравнением. Стоит также отметить, что дифференциальное уравнение может вообще не содержать неизвестную функцию, некоторые её производные и свободные переменные, но обязано содержать хотя бы одну из производных.

Порядок, или степень дифференциального уравнения -- наибольший порядок производных, входящих в него.

Решением (интегралом) дифференциального уравнения порядка n называется функция y (x), имеющая на некотором интервале (a, b) производные y'(x), y''(x),…, y (n)(x) до порядка n включительно и удовлетворяющая этому уравнению. Процесс решения дифференциального уравнения называется интегрированием. Вопрос об интегрировании дифференциального уравнения считается решенным, если нахождение неизвестной функции удается привести к квадратуре, независимо от того, выражается ли полученный интеграл в конечном виде или нет.

Все дифференциальные уравнения можно разделить на обыкновенные (ОДУ), в которые входят только функции (и их производные) от одного аргумента, и уравнения с частными производными (УРЧП), в которых входящие функции зависят от многих переменных. Существуют также стохастические дифференциальные уравнения (СДУ), включающие случайные процессы.

Решение систем дифференциальных уравнений

Дифференциальные уравнения, являясь подмножеством функциональных уравнений, довольно редко допускают аналитическое решение. В подобных ситуациях для их приближённого решения применяют численные методы.

Численные методы не могут дать точного решения дифференциальной задачи, но могут обеспечить некоторое приближение к такому решению.

Часто для получения такого приближения используют т. н. сеточную аппроксимацию функций. То есть вместо функций непрерывного аргумента вводят функции дискретного аргумента. А вместо дифференциальных операторов -- разностные. Будем называть параметром сетки такую величину h, что расстояние между любыми двумя соседними узлами сетки не превосходит h.

В моей программе использован метод Рунге-Кутта четвертого порядка, вот вид этого уравнения:

уi+1=уi+(k1+2k2+2k3+k4)/6,

k1=hf (xi, yi),

k2=hf (xi+h/2, yi+k½),

k3=hf (xi+h/2, yi+k2/2),

k4=hf (xi+h, yi+k3),

xi+1=xi+h,

где уi+1,уi — значения искомой функции в точках xi+1, xi соответственно, индекс i показывает номер шага интегрирования, h — шаг интегрирования. Начальные условия при численном интегрировании учитываются на нулевом шаге: i=0, x=x0, y=y0

Заключение

В ходе выполнения курсовой работы я закрепила знания работы с программой C++Builder. Благодаря уникальному сочетанию удобства разработки пользовательских интерфейсов, компонентной архитектуры, однотипности доступа к разнообразным базам данных было проще программировать.

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

1. Шилдт, Г. А. Программирование на C и C++ для Windows / Г. Шилдт — М.: BHV, 1996. -235с.

2. Петзолд, Ч. Р. Программирование для Windows / Ч. Петзолд — Санк-Петербург: BHV, 1997. -345с.

3. Страуструп, Б. В. Язык программирования Си++ / Б. Страуструп- М: Радио и связь, 1991. -468с.

4. Архангельский, В. В. Программирование в С++ Builder 6 / В. В. Архангельский — М.: Бином, 1998 г.- 560с.

5. Подбельский, В. В. Программирование на языке Си / В. В Подбельский. — М: Финансы и статистика, 2002. — 600с.

Разработка программы на языке C++

Содержимое файла Unit1. h

//файл Unit1. h

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

#ifndef Unit1H

#define Unit1H

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

#include < Classes. hpp>

#include < Controls. hpp>

#include < StdCtrls. hpp>

#include < Forms. hpp>

#include < ExtCtrls. hpp>

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

classTForm1: publicTForm//Создание нового класса формы

{

__published: // Органы управления

TMemo *Screen; //Поле вывода данных

TButton *Solve; //Кнопкарешить

TButton *approx; //Кнопка аппроксимировать

TButton *CalcDy; //Кнопка рассчитать погрешность

TButton *Draw; //Кнопка построить график

TGroupBox *Draws;

TRadioButton *Solution; //Кнопки выбора типа графика

TRadioButton *AppFunc;

TRadioButton *Mistake;

TGroupBox *Operation;

TButton *Clear; //Кнопка отчистить

TTimer *Timer1; //Таймер

void __fastcall FormCreate (TObject *Sender);

void __fastcall SolveClick (TObject *Sender);

void __fastcall approxClick (TObject *Sender);

void __fastcall ClearClick (TObject *Sender);

void __fastcall CalcDyClick (TObject *Sender);

void __fastcall SolutionClick (TObject *Sender);

void __fastcall AppFuncClick (TObject *Sender);

void __fastcall MistakeClick (TObject *Sender);

void __fastcall FormShow (TObject *Sender);

void __fastcall Timer1Timer (TObject *Sender);

void __fastcall DrawClick (TObject *Sender);

private: // User declarations

public: // User declarations

__fastcall TForm1(TComponent* Owner);

};

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

extern PACKAGE TForm1 *Form1;

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

#endif

Содержимое файла Unit1. cpp

//ФайлUnit1. cpp

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

#include < vcl. h>

#pragma hdrstop

#include «Unit1. h»

#include «Unit2. cpp»

#include < math. h>

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

#pragma package (smart_init)

#pragma resource «*. dfm»

TForm1 *Form1;

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

//Описание глобальных переменных

#defineNONE 0 //Не требуется построения графика

#defineSOL 1 //График решения

#defineAPR 2 //График аппроксимирующей функции

#defineMIS 3 //График погрешности

intx_c=30,y_c=170; //Начало координат

double x0 = 0. 5; //Интервал

double xk = 1. 5;

double y0 = 0. 6; //Начальное условие

double h = 0. 1; //Шаг

double h_half = h/2. 0; //Полушаг

intn = 2+(xk-x0)/h; //Количество узлов сетки

intg_type=NONE; //Вид графика для построения

double *knots; //Узлы сетки

double *knots_half; //Узлы сетки

double *solutions; //Значения решений

double *solutions_half; //Значения решений c полушагом

double *approxim; //Значения апроксимир. функции

double *correct; //Уточнённое решение

double *errors; //Значения поправок

double *approxim_correct; //Значения аппроксим. с поправкой

doubleA[3][4]; //Система уравнений для поиска коэф. апр. функции

double Parab[3]={0,0,0}; //Коэффициенты аппроксимирующей функции

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

//Прототипы функций

doubleMy (double, double); //Функция в правой части диф. уравнения

double ApproxFunc (double); //Аппроксимирующая функция

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

__fastcall TForm1: :TForm1(TComponent* Owner)

: TForm (Owner)

{

}

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

void __fastcall TForm1: :FormCreate (TObject *Sender)

{

solutions = newdouble [n]; //Выделение памяти под массивы значений

approxim = new double [n];

errors = new double [n];

knots = new double [n];

knots_half = new double [n*2];

correct = new double [n];

approxim_correct = new double [n];

solutions_half= new double [n*2];

for (int i=0; i< n; i++) knots[i]=x0+i*h; //Вычисление узлов сетки

//Вычисление узлов сетки с полушагом

for (int i=0; i< 2*n; i++) knots_half[i]=x0+i*h_half;

}

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

void __fastcall TForm1: :SolveClick (TObject *Sender)

{

int i;

double k1, k2,k3,k4;

solutions[0]=y0; //Начальное условие

solutions_half[0]=y0;

approx-> Enabled=true; //Разрешение ранее недоступных объектов управления

Solution-> Enabled=true;

//Вычисления методом Рунге-Кутта 4 порядка

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

{

k1=My (knots[i], solutions[i]);

k2=My (knots[i]+h/2. 0, solutions[i]+h/2. 0*k1);

k3=My (knots[i]+h/2. 0, solutions[i]+h/2. 0*k2);

k4=My (knots[i]+h, solutions[i]+h*k3);

solutions[i+1]=solutions[i]+h/6*(k1*+2*k2+2*k3+k4);

}

//Вычисления методом Рунге-Кутта 4 порядка с полушагом

for (i=0; i< 2*n-1; i++)

{

k1=My (knots_half[i], solutions_half[i]);

k2=My (knots_half[i]+h_half/2. 0, solutions_half[i]+h_half/2. 0*k1);

k3=My (knots_half[i]+h_half/2. 0, solutions_half[i]+h_half/2. 0*k2);

k4=My (knots_half[i]+h_half, solutions_half[i]+h_half*k3);

solutions_half[i+1]=solutions_half[i]+h_half/6*(k1*+2*k2+2*k3+k4);

}

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

Screen-> Lines->Add («Решение диф. уравнения»);

Screen-> Lines->Add («-------------------------------------------------------------------»);

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

Screen-> Lines->Add («x = «+ AnsiString (knots[i]) +

«t f (x, y) = «+ AnsiString (solutions[i]));

Screen-> Lines->Add («-------------------------------------------------------------------»);

//Вывод решения с полушагом на экран

Screen-> Lines->Add («Решение диф. уравнения c полушагом»);

Screen-> Lines->Add («-------------------------------------------------------------------»);

for (i=0; i< 2*n; i++)

Screen-> Lines->Add («x = «+ AnsiString (knots_half[i]) +

«t f (x, y) = «+ AnsiString (solutions_half[i]));

Screen-> Lines->Add («-------------------------------------------------------------------»);

}

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

void __fastcall TForm1: :approxClick (TObject *Sender)

{

double cur=0;

int i, j, k, p, q;

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

//Согласно методу наименьших квадратов

// a11 a12 a13 | b1

// a21 a22 a23 | b2

// a31 a32 a33 | b3

double tmp=0;

doublematrix[3][4];

CalcDy-> Enabled=true; //Разрешение ранее недоступных органов управления

AppFunc-> Enabled=true;

for (i=0; i< n;i++) tmp+=pow ((x0+i*h), 4); //a11

matrix[0][0]=tmp;

tmp=0;

for (i=0; i< n;i++) tmp+=pow ((x0+i*h), 3); //a12=a21

matrix[0][1]=tmp;

matrix[1][0]=tmp;

tmp=0;

for (i=0; i< n;i++) tmp+=pow ((x0+i*h), 2); //a13=a22=a31

matrix[0][2]=tmp;

matrix[1][1]=tmp;

matrix[2][0]=tmp;

tmp=0;

for (i=0; i< n;i++) tmp+=(x0+i*h); //a23=a32

matrix[1][2]=tmp;

matrix[2][1]=tmp;

tmp=0;

matrix[2][2]=n+1; //a33

tmp=0;

for (i=0; i< n;i++) tmp+=solutions[i]*pow ((x0+i*h), 2); //b1

matrix[0][3]=tmp;

tmp=0;

for (i=0; i< n;i++) tmp+=solutions[i]*(x0+i*h); //b2

matrix[1][3]=tmp;

tmp=0;

for (i=0; i< n;i++) tmp+=solutions[i]; //b3

//Нахождение коэффициентов параболы

matrix[2][3]=tmp;

tmp=0;

i=0; j=0;

q=3;

p=q+1;

for (j = 0; j< q; j++) //Выбираем ведущий элемент, не равный нулю

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

{

k = j;

while ((matrix[k+1][j] == 0) & & (k < q))

k++;

if (matrix[k+1][j] ≠ 0)

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

{

cur = matrix[j][i];

matrix[j][i] = matrix[k+1][i];

matrix[k+1][i] = cur;

}

elsebreak;

}

for (k = 0; k < q — 1; k++)

for (j = k + 1; j < q; j++)

{

if (matrix[k][k] ≠0)

{

cur = matrix[j][k] / matrix[k][k]; //Получаем нули в текущей строке

for (i = 0; i < q + 1; i++)

matrix[j][i] = matrix[k][i] * cur — matrix[j][i];

}

elsebreak;

}

//Матрица приведена к треугольному виду, начинаем обратный ход

for (j = q — 1; j >= 0; j--)

{

cur = matrix[j][q];

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

cur= cur — matrix[j][i] * Parab[i];

Parab[j] = cur / matrix[j][j]; //Вычисляем коэффициенты

}

//Выводим коэффициенты на экран

Screen-> Lines->Add («Коэффициенты апроксимирующей функции»);

Screen-> Lines->Add («-------------------------------------------------------------------»);

Screen-> Lines->Add («a = «+ AnsiString (Parab[0]));

Screen-> Lines->Add («b = «+ AnsiString (Parab[1]));

Screen-> Lines->Add («c = «+ AnsiString (Parab[2]));

Screen-> Lines->Add («-------------------------------------------------------------------»);

//Расчёт через аппроксимирующую функцию с выводом на экран

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

{

approxim[i]=ApproxFunc (knots[i]);

Screen-> Lines->Add («x = «+ AnsiString (knots[i]) +

«t f (x, y) = «+ AnsiString (approxim[i]));

}

Screen-> Lines->Add («-------------------------------------------------------------------»);

}

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

void __fastcall TForm1: :ClearClick (TObject *Sender)

{

//Очистка рабочей области

int i=Screen-> Lines->Count;

g_type=NONE;

while (i> =1)//Очищаем поле вывода

{

Screen-> Lines->Delete (0);

i=Screen-> Lines->Count;

}

Solution-> Enabled=false;//Запрещаем органы управления

AppFunc-> Enabled=false;

Mistake-> Enabled=false;

approx-> Enabled=false;

CalcDy-> Enabled=false;

Form2-> Invalidate ();//Очищаем окно отображения графика

}

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

void __fastcall TForm1: :CalcDyClick (TObject *Sender)

{

//Вычисление погрешности методом Рунге-Ромберга

inti;

Mistake-> Enabled=true;

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

{

correct[i]=solutions[i]+(solutions[i]-solutions_half[i*2])/(pow (0. 5,4. 0)-1);

errors[i]=correct[i]-approxim[i];

approxim_correct[i]=approxim[i]+errors[i];

}

//Вывод результатов вычисления погрешности

Screen-> Lines->Add («Рассчёт погрешности аппроксимации и корректировка значений»);

Screen-> Lines->Add («-------------------------------------------------------------------»);

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

{

Screen-> Lines->Add («x = «+AnsiString (knots[i]) +

":t Поправка: «+ AnsiString (errors[i])+"t Значение: «+

AnsiString (approxim_correct[i]));

}

Screen-> Lines->Add («-------------------------------------------------------------------»);

}

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

void __fastcall TForm1: :SolutionClick (TObject *Sender)

{

//Выбор графика решения

Form2-> Invalidate ();

g_type=NONE;

DrawClick (Sender);

g_type=SOL;

}

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

void __fastcall TForm1: :AppFuncClick (TObject *Sender)

{

//Выбор графика апроксимации

Form2-> Invalidate ();

g_type=NONE;

DrawClick (Sender);

g_type=APR;

}

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

void __fastcall TForm1: :MistakeClick (TObject *Sender)

{

//Выбор графика погрешности

Form2-> Invalidate ();

g_type=NONE;

DrawClick (Sender);

g_type=MIS;

}

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

double ApproxFunc (double x)

{

//Значение аппроксимирующей функции в точке x

return (Parab[0]*pow (x, 2. 0)+Parab[1]*x+Parab[2]);

}

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

double My (double x, double y)

{

//значение правой части диф. уравнения в точке (x, y)

return x+sin (y/pow (7. 0,0. 5));

}

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

void __fastcall TForm1: :FormShow (TObject *Sender)

{

//Событие на отображение формы

Form2-> Width=420; //Устанавливаем размеры формы для вывода графиков

Form2-> Height=Height;

Form2-> Show (); //Отображаем форму

Form2-> Left=20+Left+Width;

Form2-> Top=Top;

DrawClick (Sender); //Выводим сетку

}

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

void __fastcall TForm1: :Timer1Timer (TObject *Sender)

{

//Если положение главного окна изменилось, тянем вслед за ним окно графиков

Form2-> Left=20+Left+Width;

Form2-> Top=Top;

}

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

void __fastcall TForm1: :DrawClick (TObject *Sender)

{

//Чертим график

int i;

double kx=(double)Form2-> Width/n; //коэффициенты сжатия по осям

double ky=(double)Form2-> Height/n;

Form2-> Canvas->MoveTo (x_c, y_c); //Вычерчивание координатных осей

Form2-> Canvas->LineTo (Width, y_c);

Form2-> Canvas->MoveTo (x_c, y_c);

Form2-> Canvas->LineTo (x_c, 0);

//Вычерчивание сетки серым цветом

Form2-> Canvas->Pen->Color=clDkGray;

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

{

Form2-> Canvas->MoveTo (x_c+i*kx, Height-35);

Form2-> Canvas->LineTo (x_c+i*kx, 0);

Form2-> Canvas->TextOutA (x_c+i*kx-5,Height-35,AnsiString (x0+i*h));

}

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

{

Form2-> Canvas->MoveTo (x_c-5,y_c-i*ky);

Form2-> Canvas->LineTo (Width, y_c-i*ky);

/*if ((i%4)==0) */Form2-> Canvas->TextOutA (x_c-30,-5+y_c-i*ky, AnsiString (i/4. 0));

}

switch (g_type) //В зависимости от выбранного графика, чертим график

{

caseNONE: //Не указан тип

{ //Ничего не делаем

}

break;

caseSOL: //График решения

{

Form2-> Canvas->Pen->Color=clRed; //Красным цветом

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

{

Form2-> Canvas->MoveTo (x_c+i*kx, y_c-solutions[i]*ky*4. 0);

Form2-> Canvas->LineTo (x_c+(i+1)*kx, y_c-solutions[i+1]*ky*4. 0);

}

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

}

break;

caseAPR: //График аппроксимирующей функции

{

Form2-> Canvas->Pen->Color=clRed; //Красным цветом

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

{

Form2-> Canvas->MoveTo (x_c+i*kx, y_c-approxim[i]*ky*4. 0);

Form2-> Canvas->LineTo (x_c+(i+1)*kx, y_c-approxim[i+1]*ky*4. 0);

}

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

}

break;

case MIS: //Погрешность

{

Form2-> Canvas->Pen->Color=clNavy; //График аппроксимации синим

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

{

Form2-> Canvas->MoveTo (x_c+i*kx, y_c-approxim[i]*ky*4. 0);

Form2-> Canvas->LineTo (x_c+(i+1)*kx, y_c-approxim[i+1]*ky*4. 0);

}

//График аппроксимации с учётом погрешности разовым

Form2-> Canvas->Pen->Color=clFuchsia;

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

{

Form2-> Canvas->MoveTo (x_c+i*kx, y_c-approxim_correct[i]*ky*4. 0);

Form2-> Canvas->LineTo (x_c+(i+1)*kx, y_c-approxim_correct[i+1]*ky*4. 0);

}

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

}

break;

}

}

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

Содержимое Unit2. h

//Unit2. h

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

#ifndef Unit2H

#define Unit2H

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

#include < Classes. hpp>

#include < Controls. hpp>

#include < StdCtrls. hpp>

#include < Forms. hpp>

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

classTForm2: publicTForm //Определение класса формы для вывода графика

{

__published: // IDE-managed Components

private: // User declarations

public: // User declarations

__fastcall TForm2(TComponent* Owner);

};

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

extern PACKAGE TForm2 *Form2;

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

#endif

Содержимое файла Unit2. cpp

//ФайлUnit2. cpp

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

#include «Unit2. h»

#include «Unit1. h»

#pragma package (smart_init)

#pragma resource «*. dfm»

TForm2 *Form2;

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

__fastcall TForm2: :TForm2(TComponent* Owner)

: TForm (Owner)

{

}

Приложение А

Структура программы выглядит так:

Общий вид

Решение диф. уравнения

Апроксимация диф. уравнения

И расчет погрешности

График решения

График аппроксимации

График погрешности

Приложение Б Блок-схемы

Решение дифференциального уравнения на промежутке [x0; xk] при начальном условии y0 методом Рунге-Кутта 4 порядка

Решение дифференциального уравнения на промежутке [x0; xk] при начальном условии y0 методом Рунге-Кутта 4 порядка с полушагом

Вычисление погрешностей аппроксимации методом Рунге-Ромберга

ПоказатьСвернуть
Заполнить форму текущей работой