Cálculo Numérico
Cálculo Numérico
Cálculo Numérico
Encontrar raízes e encontrar pontos fixos são problemas equivalentes no seguinte sentido:
• Seja f(x) uma função contínua em [a, b], intervalo que contém uma raiz da equação
f(x) = 0. O Método do Ponto Fixo consiste em transformar esta equação em uma
equação equivalente x = Φ(x) e a partir de uma aproximação inicial gerar a sequência
{xk} de aproximações para a raiz R pela relação xk+1 = Φ(xk), pois a função Φ(x) é tal
que f(R) = 0 se e somente se Φ(R) = R. Assim, transforma-se o problema de encontrar
um zero de f(x) no problema de encontrar um ponto fixo de Φ(x). Uma função que
satisfaz essa condição é chamada função de iteração para a equação f(x) = 0.
Resumindo: se existir um α no intervalo [a,b] tal que α = Φ(α), este número é dito ponto
fixo de Φ e pode ser calculado pelo seguinte algoritmo, que é chamado de iterações de ponto
fixo:
Assim sendo, existe um teorema, o qual determina que, dado um intervalo I contendo
a raiz, para que a função φ(x) possa ser utilizada na implementação do método,
Exemplos:
1. Os algoritmos desenvolvidos a seguir têm como objetivo encontrar o valor de x para
valores negativos de E na seguinte função:
Método da Bissecção
Os resultados a seguir foram obtidos utilizando o valor E=-5 e ao chamarmos a função
no intervalo [0.66,0.76]. Alguns comandos incomuns foram utilizados no código, como deff.
Tal comando define a função que está contida nos parênteses e possibilita sua análise pelo
método descrito como "function[x]=Bisection_Method(f,A,B)". O método implementado
busca um valor intermediário em relação ao intervalo inicial para cada iteração realizada.
Analisando os valores da função para cada ponto obtido, o programa prossegue na busca de
uma raiz que satisfaça o critério de parada (proposto pelo exercício acima) utilizado.
deff('[y]=f(x)','y=[(-1-x)./x.^(3)]-E')
function[x]=Bisection_Method(f,A,B)
i=1;
Nmax=100;
Fa=f(A)
while i<=Nmax do
x=A+(B-A)./2;
F=f(x)
if (F==0|abs(B-A)./2< %eps.*max(1,abs(x))) then
disp(i,"Número de iterações: ");
return(x);
break;
end
i=i+1
if Fa.*F>0 then
A=x;
Fa=F;
else
B=x;
end
end
endfunction
Método da Falsa-Posição
Considerando E = -5 e o mesmo intervalo [0.66,0.76] (chamado na função) do Método da
Bissecção, podemos resolver o problema pelo Método de Falsa-Posição. Alguns comandos
incomuns foram utilizados no código, como deff. Tal comando define a função que está contida
nos parênteses e possibilita sua análise pelo método descrito como
"function[x]=False_Position(x0,x1,f)". Os parâmetros x0 e x1 são valores de x quaisquer
pertencentes a um intervalo onde a função é contínua. Caso contrário, o programa irá indicar
tal erro. Além disso, é necessário rodar o programa para que o método implementado seja
gravado pela máquina. Desse modo, não é necessário rodar o programa novamente para
obtermos os resultados esperados. Isso facilita o teste do método para diferentes intervalos sem
que o programa tenha que ser inicializado a cada mudança de parâmetro.
function[x]=False_Position(x0,x1,f)
i=2;
Nmax=100;
b0=f(x0);
b1=f(x1);
while i<=Nmax do
x=x1-(b1.*(x1-x0))./(b1-b0);
if (abs(x-x1))<%eps.*max(1,abs(x)) then
disp(i,"Número de iterações: ");
return(x);
break;
end
i=i+1;
q=f(x);
if (q.*b1<0) then
x0=x1;
b0=b1;
end
x1=x;
b1=q;
end
endfunction
Método de Newton-Raphson
Alguns comandos incomuns foram utilizados no código, como deff. Tal comando
define a função que está contida nos parênteses e possibilita sua análise pelo método descrito
como "function[x]=Newton_Raphson(xi,f,fd)". O parâmetro x0 representa um chute inicial
para a raiz procurada. Além disso, é necessário rodar o programa para que o método
implementado seja gravado pela máquina. Desse modo, não é necessário rodar o programa
novamente para obtermos os resultados esperados. Isso facilita o teste do método para
diferentes chutes iniciais sem que o programa tenha que ser inicializado a cada mudança de
parâmetro. O valor de E utilizado nos resultados descritos abaixo foi E = -5, para permitir uma
comparação mais fiel entre os códigos.
E=input("Entre com um valor negativo para E:")
deff('[y]=f(x)','y=[(-1-x)./x.^(3)]-E')
deff('[y] = fd(x)','y=(2*x+3)/x.^(4)')
x=(1:0.001:100)
y=f(x)
function[x]=Newton_Raphson(xi,f,fd)
Ni=100;
xx=xi;
while(Ni>0)
x=xi-f(xi)/fd(xi);
if abs(x-xi)<=%eps.*max(1,abs(x)) then
disp(100-Ni,"Número de iterações: ")
return(x);
break;
end;
Ni=Ni-1;
xi=x;
end;
endfunction
O máximo comprimento L de uma barra que pode passar de uma extremidade a outra
deslizando no solo, na situação acima, é dado por:
Alguns comandos incomuns foram utilizados no código, como deff. Tal comando define a
função que está contida nos parênteses e possibilita sua análise pelo método descrito como
"function[a]=Newton_Raphson(a0,f,fd)". O parâmetro x0 representa um chute inicial para a
raiz procurada. Além disso, é necessário rodar o programa para que o método implementado
seja gravado pela máquina. Desse modo, não é necessário rodar o programa novamente para
obtermos os resultados esperados. Isso facilita o teste do método para diferentes chutes iniciais
sem que o programa tenha que ser inicializado a cada mudança de parâmetro.
A função utilizada nesse código foi y=cos(p-a).cos(a).[b-c] + c.cos(p-a) - b.cos(a). O motivo
para a escolha desse formato para a expressão é a ausência de variáveis no denominador. Por
termos uma expressão com denominador comum igual a 1, excluímos uma das potenciais
fontes de erro.
c=10; //L2=c
b=8; //L1=b
p=2.*%pi./5;
g=3.*%pi./5;
tol=10.^(-12);
//y=cos(p-a).*cos(a).*(b-c)+c.*cos(p-a)- b.*cos(a)
deff('[y]=f(a)','y=cos(p-a).*cos(a).*(b-c)+c.*cos(p-a)- b.*cos(a)')
deff('[y] = fd(a)','y=(c-b).*sin(2.*a-p)+b.*sin(a)-c.*sin(a-p)')
a=(0:0.001:2.*%pi)
//y=f(a)
function[a]=Newton_Raphson(a0,f,fd)
Ni=100;
aa=a0;
while(Ni>0)
a=a0-f(a0)/fd(a0);
if abs(a-a0)<tol then
disp(100-Ni,"Número de iterações: ")
L=c./(sin(%pi-g-a))+b./(sin(a))
disp(L,"Comprimento máximo da barra: ");
return(a);
break;
end;
Ni=Ni-1;
a0=a;
end;
endfunction
Método da Secante
Alguns comandos incomuns foram utilizados no código, como deff. Tal comando define a
função que está contida nos parênteses e possibilita sua análise pelo método descrito como
"function[a]=Secante(x0,x1,f)". Os parâmetros x0 e x1 determinam um intervalo, cada extremo
com um determinado valor de função f(x0) e f(x1), para que o método possa iniciar as iterações.
Além disso, é necessário rodar o programa para que o método implementado seja gravado pela
máquina. Desse modo, não é necessário rodar o programa novamente para obtermos os
resultados esperados. Isso facilita o teste do método para diferentes chutes iniciais sem que o
programa tenha que ser inicializado a cada mudança de parâmetro.
c=10; //L2=c
b=8; //L1=b
p=2.*%pi./5;
g=3.*%pi./5;
tol=10.^(-12);
//y=cos(p-a).*cos(a).*(b-c)+c.*cos(p-a)- b.*cos(a)
deff('[y]=f(a)','y=cos(p-a).*cos(a).*(b-c)+c.*cos(p-a)- b.*cos(a)')
a=(0:0.001:2.*%pi)
//y=f(a)
function[x]=Secante(x0,x1,f)
i=2;
Nmax=100;
b0=f(x0);
b1=f(x1);
while i<=Nmax do
x=x1-(b1.*(x1-x0))./(b1-b0);
if (abs(x-x1)<%eps) then
disp(i,"Número de iterações: ");
L=c./(sin(%pi-g-x))+b./(sin(x))
disp(L,"Comprimento máximo da barra: ");
return(x);
break;
end
i=i+1;
q=f(x);
if (q.*b1<0) then
x0=x1;
b0=b1;
end
x1=x;
b1=q;
end
endfunction
Ao chamarmos a função "function[x]=Secante(0.3,0.7,f)" definida no código acima,
utilizamos os parâmetros x0=0.3 e x1=0.7:
-->Secante(0.3,0.7,f)
Número de iterações: 10.
Comprimento máximo da barra: 30.548969
ans =
0.5990104
para o cálculo da raiz quadrada de um número positivo a, sendo que k representa a k-ésima
iteração.
Inicialmente, estabelecemos um número positivo a = 10 para o cálculo de sua raiz. Com isso,
temos que a função de iteração é dada por: Φ(x) = x(x2+30)/(3x2+10). O ponto fixo p é tal que
Φ(p) = p, cuja única solução conveniente é p = √10, como determinado pelo método.
A derivada da função de iteração para a = 10 é dada por:
E a segunda derivada é:
-->Fixed_Point(1,0.0003,f)
Número de iterações: 7.
ans =
0.0173205