Рівномірне наближення функцій ермітовими сплайнами (стр. 5 из 6)
(53) 
Потрібно знайти залежність
від 
. Для деяких вузлів ланок ермітових сплайнів, а саме ланок у вигляді многочлена, відношення многочлена до лінійної функції, добутку степеневої і експоненціальної функцій, степеневого виразу від многочлена параметри 
сплайна знаходяться в аналітичному вигляді із перших чотирьох рівнянь системи (53).Вони залежать від
і значень функції та її похідної в цих точках. Коефіцієнти можна підставити в п’яте і шосте рівняння системи. В результаті система шести рівнянь з шістьома невідомими зводиться до системи двох рівнянь з двома невідомими 
: 
(54)Система (54) є системою трансцендентних рівнянь. Її можна розв’язати, використовуючи відомі наближені методи знаходження коренів трансцендентних систем.
Висновки
В багатьох технічних задачах використовується кускова апроксимація однозначних функцій. Застосування у такій задачі нелінійних виразів з метою наближення викликає труднощі через відсутність ефективних алгоритмів для визначення їх параметрів. Для цієї задачі є зручними кускові наближення (сплайн-наближення). У роботі наведений приклад побудови ермітового сплайна з експоненціальною і многочленною ланками. Оскільки похибка ермітового сплайна з експоненціальною ланкою в деяких випадках є меншою, ніж у многочленного ермітового сплайна, то їх доцільно застосовувати для наближення функцій. Також побудовано алгоритми рівномірного наближення ермітовими сплайнами.
Викладацька практика
1.10.2009 – 3 пара.
Лекція з курсу "Теорія масового обслуговування".
Тема: "Потоки Пальма".
Заняття проводилось для груп СІМ51 магістри і спеціалісти.
2.10.2009 – 1 пара.
Лабораторна робота з курсу "Чисельні методи".
Тема: "Однокрокові методи чисельного розвязування задачі Коші для звичайних диференціальних рівнянь"
Заняття проводилось для групи ПМ41.
2.10.2009. – 3 пара.
Практичне заняття з курсу "Теорія масового обслуговування".
Тема: "Найпростіший потік"
Заняття проводилось для груп СІМ51 магістри і спеціалісти.
Опис програми
Програма Hermit’sspline шукає балансне наближення функцій ермітовими сплайнами. Головне вікно програми розділене на дві частини: ліву і праву. У лівій частині є три закладки: перша призначена для виводу результатів програми, друга для виводу графіків функції і сплайну; третя для виводу графіку похибки наближення. У правій частині є поля для вводу меж інтервалу і похибки. Також є перемикачі для вибору виду сплайна і функції.
Для роботи програми треба виконати наступні дії:
· у поля"2" "3" потрібно ввести межі інтервалу на якому функція визначена і диференційовна;
· у поле "1" треба ввести похибку;
· вибрати вид сплайна 4;
· вибрати функцію 5;
· далі натиснути кнопку "6", яка викликає функцію, що будує балансне наближення із заданою похибкою;
· для побудови балансного наближення із заданою кількістю ланок треба натиснути кнопку "8";
· вивід результатів буде у полі "7";
· щоб переглянути графіки функції і сплайну потрібно натиснути на закладку 9;
· щоб переглянути графік похибки наближення потрібно натиснути на закладку 10;
Опис основних функцій програми:
· voidermit_1(double *a, doublex0, doublex1); - функція пошуку коефіцієнтів ермітового сплайна з ланками виду
;· voidermit_2(double *a, doublex0, doublex1); - функція пошуку коефіцієнтів ермітового сплайна з ланками виду
;· voidermit_3(double *a, doublex0, doublex2); - функція пошуку коефіцієнтів ермітового сплайна з ланками виду
;· voidermit_4(double *b, doublex0, doublex2); - функція пошуку коефіцієнтів ермітового сплайна з ланками виду
;· voidermit_5(double *a, doublezl, doublezp); - функція пошуку коефіцієнтів ермітового сплайна з ланками виду
;· voidermit_rp(double *a, doublea1, doubleb1, doublenyu, intn); - рівномірне наближення ермітовими сплайнами із заданною похибкою;
· voidermit_rl (double*a, doublezl, doubleb1, intn, intp, intr); - рівномірне наближення ермітовими сплайнами із заданною кількістю ланок.
Література
1. Пізюр Я.В., Попов Б.О. Рівномірне наближення ермітовими сплайнами з парною кількістю параметрів.// Контрольно-вимірювальна техніка.- 1993. – Вип. 50. – С. 8-13
2. Пізюр Я.В. Наближення функцій ермітовими сплайнами з експоненціальними ланками// Вісник НУ "Львівська політехніка". "Фізико-математичні науки" №566, 2006, – С. 68-75.
3. Зав’ялов Ю.С., Квасов Б.И., Мірошниченко В.Л. Методи сплайн функцій. – М.: Наука, 1980. – 352 с.
Додаток
Код програми.
private: System::Void button2_Click(System::Object^ sender, System::EventArgs^ e) {
double zl, zp, x;
zl=Double::Parse(textBox3->Text);
zp=Double::Parse(textBox4->Text);
x =(zl+zp)/2;
int p=2,n=5;
if((s1->Checked==true)||(s2->Checked==true)||(s5->Checked==true)||(s7->Checked==true)||(s9->Checked==true)){
n=4;p=1;
}
double *a = new double[n];
if (s1->Checked == true) {
ermit_1(a, zl, zp, p);
}
if (s2->Checked == true) {
ermit_2(a, zl, zp, p);
}
if (s3->Checked == true) {
ermit_3(a, zl, zp, p);
}
if (s4->Checked == true) {
ermit_4(a, zl, zp, p);
}
if (s5->Checked == true) {
ermit_5(a, zl, zp, p);
}
if (s6->Checked == true) {
ermit_6(a, zl, zp, p);
}
if (s7->Checked == true) {
ermit_8(a, zl, zp, p);
}
if (s8->Checked == true) {
ermit_9(a, zl, zp, p);
}
if (s9->Checked == true) {
ermit_7(a, zl, zp, p);
}
chart1->Series["Function"]->Points->Clear();
chart1->Series["Spline"]->Points->Clear();
chart2->Series["error"]->Points->Clear();
double t,ch1,ch2,ch3;
for(t = zl; t <= zp; t += 0.01)
{
ch1 = f(t,1);
ch2 = sp(a,t);
ch3 = epx_p(a,t,1);
chart1->Series["Function"]->Points->AddXY(t, ch1);
chart1->Series["Spline"]->Points->AddXY(t, ch2);
chart2->Series["error"]->Points->AddXY(t, ch3);
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
double epx_p(double *a, double x, int p) {
return Math::Abs((f(x, p) - sp(a, x)) / w(x));
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public: double f(double x, int p) {
if(f1->Checked==true){
return Math::Sin(x);
}
if(f2->Checked==true){
return Math::Cos(x);
}
if(f3->Checked==true){
return 1 / (2 + x * x);
}
if(f4->Checked==true){
return Math::Log(x + 1);
}
if(f5->Checked==true){
return Math::Exp(x);
}
if(f6->Checked==true){
return x*x;
}
return -1;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public: double fp(double x, int p) {
if(f1->Checked==true){
return Math::Cos(x);
}
if(f2->Checked==true){
return -Math::Sin(x);
}
if(f3->Checked==true){
return (-2* x ) / ((2 + x * x) * (2 + x * x));
}
if(f4->Checked==true){
return 1 / (x + 1);
}
if(f5->Checked==true){
return Math::Exp(x);
}
if(f6->Checked==true){
return 2*x;
}
return -1;
}
//*****************************************
public: void ermit_1(double *a, double x0, double x1, int p) {
a[3] = (fp(x1, p) / f(x1, p) + fp(x0, p) / f(x0, p) + 2 * (Math::Log(f(x0, p)
/ f(x1, p)) / (x1 - x0))) / ((x1 - x0) * (x1 - x0));
a[2] = ((2* x0 * x0 - x0 * x1 - x1 * x1) * a[3] - (fp(x0, p) / f(x0, p))
- (Math::Log(f(x0, p) / f(x1, p)) / (x1 - x0))) / (x1 - x0);
a[1] = (1 / (x1 - x0)) * (Math::Log(f(x1, p) / f(x0, p)) - a[3] * (x1 * x1 * x1
- x0 * x0 * x0) - a[2] * (x1 * x1 - x0 * x0));
a[0] = f(x0, p) * Math::Exp(-(a[1] * x0 + a[2] * x0 * x0 + a[3] * x0 * x0 * x0));
}
/////////////////////////////////////////////////////////////////////////////
void ermit_2(double *b, double x0, double x1, int p) {
double h;
h = x1 - x0;
b[3] = 2 * ((fp(x1, p) + fp(x0, p)) / 2 - (f(x1, p) - f(x0, p)) / h) / (h
* h);
b[2] = 0.5 * ((fp(x1, p) - fp(x0, p)) / h - 3* b [3] * (x0 + x1));
b[1] = fp(x1, p) - 2* b [2] * x1 - 3* b [3] * x1 * x1;
b[0] = 0.5 * (f(x1, p) + f(x0, p) - b[3] * (x0 * x0 * x0 + x1 * x1 * x1)
- b[2] * (x0 * x0 + x1 * x1) - b[1] * (x0 + x1));
}
////////////////////////////////////////////////////////////////
void ermit_3(double *a, double x0, double x2, int p) {
double a1, a2, a3, b1, b2, b3, z1, z2, z3, g1, g2, g3;
double x1;
x1 = (x0 + x2) / 2;
a1 = Math::Log(f(x1, p) / f(x0, p)) / (x1 - x0) - Math::Log(f(x2, p) / f(x0, p)) / (x2- x0);
b1 = (x1 + x0) * (x1 * x1 + x0 * x0) - (x2 + x0) * (x2 * x2 + x0 * x0);
z1 = x1 * x1 + x1 * x0 - x2 * x2 - x2 * x0;
g1 = x1 - x2;
a2 = Math::Log(f(x1, p) / f(x0, p)) / (x1 - x0) - fp(x0, p) / f(x0, p);
b2 = x1 * x1 * x1 + x0 * x1 * (x0 + x1) - 3* x0 * x0 * x0;
z2 = x1 * x1 + x0 * x1 - 2* x0 * x0;
g2 = x1 - x0;
a3 = Math::Log(f(x1, p) / f(x0, p)) / (x1 - x0) - fp(x2, p) / f(x2, p);
b3 = (x0 + x1) * (x0 * x0 + x1 * x1) - 4* x2 * x2 * x2;
z3 = x1 * x1 + x0 * x1 + x0 * x0 - 3* x2 * x2;
g3 = x1 + x0 - 2* x2 ;
a[2] = ((a2 * b1 - a1 * b2) * (z3 * b1 - z1 * b3) - (z2 * b1 - z1 * b2)
* (a3 * b1 - a1 * b3)) / ((g1 * b2 - g2 * b1) * (z1 * b3 - z3 * b1)
+ (z2 * b1 - z1 * b2) * (g1 * b3 - g3 * b1));
a[3] = (a2 * b1 - a1 * b2 + (g1 * b2 - b1 * g2) * a[2]) / (b1 * z2 - z1* b2);
a[4] = (a1 - z1 * a[3] - g1 * a[2]) / b1;
a[1] = (1 / (x2 - x0)) * (Math::Log(f(x2, p) / f(x0, p)) - a[4] * (x2 * x2 * x2
* x2 - x0 * x0 * x0 * x0) - a[3] * (x2 * x2 * x2 - x0 * x0 * x0)
- a[2] * (x2 * x2 - x0 * x0));
a[0] = f(x0, p) * Math::Exp(-(a[1] * x0 + a[2] * x0 * x0 + a[3] * x0 * x0 * x0+ a[4] * x0 * x0 * x0 * x0));
}
///////////////////////////////////////////////////////////////////////////
void ermit_4(double *a, double x0, double x2, int p) {
double a1, a2, a3, b1, b2, b3, z1, z2, z3, g1, g2, g3;
double x1, h;
x1 = (x0 + x2) / 2;
h = x1 - x0;
a1 = (f(x2, p) - f(x0, p)) / (x2 - x0) - (f(x1, p) - f(x0, p)) / (x1 - x0);
b1 = (x2 + x0) * (x2 * x2 + x0 * x0) - (x1 + x0) * (x1 * x1 + x0 * x0);
z1 = x2 * x2 + x2 * x0 - x1 * x1 - x1 * x0;
g1 = x2 - x1;
a2 = (f(x1, p) - f(x0, p)) / (x1 - x0) - fp(x0, p);
b2 = x1 * x1 * x1 + x0 * x1 * (x0 + x1) - 3* x0 * x0 * x0;
z2 = x1 * x1 + x0 * x1 - 2* x0 * x0;
g2 = x1 - x0;
a3 = (f(x1, p) - f(x0, p)) / (x1 - x0) - fp(x2, p);
b3 = (x0 + x1) * (x0 * x0 + x1 * x1) - 4* x2 * x2 * x2;
z3 = (x1 * x1 + x0 * x1 + x0 * x0) - 3* x2 * x2;
g3 = (x1 + x0 - 2* x2 );
a[2] = ((a2 * b1 - a1 * b2) * (z3 * b1 - z1 * b3) - (z2 * b1 - z1 * b2)
* (a3 * b1 - a1 * b3)) / ((g1 * b2 - g2 * b1) * (z1 * b3 - z3 * b1)
+ (z2 * b1 - z1 * b2) * (g1 * b3 - g3 * b1));
a[3] = (a2 * b1 - a1 * b2 + (g1 * b2 - b1 * g2) * a[2]) / (b1 * z2 - z1
* b2);
a[4] = (a1 - z1 * a[3] - g1 * a[2]) / b1;
a[1] = (f(x1, p) - f(x0, p)) / h - a[2] * (x1 + x0) - a[3] * (x1 * x1 + x1
* x0 + x0 * x0) - a[4] * (x1 + x0) * (x1 * x1 + x0 * x0);
a[0] = f(x0, p) - a[1] * x0 - a[2] * x0 * x0 - a[3] * x0 * x0 * x0 - a[4]
* x0 * x0 * x0 * x0;
}
////////////////////////////////////////////////////////////////