Разработка программы на языке C - Курсовая работа

На самом деле программы можно писать не только для компьютера, но и для других устройств, у которых есть микропроцессорное устройство, способное производить математические вычисления (сложение, вычитание, умножение, деление и т.д.) и выполнять логические операции (если выполняется какое-либо условие, то делаем это (набор действий), иначе делаем то (набор альтернативных действий)). Программирование основывается на специальных алгоритмических языках, с помощью которых и задаются инструкции компьютеру (вернее, его процессору), законченный набор которых называется программой. В то же время есть и языки общего назначения, на которых пишется большое количество современных приложений для компьютера. Программы, которые мы пишем на алгоритмических языках, непосредственно не понятны компьютеру (процессору), т.к. на самом низком уровне он может воспринимать и понимать лишь два числа: ноль и единицу. Для того чтобы текст составленной программы смог выполняться компьютером, его нужно преобразовать к понятному компьютеру формату.Разработать программу на языке С , в которой реализовано: 1) решение дифференциального уравнения с начальными условиями на интервале . Программа должна сопровождаться понятным пользователю интерфейсом. Среди пользователей персональных компьютеров в настоящее время наиболее популярна операционная система Windows, и естественно, что тот, кто хочет программировать, хочет и писать программы, которые будут работать в Windows. Бурное развитие вычислительной техники, потребность в эффективных средствах разработки программного обеспечения привели к появлению на рынке целого ряда систем программирования, ориентированных на так называемую "быструю разработку", среди которых особо следует отметить Microsoft Visual Basic и Borland Delphi. В основе систем быстрой разработки (RAD-систем, Rapid Application Development - среда быстрой разработки приложений) лежит технология визуального проектирования и событийного программирования, суть которой заключается в том, что среда разработки берет на себя большую часть работы по генерации кода программы, оставляя программисту работу по конструированию диалоговых окон и написанию функций обработки событий.К задачам вычислительной математики относят: решение систем линейных уравнений нахождение собственных значений и векторов матрицы нахождение сингулярных значений и векторов матрицы решение нелинейных алгебраических уравнений решение систем нелинейных алгебраических уравнений решение дифференциальных уравнений (как обыкновенных дифференциальных уравнений, так и уравнений с частными производными) решение систем дифференциальных уравнений решение интегральных уравнений задачи аппроксимации задачи интерполяции задачи экстраполяции задачи численной оптимизации Дифференциальное уравнение - уравнение, связывающее значение некоторой неизвестной функции в некоторой точке и значение ее производных различных порядков в той же точке. Дифференциальное уравнение содержит в своей записи неизвестную функцию, ее производные и независимые переменные; однако не любое уравнение, содержащее производные неизвестной функции, является дифференциальным уравнением. Стоит также отметить, что дифференциальное уравнение может вообще не содержать неизвестную функцию, некоторые ее производные и свободные переменные, но обязано содержать хотя бы одну из производных. Решением (интегралом) дифференциального уравнения порядка n называется функция y(x), имеющая на некотором интервале (a, b) производные y"(x),y""(x),...,y(n)(x) до порядка n включительно и удовлетворяющая этому уравнению.В ходе выполнения курсовой работы я закрепила знания работы с программой C Builder .Структура программы выглядит так: Общий вид Решение диф.

Содержание

Введение

1. Задание

2. С Builder что это?

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

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

Заключение

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

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

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

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

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

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

В ходе выполнения курсовой работы я закрепила знания работы с программой 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

#include

#include

#include

#include

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

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

#pragma hdrstop

#include "Unit1.h"

#include "Unit2.cpp"

#include

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

#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

#include

#include

#include

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

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)

{

}