Дисциплина:
Раздел:
Выполнил:

Вычислительная математика

Метод деления отрезка пополам.

матфак, Петров И.

                                             www.domath.ru

>    #Метод деления отрезка пополам.

#Суть этого метода заключается в следующем:
#Для поиска решения выбирается начальный интервал, на
#котором будет выполняться поиск решения. Поиск осуществляется,
#если функция f(x) на границах интервала принимает значения разных знаков.

#Тогда это говорит о том, что на интервале имеется по крайней мере
#один корень уравнения. Далее определяется середина интервала, а
#также значение функции в этой точке. Такая серединная точка
#становится новой граничной точкой интервала - в эту точку
#смещается та граница интервала, для которой знак функции
#совпадает со знаком функции в серединной точке.

#Процесс продолжается до тех пор пока не будет выполнена заданная
#точность.

>    #Процедура double_div_otrezok(f,otrezok,epsilon)
#зависит от трёх параметров,
#где (f - Функция (фц),
          otrezok-отрезок,
          epsilon-заданная точность)


>   

double_div_otrezok:=proc(f,otrezok,epsilon)
                               local x,a,b,c,ff,i:
#локальные переменные пн

#левая часть отрезка присваиваем к пн x
x:=lhs(otrezok):

#Функция (фц) rhs - правая часть отрезка

a:=op( rhs( otrezok ) )[1]:
b:=op( rhs( otrezok ) )[2]:

#Вычисление функции в точке x до 4 знака
ff:=unapply(evalf(f),x):



#ниже заложен алгоритм метода
if (ff(a)*ff(b)>0)
                 then print("неверно введённый интервал"):
              
   #если произведение на концах отрезка больше 0,
                 #то это ошибка,


else                           
 #иначе продолжаем.
     if (ff(a)*ff(b)<0)
                      then
             
#если прозведение значений фц на концах отрезка больше 0,
#то есть существует корень на этом отрезке

#Здесь в условном операторе проверка заданной точности   
while (abs(b-a)>epsilon and f(c)<>0)
                                     do
#сюда мы попали, потому что большая погрешность и c - не корень
c:=(a+b)/2:


           if (ff(a)*ff(b)>0)
                              then a:=c:
                            
 
                                 #если произведение больше 0, то
                                  #то это значит, что функция f на
                                  #концах отрезка [a,b] разного
                                  # знака.Тогда переприсвиваем к a
                                  #значение c.
           else
    
           #иначе значение c присваиваем к b
               b:=c:

           fi:




#конец цикла
end do:
else
            if (ff(a)=0)
                          then c:=a:
                              
  #если значение функции ff в текущей точке a равно 0, то
                                #переприсваиваем значение c
             else
                          c:=b:
                             
   #иначе присваиваем значение b
             end if:
  end if:

#представление числа с плавающей точкой
x:=evalf(c):

end if:

#конец процедуры
end proc;                       

double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...
double_div_otrezok := proc (f, otrezok, epsilon) local x, a, b, c, ff, i; x := lhs(otrezok); a := op(rhs(otrezok))[1]; b := op(rhs(otrezok))[2]; ff := unapply(evalf(f),x); if 0 < ff(a)*ff(b) then print...

>    #Давайте теперь на конкретном примере продемонстрируем использование данной процедуры

>    #зададим фц

>    f:=x*(x-2.255)*(x+1);

f := x*(x-2.255)*(x+1)

>    #отрезок, на котором отыскивается решение  

>    a:=2:
b:=3:

>    #для графического отображения полученого решения воспользуемся функцией plot
#построения графики f на отрезке [1.5, 3.5]

>    graph:=plot(f,x=1.5..3.5):

>    #Итак, по методу деления отрезка пополам

>    x_корень:=double_div_otrezok(f,x=a..b,0.0001):

#вычислим значение функции в точке x_корень, что
#с помощью функции subs
 

>    y_корень:=subs(x=x_корень,f):

>    #Для отображения графических объектов на экране воспользуемся пакетом plots

>    with(plots):

#данная команда строит точку с координатами
#[x_корень,y_корень], цвет задан синий
p:=pointplot([x_корень,y_корень],color=blue):

>    #отображение всех графических объектов на экране дисплея.

>    display(graph,p);

метод деления отрезка пополам

>    #Теперь можно сохранить данную процедуру
#и использовать её по назначению в любом приложении Maple

>    save double_div_otrezok "double_div_otrezok.m";

#функция Save сохранит процедуру double_div_otrezok в модуле double_div_otrezok.m
#Теперь всякий раз, когда захотите использовать данную процедуру
# в своих программах укажите в начале read "double_div_otrezok.m",;
#то есть подключите таким образом данный модуль.
#Модуль должен находится в той же папке, что и программа.