Таблица 2 – Сравнение методов хорд и бисекции
Значение |
Значение |
Значение |
|
Значение |
Значение |
Значение |
||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||
|
|
|
|
|
|
|
||
0.01 |
0.001 |
0.859375 |
|
0,86651 |
5 |
3 |
||
|
|
|
|
|
|
|
||
0.001 |
0.001 |
0.867188 |
|
0,867042 |
5 |
3 |
||
|
|
|
|
|
|
|
||
0.0001 |
0.001 |
0.867188 |
|
0,867042 |
5 |
3 |
||
|
|
|
|
|
|
|
||
0.00001 |
0.001 |
0.867188 |
|
0,867042 |
5 |
3 |
||
|
|
|
|
|
|
|
||
0.000001 |
0.001 |
0.867188 |
|
0,867042 |
5 |
3 |
||
|
|
|
|
|
|
|
||
0.1 |
0.0001 |
0.875 |
|
0.86166 |
2 |
2 |
||
|
|
|
|
|
|
|
||
0.01 |
0.0001 |
0.859375 |
|
0.866474 |
5 |
3 |
||
|
|
|
|
|
|
|
||
0.001 |
0.0001 |
0.865234 |
|
0.867033 |
8 |
4 |
||
|
|
|
|
|
|
|
||
0.0001 |
0.0001 |
0.867065 |
|
0.867086 |
12 |
4 |
||
|
|
|
|
|
|
|
||
0.00001 |
0.0001 |
0.867096 |
|
0.867086 |
13 |
4 |
||
|
|
|
|
|
|
|
||
0.000001 |
0.0001 |
0.867096 |
|
0.867086 |
13 |
4 |
||
|
|
|
|
|
|
|
||
0.1 |
0.00001 |
0.875 |
|
0.861154 |
2 |
2 |
||
|
|
|
|
|
|
|
||
0.01 |
0.00001 |
0.859375 |
|
0.86478 |
5 |
3 |
||
|
|
|
|
|
|
|
||
0.001 |
0.00001 |
0.865234 |
|
0.867024 |
8 |
4 |
||
|
|
|
|
|
|
|
||
0.0001 |
0.00001 |
0.867065 |
|
0.86708 |
12 |
5 |
||
|
|
|
|
|
|
|
||
0.00001 |
0.0001 |
0.8667081 |
|
0.867085 |
15 |
5 |
||
|
|
|
|
|
|
|
||
0.000001 |
0.0001 |
0.867085 |
|
0.867085 |
16 |
5 |
||
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
ПРИЛОЖЕНИЕ А
ИСХОДНЫЙ КОД ПРОГРАММЫ
#include <stdio.h> #include <math.h> #include <stdlib.h> #include <iostream> #include <conio.h>
double delta;
#ifndef M_PI
#define M_PI 3.14159265358979323846 #endif // !M_PI
extern double F(double); /******************************************************************/
/* Функция F(X) , задаваемая пользователем */
/******************************************************************/
#ifdef __NEWTON
extern double F1(double); /******************************************************************/
/* Производная функции F(X) , задаваемая пользователем */
/******************************************************************/
#endif
#ifdef __ITER
extern double PHI(double); /******************************************************************/
/* |
Функция PHI(X) , задаваемая пользователем |
*/ |
/* |
Данная функция используется в методе |
*/ |
/* |
простых итераций |
*/ |
/******************************************************************/
#endif
double Round(double, double); /******************************************************************/
/* |
Функция Round (X, |
Delta) , предназначена для округления |
*/ |
/* |
X |
с точностью Delta |
*/ |
/******************************************************************/
double BISECT(double, double, double, int&); /******************************************************************/
/* |
Функция BISECT предназначена для решения уравнения F(X)=0 |
*/ |
|
7 |
|
/* |
методом |
деления отрезка пополам. Использованы обозначения: |
*/ |
|
/* |
Left - левый конец промежутка |
*/ |
||
/* |
Right |
- правый конец промежутка |
*/ |
|
/* |
Eps |
- |
погрешность вычисления корня уравнения; |
*/ |
/* |
N - |
число итераций |
*/ |
|
/******************************************************************/
double ITER(double, double, int&); /******************************************************************/
/* |
Функция |
ITER предназначена для решения уравнения F(X)=X |
*/ |
|
/* |
методом простой итерации. Использованы обозначения: |
*/ |
||
/* |
X0 - начальное приближение корня |
*/ |
||
/* |
Eps |
- |
погрешность вычисления корня уравнения; |
*/ |
/* |
N - |
число итераций |
*/ |
|
/******************************************************************/
double HORDA(double, double, double, int&); /******************************************************************/
/* |
Функция |
HORDA предназначена для решения уравнения F(x)=0 |
*/ |
/* |
методом хорд. Использованы обозначения: |
*/ |
|
/* |
Left - левый конец промежутка |
*/ |
|
/* |
Right |
- правый конец промежутка |
*/ |
/* |
Eps - |
погрешность вычисления корня уравнения; |
*/ |
/* |
N - число итераций |
*/ |
|
/******************************************************************/
double NEWTON(double, double, int&); /******************************************************************/
/* |
Функция |
NEWTON предназначена для решения уравнения F(X)=0 |
*/ |
|
/* |
|
методом касательных. Использованы обозначения: |
*/ |
|
/* |
X |
- |
начальное приближение корня |
*/ |
/* |
Eps |
- погрешность вычисления корня уравнения; |
*/ |
|
/* |
N |
- |
число итераций |
*/ |
/******************************************************************/
double Round(double X, double Delta) { if (Delta <= 1E-9) {
puts("Неверное задание точности округления\n"); exit(1);
}
if (X > 0.0) {
return Delta * long(X / Delta + 0.5);
}else {
return Delta * long(X / Delta - 0.5);
8
}
}
double F(double x) {
// функция f(x)
extern double delta; double s;
long S;
s = pow(x, M_PI) - 1/(pow(x,4)+1);
s = Round(s, delta);
return s;
}
double F1(double x) {
// функция f'(x)
//double f = (M_PI * pow(x, M_PI + 7) + 2 * M_PI*pow(x, M_PI + 3) + M_PI * pow(x, M_PI - 1) + 4 * pow(x, 3)) / (pow(x, 8) + 2 * pow(x, 4) + 1);
return x;
}
double PHI(double x) {
// функция φ(x) - для метода простых итераций return x;
}
double BISECT(double Left, double Right, double Eps, int &N) { double E = fabs(Eps) * 2.0;
double FLeft = F(Left); double FRight = F(Right);
double X = 0.5 * (Left + Right); double Y;
if (FLeft * FRight > 0.0) { puts("Неверное задание интервала\n"); exit(1);
}
if (Eps <= 0.0) {
puts("Неверное задание точности\n");
9
exit(1);
}
if (FLeft == 0.0) { return Left;
}
if (FRight == 0.0) { return Right;
}
for (N = 0; Right - Left >= E; N++) {
X = 0.5 * (Right + Left); // вычисление середины отрезка
Y = F(X);
if (Y == 0.0) { return X;
}
if (Y * FLeft < 0.0) { Right = X;
}else { Left = X;
FLeft = Y;
}
}
return X;
}
#ifdef __ITER
double ITER(double X0, double Eps, int &N) { extern double PHI(double);
if (Eps <= 0.0) {
puts("Неверное задание точности\n"); exit(1);
}
double X1 = PHI(X0); double X2 = PHI(X1);
for (N = 2;
(X1 - X2) * (X1 - X2) > fabs((2 * X1 - X0 - X2) * Eps); N++) {
X0 = X1;
10