Exercícios Zeros de Funções

Exercícios Zeros de Funções
Cálculo Numérico, Turma A
Profª. Dra. Tina Andreolla
Data: 22/04/2008.
Nome: Laure Max Da Silva Palma
Curso: Engenharia Industrial Elétrica
1. Dê um exemplo de função f(x), que tenha pelo menos uma raiz, que não pode
ser determinada usando o Método da Bisseção.
> f1:= x-> x^2-4*x + 4;
f1 := x → x2 − 4 x + 4
> plot(f1(x),x=-1..4);
2. Dê um exemplo de função f(x), que tenha pelo menos uma raiz, onde o Método
de Newton-Raphson não converge.
> f2:= x-> arctan(x);
f2 := arctan
> plot(f2(x),x=-3..3);
3) A equação x^2-7x + 12 = 0 tem 3 e 4 como raízes. Considere a função de
iteração dada por fit(x) = x^2 - 6x + 12. Determine o intervalo (a; b), onde
para qualquer que seja x0 escolhido a sequência X n+1 = fit (Xn) converge para a
raiz x = 3. Mostre que a convergência é quadrática.
> mpfixo(2.2,f1,fit1,0.001,15);
#nota-se que usando x0=2.2 a função converge para a raiz 3.
1, "xk=", 2.2, "f(kx)=", 1.44, "phi(xk)=", 3.64
2, "xk=", 3.64, "f(kx)=", -.2304, "phi(xk)=", 3.4096
3, "xk=", 3.4096, "f(kx)=", -.24182784, "phi(xk)=", 3.16777216
4, "xk=", 3.16777216, "f(kx)=", -.13962466, "phi(xk)=", 3.02814750
5, "xk=", 3.02814750, "f(kx)=", -.02735522, "phi(xk)=", 3.000792282
3.000792282
4. Para determinar a raiz quadrada de um número c >= 0, basta resolver a equação
x^2-c = 0. É possível determinar sua raiz quadrada usando a função de iteração
fit(x) = c/x. Justifique a resposta.
Condição para convergência
-1 < diff(fit(x),x) < 1
sabe-se que r1= sqrt(c) e r2=-sqrt(c)
então |diff(fit(x),x)| = c /|x^2| <1, logo |x^2| > c, portanto |x|>sqrt(c)
Como r1 e r2 nao pertecem ao intervalo I=(-inf,-sqrt(c))U(sqrt(c),+inf), logo nao é possivel.
5) As funções de iterações fit1(x) = x^2/2-2x+4 e fit2(x) = x^2/2-2.5x+5, geram
sequências convergentes para a raiz x = 2, para qualquer aproximação inicial
x0 pertence (1.5; 3). Qual das duas funções geram sequências mais rapidamente
convergente para esta raiz. Justifique a resposta.
> fit1:= x-> x^2/2 - 2*x +4;
fit1 := x →
1
2
x2 − 2 x + 4
> diff(fit1(x),x);
x−2
Nas proximidades de x=2 temos fit1´(2)=0
> fit2:= x-> x^2/2 - 2.5*x +5;
fit2 := x →
1
2
x2 − 2.5 x + 5
> diff(fit2(x),x);
x − 2.5
Nas proximidades de x=2 temos fit2´(2)=0.5
Logo, | fit1´(2) |< | fit2´(2) |, entao fit1´(2) convergirá mais rapido para raíz.
6. Determine um intervalo (a; b) e uma fun¸c˜ao de iteração fit(x) associada, de tal
forma que para todo x0 pertencente (a; b) a função de iteração gere uma sequância convergente
para a(s) raiz(es) de cada uma das funções abaixo, usando o método iterativo
linear (MIL) com tolerância com erro de 0.001.
> f1:= x-> sqrt(x)- exp(-x);
fit11:= x-> exp(2*x);
f1 := x → x − e
( −x )
(2 x)
fit11 := x → e
> plot([f1(x),fit11(x)],x=-4..4,y=-10..10);
um bom intervalo I=(0.42,0.44)
usando x0=0.43, temos:
> mpfixo := proc(x0,fun,phi,erro,itmax)
local xk :: real, i :: integer;
xk:=x0;
for i from 1 by 1 while ( abs(fun(xk)) > erro) and (i <=itmax)
do
print(i,"xk=",xk,"f(kx)=",evalf(fun(xk)),"phi(xk)=",evalf(phi(xk
)));
xk:= evalf(phi(xk));
end do;
end proc;
mpfixo := proc(x0, fun, φ, erro, itmax)
local xk::real, i::integer;
xk := x0;
for i while erro < abs( fun( xk ) ) and i ≤ itmax do
print( i, "xk=", xk, "f(kx)=", evalf( fun( xk ) ), "phi(xk)=", evalf( φ( xk ) ) ) ;
xk := evalf( φ( xk ) )
end do
end proc
> mpfixo(0.43,f1,fit11,0.001,15);
1, "xk=", .43, "f(kx)=", .0052347577, "phi(xk)=", 2.363160694
2, "xk=", 2.363160694, "f(kx)=", 1.443135263, "phi(xk)=", 112.8795576
3, "xk=", 112.8795576, "f(kx)=", 10.62447917, "phi(xk)=", .1111572953 1099
4, "xk=", .1111572953 1099, "f(kx)=", .1054311601 1050, "phi(xk)=", Float( ∞ )
5, "xk=", Float( ∞ ), "f(kx)=", Float( ∞ ), "phi(xk)=", Float( ∞ )
6, "xk=", Float( ∞ ), "f(kx)=", Float( ∞ ), "phi(xk)=", Float( ∞ )
7, "xk=", Float( ∞ ), "f(kx)=", Float( ∞ ), "phi(xk)=", Float( ∞ )
8, "xk=", Float( ∞ ), "f(kx)=", Float( ∞ ), "phi(xk)=", Float( ∞ )
9, "xk=", Float( ∞ ), "f(kx)=", Float( ∞ ), "phi(xk)=", Float( ∞ )
10, "xk=", Float( ∞ ), "f(kx)=", Float( ∞ ), "phi(xk)=", Float( ∞ )
11, "xk=", Float( ∞ ), "f(kx)=", Float( ∞ ), "phi(xk)=", Float( ∞ )
12, "xk=", Float( ∞ ), "f(kx)=", Float( ∞ ), "phi(xk)=", Float( ∞ )
13, "xk=", Float( ∞ ), "f(kx)=", Float( ∞ ), "phi(xk)=", Float( ∞ )
14, "xk=", Float( ∞ ), "f(kx)=", Float( ∞ ), "phi(xk)=", Float( ∞ )
15, "xk=", Float( ∞ ), "f(kx)=", Float( ∞ ), "phi(xk)=", Float( ∞ )
Float( ∞ )
> f2:= x-> ln(x)-x+2;
fit12:= x-> exp(x-2);
f2 := x → ln( x ) − x + 2
fit12 := x → e
> plot({f2(x),x,fit12(x)},x= -4..4);
(x − 2)
> mpfixo(0.43,f2,fit12,0.001,15);
1, "xk=", .43, "f(kx)=", .726029930, "phi(xk)=", .2080451824
2, "xk=", .2080451824, "f(kx)=", .221954818, "phi(xk)=", .1666341117
3, "xk=", .1666341117, "f(kx)=", .041411070, "phi(xk)=", .1598745413
4, "xk=", .1598745413, "f(kx)=", .006759571, "phi(xk)=", .1587975023
5, "xk=", .1587975023, "f(kx)=", .001077039, "phi(xk)=", .1586265632
.1586265632
> f3:= x-> exp(x/2)-x^3;
fit13:= x-> exp(x/6);
(1 / 2 x)
f3 := x → e
− x3
(1 / 6 x)
fit13 := x → e
> plot({f3(x),x,fit13(x)},x= -4..4);
> mpfixo(0.43,f2,fit12,0.001,15);
1, "xk=", .43, "f(kx)=", .726029930, "phi(xk)=", .2080451824
2, "xk=", .2080451824, "f(kx)=", .221954818, "phi(xk)=", .1666341117
3, "xk=", .1666341117, "f(kx)=", .041411070, "phi(xk)=", .1598745413
4, "xk=", .1598745413, "f(kx)=", .006759571, "phi(xk)=", .1587975023
5, "xk=", .1587975023, "f(kx)=", .001077039, "phi(xk)=", .1586265632
.1586265632
7. Determine a(s) raiz(es) da função f1(x), usando o método da Bisseção, Método
da Falsa posição e da Falsa posição modificada com erro de 0.001.
Quantas iterações foram necessárias para cada um dos métodos.
> bisseccao := proc(a,b,fun,erro)
local a1, b1, med :: real, i :: integer;
a1:=a; b1:=b;
for i from 1 by 1 while ( abs(a1-b1) > erro) do
print(i,a1,b1,evalf(fun(a1)),
evalf(fun(b1)));
med := evalf((a1+b1)/2);
if (evalf(fun(med))*evalf(fun(a1)) <= 0) then b1:=med
else a1:=med end if;
end do;
end proc;
bisseccao := proc(a, b, fun, erro)
local a1, b1, med::real, i::integer;
a1 := a;
b1 := b;
for i while erro < abs( a1 − b1 ) do
print( i, a1, b1, evalf( fun( a1 ) ), evalf( fun( b1 ) ) ) ;
med := evalf( 1 / 2∗a1 + 1 / 2∗b1 ) ;
if evalf( fun( med ) )∗evalf( fun( a1 ) ) ≤ 0 then b1 := med else a1 := med end if
end do
end proc
> posfalsa := proc(a,b,fun,erro)
local a1, b1, ptpf :: real, i :: integer;
a1:=a; b1:=b;
for i from 1 by 1 while (( evalf(abs(a1-b1)) > erro) and
(evalf(abs(fun(a1))) > erro) and
(evalf(abs(fun(b1))) > erro) ) do
print(i,"a=",a1,"b=",b1,"f(a)=",evalf(fun(a1)),"f(b)=",evalf(fun
(b1)));
ptpf := evalf((b1 * fun(a1) - a1 *
fun(b1))/(fun(a1)-fun(b1)));
if (evalf(fun(ptpf)) = 0) then a1:=ptpf; b1:=ptpf;
else if (evalf(fun(ptpf)*fun(a1)) < 0) then b1:=ptpf;
else a1:=ptpf end if;
end if;
end do;
if (evalf(abs(fun(b1))) < evalf(abs(fun(a1)))) then a1:=b1;
print(a1) end if
end proc;
posfalsa := proc(a, b, fun, erro)
local a1, b1, ptpf::real, i::integer;
a1 := a;
b1 := b;
for i while erro < evalf( abs( a1 − b1 ) ) and erro < evalf( abs( fun( a1 ) ) ) and
erro < evalf( abs( fun( b1 ) ) ) do
print( i, "a=", a1, "b=", b1, "f(a)=", evalf( fun( a1 ) ), "f(b)=", evalf( fun( b1 ) ) ) ;
ptpf := evalf( ( b1∗fun( a1 ) − a1∗fun( b1 ) ) / ( fun( a1 ) − fun( b1 ) ) ) ;
if evalf( fun( ptpf ) ) = 0 then a1 := ptpf ; b1 := ptpf
else if evalf( fun( ptpf )∗fun( a1 ) ) < 0 then b1 := ptpf else a1 := ptpf end if
end if
end do;
if evalf( abs( fun( b1 ) ) ) < evalf( abs( fun( a1 ) ) ) then a1 := b1 ; print( a1 ) end if
end proc
> bisseccao(0,1,f1,0.001);
1, 0, 1, -1., .6321205588
2, 0, .5000000000, -1., .1005761215
3, .2500000000, .5000000000, -.2788007831, .1005761215
4, .3750000000, .5000000000, -.0749168431, .1005761215
5, .3750000000, .4375000000, -.0749168431, .0157893014
6, .4062500000, .4375000000, -.0287661715, .0157893014
7, .4218750000, .4375000000, -.0062969585, .0157893014
8, .4218750000, .4296875000, -.0062969585, .0047931195
9, .4257812500, .4296875000, -.0007400701, .0047931195
10, .4257812500, .4277343750, -.0007400701, .0020294728
.4267578125
> posfalsa(0,1,f1,0.001);
1, "a=", 0, "b=", 1, "f(a)=", -1., "f(b)=", .6321205588
2, "a=", 0, "b=", .6126998367, "f(a)=", -1., "f(b)=", .2408655637
3, "a=", 0, "b=", .4937681039, "f(a)=", -1., "f(b)=", .0923640502
4, "a=", 0, "b=", .4520179000, "f(a)=", -1., "f(b)=", .0359799856
5, "a=", 0, "b=", .4363191433, "f(a)=", -1., "f(b)=", .0141331858
6, "a=", 0, "b=", .4302385025, "f(a)=", -1., "f(b)=", .0055717185
7, "a=", 0, "b=", .4278546172, "f(a)=", -1., "f(b)=", .0021997840
.4269154953
Para o metodo da Bissecção foram necessárias 10 interações, já para o metodo da posição falsa
apenas 7.
8. Determine as raízes do exercício (6), usando o Método de Newton-Raphson.
Para facilitar a minha vida e a correçao pegarei apenas um exemplo. Desculpa Prof e obrigado.
pegarei a (d).
> f4:= x-> sin(x)-x^2;
f4 := x → sin( x ) − x2
> plot(f4(x),x=-1..2);
> newton := proc(x0,fun,erro,itmax)
local dfun, xa, xb :: real, i :: integer;
dfun:= unapply(diff(fun(x),x),x);
xa:=x0;
xb:=evalf(xa-fun(xa)/dfun(xa));
for i from 0 by 1 while ( abs(fun(xb)) > erro or abs(xb-xa) >
erro) and (i < itmax) do
print(i,"xk=",xa,"f(xk)=",evalf(fun(xa)));
xa := xb;
xb := evalf(xa-fun(xa)/dfun(xa));
end do;
print(i,"xk=",xb,"f(xk)=",evalf(fun(xb)));
end proc;
newton := proc(x0, fun, erro, itmax)
local dfun, xa, xb::real, i::integer;
dfun := unapply( diff( fun( x ), x ), x ) ;
xa := x0;
xb := evalf( xa − fun( xa ) / dfun( xa ) ) ;
for i from 0 while ( erro < abs( fun( xb ) ) or erro < abs( xb − xa ) ) and i < itmax do
print( i, "xk=", xa, "f(xk)=", evalf( fun( xa ) ) ) ;
xa := xb;
xb := evalf( xa − fun( xa ) / dfun( xa ) )
end do;
print( i, "xk=", xb, "f(xk)=", evalf( fun( xb ) ) )
end proc
> newton(0.6,f4,0.001,15);
0, "xk=", .6, "f(xk)=", .2046424734
1, "xk=", 1.146202099, "f(xk)=", -.4025732857
2, "xk=", .9321189716, "f(xk)=", -.0659608437
3, "xk=", .8801036414, "f(xk)=", -.0037775096
4, "xk=", .8767262156, "f(xk)=", -.2 10-9
9. Determine as raízes do exercício (6), usando o Método das Secantes.
> secante := proc(x0,x1,fun,erro,itmax)
local xa, xb, xc :: real, i :: integer;
xa:=x0;
xb:=x1;
for i from 0 by 1 while ( abs(fun(xb)) > erro or abs(xb-xa)
> erro) and (i < itmax) do
print(i,"xk=",xa,"f(xk)=",evalf(fun(xa)));
xc := evalf((xa*fun(xb)-xb*fun(xa))/(fun(xb)-fun(xa)));
xa:=xb;
xb:=xc;
end do;
print(i,"xk=",xb,"f(xk)=",evalf(fun(xb)));
end proc;
secante := proc(x0, x1, fun, erro, itmax)
local xa, xb, xc::real, i::integer;
xa := x0;
xb := x1;
for i from 0 while ( erro < abs( fun( xb ) ) or erro < abs( xb − xa ) ) and i < itmax do
print( i, "xk=", xa, "f(xk)=", evalf( fun( xa ) ) ) ;
xc := evalf( ( xa∗fun( xb ) − xb∗fun( xa ) ) / ( fun( xb ) − fun( xa ) ) ) ;
xa := xb;
xb := xc
end do;
print( i, "xk=", xb, "f(xk)=", evalf( fun( xb ) ) )
end proc
> secante(0.6,0.9,f4,0.001,10);
0, "xk=", .6, "f(xk)=", .2046424734
1, "xk=", .9, "f(xk)=", -.0266730904
2, "xk=", .8654068797, "f(xk)=", .0124300517
3, "xk=", .8767308208, "f(xk)=", -.51294 10-5
10) ???
11. Determine o ponto de intersecção entre as funções f1(x) e f2(x), f2(x) e f3(x)
e entre f1(x), f2(x) e f3(x).
Para encontrar o ponto em que as funções se interceptam basta igualar ambas
f1(x)=f2(x)
disto vem que x= exp(sqrt(x)-exp(-x)+x-2);
> x:= x->exp(sqrt(x)-exp(-x)+x-2);
x := x → e
> plot({f1(x),x,x(x)},x=-1..2);
( x −e
( −x )
+ x − 2)
> h1:= x-> sqrt(x)-exp(-x)-ln(x)+x-2;
h1 := x → x − e
> plot(h1(x),x=-2..2);
( −x )
− ln( x ) + x − 2
> newton(0.07,h1,0.001,15);
0, "xk=", .07, "f(xk)=", .061441348
1, "xk=", .07619976706, "f(xk)=", .8615 10-5
> newton(1.4,h1,0.001,15);
0, "xk=", 1.399846311, "f(xk)=", .1 10-8
Logo o ponto de intersecção é P=(1.39984,0.0762).
12)
Substituindo os valores na equação dada obtemos:
arctg(x)= arctg(0)+ (x-0)f´(x/2)
logo arctg(x)= x f´(x/2)
sabendo que arctg(x)= 1/(1+x^2), temos
arctg(x)= 4x/(4+x^2)
usando o método de Newton obtemos:
> f5:= x-> arctan(x)- 4*x/(x^2 +4); #usando x0=1.4
f5 := x → arctan( x ) −
4x
x2 + 4
> newton(1.4,f5,0.001,15);
# entao x = 1.2856
0, "xk=", 1.4, "f(xk)=", .0109495252
1, "xk=", 1.298726585, "f(xk)=", .0011069130
2, "xk=", 1.285643813, "f(xk)=", .54 10-8