Министерство образования и науки Российской Федерации
Федеральное государственное бюджетное образовательное
учреждение высшего профессионального образования
«Комсомольский-на-Амуре государственный технический университет»
Факультет электротехнический
Кафедра «Теоретические основы электротехники»
ПОЯСНИТЕЛЬНАЯ ЗАПИСКА
к курсовому проекту
по дисциплине «Программирование и основы алгоритмизации»
Разработка программы на языке C++
Студент группы 9ИНб-1 М. А. Путинцева
Преподаватель А. В. Купова
Нормоконтролер А. В. Купова
Содержание
Введение
. Задание
. С++ Builder что это?
. Численные методы
4. Разработка программы на языке C++
Заключение
Список использованных источников
Приложение А Программа на языке C++
Приложение Б Блок-схемы метода Рунге-Кутта 4 порядка для решения ОДУ
Введение
Программирование - это процесс создания (написания) программ для
компьютера. На самом деле программы можно писать не только для
компьютера, но и для других устройств, у которых есть микропроцессорное
устройство, способное производить математические вычисления (сложение,
вычитание, умножение, деление и т.д.) и выполнять логические операции (если
выполняется какое-либо условие, то делаем это (набор действий), иначе делаем
то (набор альтернативных действий)).
Программирование основывается на специальных алгоритмических
языках, с помощью которых и задаются инструкции компьютеру (вернее, его
процессору),
законченный
набор
которых
называется
программой.
Алгоритмических языков в данное время имеется большое множество, каждый
из которых служит для решения своих задач. В то же время есть и языки общего
назначения, на которых пишется большое количество современных приложений
для компьютера. К этим языкам можно отнести такие, как C++, Java, C#, Delphi
и другие.
Программы,
которые
мы
пишем
на
алгоритмических
языках,
непосредственно не понятны компьютеру (процессору), т.к. на самом низком
уровне он может воспринимать и понимать лишь два числа: ноль и единицу.
Иными словами, процессор оперирует лишь значениями и командами в
двоичном коде (а двоичный код, как вы знаете, состоит из нулей и единиц). Для
того чтобы текст составленной программы смог выполняться компьютером, его
нужно преобразовать к понятному компьютеру формату. Для этой цели служат,
так называемые трансляторы, у которых в свою очередь есть тоже две
разновидности: компиляторы и интерпретаторы. Разница между ними в том, что
компиляторы полностью преобразуют код к формату, понятному компьютеру, а
затем уже он выполняется. Интерпретаторы построчно преобразуют код к
понятному компьютеру формату, которые он так же построчно и выполняет.
Вторым способом выполнение программы будет происходить несколько
медленнее, нежели первым. В то же время программы, написанные на
интерпретируемых языках программирования, могут быть легко перенесены в
другую программную среду. К примеру, могут выполняться как на
компьютерах, так и
на смартфонах. Все вы, наверное, слышали о
java-приложениях, которые могут работать в разных средах, за счет того, что
java
является
джава-машиной.
интерпретируемым
языком
и
выполняется
специальной
1. Задание
программирование язык си дифференциальное уравнение
Разработать программу на языке С++, в которой реализовано:
) решение дифференциального уравнения
условиями
на интервале
с начальными
.
) аппроксимация полученного решения параболой методом наименьших
квадратов.
) расчет погрешности аппроксимации.
)
построение
графиков
решения
дифференциального
уравнения,
аппроксимирующей функции и погрешности аппроксимации.
Программа
должна
сопровождаться
понятным
пользователю
интерфейсом.
Исходные данные
Вариант: 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
систем
фирмы
Borland
фантастическая!
Успех
и
популярность
Delphi
вызвал
желание
распространить методы быстрой разработки на область профессионального
программирования, что и привело к появлению Borland C++ Builder.++ 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 Мбайт).
. Численные методы
Вычислительная математика - раздел математики, включающий круг
вопросов,
связанных
с
производством
вычислений
и
использованием
компьютеров. В более узком понимании вычислительная математика - теория
численных методов решения типовых математических задач.
К задачам вычислительной математики относят:
решение систем линейных уравнений
нахождение собственных значений и векторов матрицы
нахождение сингулярных значений и векторов матрицы
решение нелинейных алгебраических уравнений
решение систем нелинейных алгебраических уравнений
решение
дифференциальных
уравнений
(как
обыкновенных
дифференциальных уравнений, так и уравнений с частными производными)
решение систем дифференциальных уравнений
решение интегральных уравнений
задачи аппроксимации
задачи интерполяции
задачи экстраполяции
задачи численной оптимизации
Основное отличие вычислительной математики заключается в том, что
при решении вычислительных задач человек оперирует машинными числами,
которые являются дискретной проекцией вещественных чисел на конкретную
архитектуру компьютера. Так, например если взять машинное число длиной в 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,=hf(xi,yi),=hf(xi+h/2,
yi+k2/2),=hf(xi+h, yi+k3),+1=xi+h,
yi+k1/2),=hf(xi+h/2,
где уi+1,уi - значения искомой функции в точках xi+1, xi соответственно,
индекс i показывает номер шага интегрирования, h - шаг интегрирования.
Начальные условия при численном интегрировании учитываются на нулевом
шаге: i=0, x=x0, y=y0
Заключение
В ходе выполнения курсовой работы я закрепила знания работы с
программой C++Builder
разработки
. Благодаря
пользовательских
однотипности
доступа
программировать.
к
уникальному сочетанию удобства
интерфейсов,
разнообразным
компонентной
базам
данных
архитектуры,
было
проще
Список использованных источников
1. Шилдт, Г. А. Программирование на C и C++ для Windows / Г. Шилдт - М.:
BHV, 1996.-235с.
. Петзолд, Ч. Р. Программирование для Windows / Ч. Петзолд - Санк-Петербург:
BHV, 1997.-345с.
. Страуструп, Б. В. Язык программирования Си++ / Б. Страуструп- М: Радио и
связь, 1991.-468с.
. Архангельский, В.В. Программирование в С++ Builder 6 / В.В. Архангельский
- М.: Бином, 1998г.- 560с.
. Подбельский, В.В. Программирование на языке Си / В.В Подбельский. - М:
Финансы и статистика, 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;*Solution;//Кнопки
выбора
типа
графика*AppFunc;*Mistake;*Operation;*Clear;//Кнопка
отчистить*Timer1;//Таймер__fastcall
FormCreate(TObject
*Sender);__fastcall
SolveClick(TObject *Sender);__fastcall approxClick(TObject *Sender);__fastcall
ClearClick(TObject *Sender);__fastcall CalcDyClick(TObject *Sender);__fastcall
SolutionClick(TObject
*Sender);__fastcall
AppFuncClick(TObject
*Sender);__fastcall MistakeClick(TObject *Sender);__fastcall FormShow(TObject
*Sender);__fastcall Timer1Timer(TObject *Sender);__fastcall DrawClick(TObject
*Sender);:
// User declarations:
// User declarations
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------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"1 *Form1;
//--------------------------------------------------------------------------//Описание глобальных переменных
#defineNONE 0 //Не требуется построения графика
#defineSOL 1 //График решения
#defineAPR 2 //График аппроксимирующей функции
#defineMIS 3 //График погрешности
intx_c=30,y_c=170; //Начало координат
double x0 = 0.5; //Интервалxk = 1.5; y0 = 0.6; //Начальное условие
double h = 0.1; //Шаг
double h_half = h/2.0; //Полушаг
intn = 2+(xk-x0)/h; //Количество узлов сетки
intg_type=NONE; //Вид графика для построения
double *knots; //Узлы сетки*knots_half; //Узлы сетки*solutions; //Значения
решений*solutions_half; //Значения решений c полушагом*approxim; //Значения
апроксимир.
функции*correct;
//Уточнённое
решение*errors;
//Значения
поправок*approxim_correct; //Значения аппроксим. с поправкой[3][4]; //Система
уравнений для поиска коэф. апр. функции
double Parab[3]={0,0,0}; //Коэффициенты аппроксимирующей функции
//--------------------------------------------------------------------------//Прототипы функций
doubleMy(double, double); //Функция в правой части диф.уравнения
double ApproxFunc(double); //Аппроксимирующая функция
//--------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------__fastcall
TForm1::FormCreate(TObject *Sender)
{
solutions = newdouble [n]; //Выделение памяти под массивы значений
approxim = new double [n];= new double [n];= new double [n];_half = new
double [n*2];= new double [n];_correct = new double [n];_half= new double
[n*2];(int i=0; i<n; i++) knots[i]=x0+i*h; //Вычисление узлов сетки
//Вычисление
узлов
сетки
с
полушагом(int
i=0;
i<2*n;
i++)
knots_half[i]=x0+i*h_half;
}
//---------------------------------------------------------------------------__fastcall
TForm1::SolveClick(TObject *Sender)
{i;k1,k2,k3,k4;[0]=y0;
//Начальное
условие_half[0]=y0;->Enabled=true;
//Разрешение ранее недоступных объектов управления
Solution->Enabled=true;
//Вычисления методом Рунге-Кутта 4 порядка
for(i=0; i<n-1; i++)
{=My(knots[i],solutions[i]);=My(knots[i]+h/2.0,solutions[i]+h/2.0*k1);=My(k
nots[i]+h/2.0,solutions[i]+h/2.0*k2);=My(knots[i]+h,solutions[i]+h*k3);[i+1]=solutio
ns[i]+h/6*(k1*+2*k2+2*k3+k4);
}
//Вычисления методом Рунге-Кутта 4 порядка с полушагом
for(i=0; i<2*n-1; i++)
{=My(knots_half[i],solutions_half[i]);=My(knots_half[i]+h_half/2.0,solutions_
half[i]+h_half/2.0*k1);=My(knots_half[i]+h_half/2.0,solutions_half[i]+h_half/2.0*k2
);=My(knots_half[i]+h_half,solutions_half[i]+h_half*k3);_half[i+1]=solutions_half[i]
+h_half/6*(k1*+2*k2+2*k3+k4);
}
//Вывод решения на экран
Screen->Lines->Add("Решение диф. уравнения");
Screen->Lines->Add("-------------------------------------------------------------------"
);(i=0; i<n; i++)>Lines->Add("x = " + AnsiString(knots[i]) +
"\t
f(x,y)
=
"
+
AnsiString(solutions[i]));->Lines->Add("------------------------------------------------------------------");
//Вывод решения с полушагом на экран
Screen->Lines->Add("Решение диф. уравнения c полушагом");
Screen->Lines->Add("-------------------------------------------------------------------"
);(i=0; i<2*n; i++)>Lines->Add("x = " + AnsiString(knots_half[i]) +
"\t
f(x,y)
=
"
+
AnsiString(solutions_half[i]));>Lines->Add("------------------------------------------------------------------");
}
//---------------------------------------------------------------------------__fastcall
TForm1::approxClick(TObject *Sender)
{cur=0;i, j, k, p, q;
//Вычисление коэффициентов системы уравнений для вычисления апр.
функции
//Согласно методу наименьших квадратов
// a11 a12 a13 | b1
// a21 a22 a23 | b2
// a31 a32 a33 | b3tmp=0;[3][4];
CalcDy->Enabled=true;
//Разрешение
ранее
недоступных
органов
управления
AppFunc->Enabled=true;(i=0;
//a11[0][0]=tmp;=0;(i=0;
i<n;i++)
i<n;i++)
//a12=a21[0][1]=tmp;[1][0]=tmp;=0;(i=0;
i<n;i++)
tmp+=pow((x0+i*h),4);
tmp+=pow((x0+i*h),3);
tmp+=pow((x0+i*h),2);
//a13=a22=a31[0][2]=tmp;[1][1]=tmp;[2][0]=tmp;=0;(i=0; i<n;i++) tmp+=(x0+i*h);
//a23=a32[1][2]=tmp;[2][1]=tmp;=0;[2][2]=n+1;
tmp+=solutions[i]*pow((x0+i*h),2);
//a33=0;(i=0;
i<n;i++)
//b1[0][3]=tmp;=0;(i=0;
i<n;i++)
tmp+=solutions[i]*(x0+i*h); //b2[1][3]=tmp;=0;(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)
{= j;((matrix[k+1][j] == 0) && (k < q))++;(matrix[k+1][j] != 0)(i = 0; i < p;
i++)
{= matrix[j][i];[j][i] = matrix[k+1][i];[k+1][i] = cur;
};
}(k = 0; k < q - 1; k++)(j = k + 1; j < q; j++)
{(matrix[k][k] !=0)
{= matrix[j][k] / matrix[k][k]; //Получаем нули в текущей строке(i = 0; i < q
+ 1; i++)[j][i] = matrix[k][i] * cur - matrix[j][i];
}
elsebreak;
}
//Матрица приведена к треугольному виду, начинаем обратный ход
for (j = q - 1 ; j >= 0; j--)
{= matrix[j][q];(i = j + 1; i < q; i++)= cur - matrix[j][i] * Parab[i];[j] = cur /
matrix[j][j]; //Вычисляем коэффициенты
}
//Выводим коэффициенты на экран
Screen->Lines->Add("Коэффициенты апроксимирующей функции");
Screen->Lines->Add("-------------------------------------------------------------------"
);>Lines->Add("a
=
"
+
AnsiString(Parab[0]));>Lines->Add("b
AnsiString(Parab[1]));>Lines->Add("c
=
=
"
"
+
+
AnsiString(Parab[2]));->Lines->Add("------------------------------------------------------------------");
//Расчёт через аппроксимирующую функцию с выводом на экран
for(i=0; i<n; i++)
{[i]=ApproxFunc(knots[i]);>Lines->Add("x = " + AnsiString(knots[i]) +
"\t f(x,y) = " + AnsiString(approxim[i]));
}>Lines->Add("-------------------------------------------------------------------");
}
//---------------------------------------------------------------------------__fastcall
TForm1::ClearClick(TObject *Sender)
{
//Очистка
рабочей
областиi=Screen->Lines->Count;_type=NONE;(i>=1)//Очищаем поле вывода
{>Lines->Delete(0);=Screen->Lines->Count;
}
Solution->Enabled=false;//Запрещаем органы управления
AppFunc->Enabled=false;>Enabled=false;>Enabled=false;>Enabled=false;2->I
nvalidate();//Очищаем окно отображения графика
}
//---------------------------------------------------------------------------__fastcall
TForm1::CalcDyClick(TObject *Sender)
{
//Вычисление погрешности методом Рунге-Ромберга
inti;
Mistake->Enabled=true;(i=0; i<n; i++)
{[i]=solutions[i]+(solutions[i]-solutions_half[i*2])/(pow(0.5,4.0)-1);[i]=correct
[i]-approxim[i];_correct[i]=approxim[i]+errors[i];
}
//Вывод результатов вычисления погрешности
Screen->Lines->Add("Рассчёт
погрешности
аппроксимации
и
корректировка значений");
Screen->Lines->Add("-------------------------------------------------------------------"
);(i=0; i<n; i++)
{>Lines->Add("x = "+AnsiString(knots[i]) +
":\t
Поправка:
"
+
AnsiString(errors[i])+"\t
Значение:
"+(approxim_correct[i]));
}>Lines->Add("-------------------------------------------------------------------");
}
//---------------------------------------------------------------------------__fastcall
TForm1::SolutionClick(TObject *Sender)
{
//Выбор графика решения
Form2->Invalidate();
g_type=NONE;(Sender);_type=SOL;
}
//---------------------------------------------------------------------------__fastcall
TForm1::AppFuncClick(TObject *Sender)
{
//Выбор графика апроксимации
Form2->Invalidate();
g_type=NONE;(Sender);_type=APR;
}
//---------------------------------------------------------------------------__fastcall
TForm1::MistakeClick(TObject *Sender)
{
//Выбор графика погрешности
Form2->Invalidate();
g_type=NONE;(Sender);_type=MIS;
}
//---------------------------------------------------------------------------ApproxFunc(do
uble x)
{
//Значение аппроксимирующей функции в точке x
return (Parab[0]*pow(x,2.0)+Parab[1]*x+Parab[2]);
}
//---------------------------------------------------------------------------My(double
x,
double y)
{
//значение правой части диф. уравнения в точке (x,y)
return x+sin(y/pow(7.0,0.5));
}
//---------------------------------------------------------------------------__fastcall
TForm1::FormShow(TObject *Sender)
{
//Событие на отображение формы
Form2->Width=420; //Устанавливаем размеры формы для вывода графиков
Form2->Height=Height;->Show();
//Отображаем
форму->Left=20+Left+Width;->Top=Top;(Sender); //Выводим сетку
}
//---------------------------------------------------------------------------__fastcall
TForm1::Timer1Timer(TObject *Sender)
{
//Если положение главного окна изменилось, тянем вслед за ним окно
графиков
Form2->Left=20+Left+Width;->Top=Top;
}
//---------------------------------------------------------------------------__fastcall
TForm1::DrawClick(TObject *Sender)
{
//Чертим графикi;kx=(double)Form2->Width/n; //коэффициенты сжатия по
осямky=(double)Form2->Height/n;->Canvas->MoveTo(x_c,y_c);
//Вычерчивание
координатных
осей->Canvas->LineTo(Width,y_c);->Canvas->MoveTo(x_c,y_c);->Canvas->LineT
o(x_c,0);
//Вычерчивание сетки серым цветом->Canvas->Pen->Color=clDkGray;(i=0;
i<n; i++)
{->Canvas->MoveTo(x_c+i*kx,Height-35);->Canvas->LineTo(x_c+i*kx,0);->
Canvas->TextOutA(x_c+i*kx-5,Height-35,AnsiString(x0+i*h));
}(i=0; i<n; i++)
{->Canvas->MoveTo(x_c-5,y_c-i*ky);->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++)
{->Canvas->MoveTo(x_c+i*kx,y_c-solutions[i]*ky*4.0);->Canvas->LineTo(x
_c+(i+1)*kx,y_c-solutions[i+1]*ky*4.0);
}->Canvas->Pen->Color=clBlack;
}
break;
caseAPR: //График аппроксимирующей функции
{
Form2->Canvas->Pen->Color=clRed; //Красным цветом(i=0; i<n-1; i++)
{->Canvas->MoveTo(x_c+i*kx,y_c-approxim[i]*ky*4.0);->Canvas->LineTo(x
_c+(i+1)*kx,y_c-approxim[i+1]*ky*4.0);
}->Canvas->Pen->Color=clBlack;
};MIS: //Погрешность
{->Canvas->Pen->Color=clNavy;
//График
аппроксимации
синим(i=0;
i<n-1; i++)
{->Canvas->MoveTo(x_c+i*kx,y_c-approxim[i]*ky*4.0);->Canvas->LineTo(x
_c+(i+1)*kx,y_c-approxim[i+1]*ky*4.0);
}
//График аппроксимации с учётом погрешности разовым
Form2->Canvas->Pen->Color=clFuchsia;(i=0; i<n-1; i++)
{->Canvas->MoveTo(x_c+i*kx,y_c-approxim_correct[i]*ky*4.0);->Canvas->L
ineTo(x_c+(i+1)*kx,y_c-approxim_correct[i+1]*ky*4.0);
}->Canvas->Pen->Color=clBlack;
};
}
}
//--------------------------------------------------------------------------Содержимое Unit2.h
//Unit2.h
//--------------------------------------------------------------------------#ifndef Unit2H
#define Unit2H
//--------------------------------------------------------------------------#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//--------------------------------------------------------------------------classTForm2 : publicTForm //Определение класса формы для вывода
графика
{
__published:
Components:
//
IDE-managed
// User declarations:
// User declarations
__fastcall TForm2(TComponent* Owner);
};
//---------------------------------------------------------------------------PACKAGE
TForm2 *Form2;
//--------------------------------------------------------------------------#endif
Содержимое файла Unit2.cpp
//ФайлUnit2.cpp
//--------------------------------------------------------------------------#include "Unit2.h"
#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"*Form2;
//--------------------------------------------------------------------------__fastcall TForm2::TForm2(TComponent* Owner)
: TForm(Owner)
{
}
Приложение А
Структура программы выглядит так:
Общий вид
Решение диф. уравнения
Апроксимация диф. уравнения
И расчет погрешности
График решения
График аппроксимации
График погрешности
Приложение Б Блок-схемы
Решение дифференциального уравнения на промежутке [x0;xk] при
начальном условии y0 методом Рунге-Кутта 4 порядка
Решение дифференциального уравнения на промежутке [x0;xk] при
начальном условии y0 методом Рунге-Кутта 4 порядка с полушагом
Вычисление погрешностей аппроксимации методом Рунге-Ромберга