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

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

Метод хорд.

матфак, Васильев С.

                                             www.domath.ru

>    #Метод хорд

>    #Процедура horda(f,otrezok,eps,M)
#зависит от 4 параметров,


 
#где (f - уравнение (фц),
#          otrezok-отрезок,
#          eps-заданная точность,M-минимальное значение производной)




>    horda:=proc(f,otrezok,eps,M)
                               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):


c:= b - ff(b)*(b-a)/(ff(b)-ff(a)):
#зададим параметр c


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

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

#Здесь в условном операторе проверка заданной точности
#M можно взять, как верхнее значение производной
  


while (abs(ff(c)/M)>eps and f(c)<>0)
                                     do
#сюда мы попали, потому что большая погрешность и c - не корень

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

           fi:



c:=b-ff(b)*(b-a)/(ff(b)-ff(a))
:#иначе c равно
#конец цикла
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;                       

horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...
horda := proc (f, otrezok, eps, M) 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); c := b-ff(b)*(b-a)/(ff(b)-ff(a)); if 0 < ff...

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

>    #зададим фц

>    f:=-0.55+exp(-t);

f := -.55+exp(-t)

>    t_корень:=fsolve(f,t);

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

>    a:=0:
b:=3:

>    #для графического отображения полученого решения воспользуемся функцией plot
#построения графики f на отрезке [0, 3.5]
graph:=plot(f,t=0..3.5):

`t_корень` := .5978370008

>    #Итак, по методу хорд

>    x_корень:=horda(f,t=0..3,0.0001,evalf(exp(-3)));

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

`x_корень` := .5978440917

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

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

>    with(plots):

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

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

>    display(graph,p);

метод хорд

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

>    save horda, "horda.m":

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