Estude fácil! Tem muito documento disponível na Docsity
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity
Encontra documentos específicos para os exames da tua universidade
Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade
Responda perguntas de provas passadas e avalie sua preparação.
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Trabalho de análise numerica que visa implementar, em linguagem qualquer, os métodos de newton, jordan, jacobi e bisseção
Tipologia: Trabalhos
1 / 21
Esta página não é visível na pré-visualização
Não perca as partes importantes!
João Monlevade, 24 de junho de 2015
Este trabalho objetiva fornecer levantamento bibliográfico dos métodos de Jordan, Jacobi, Newton e de Bisseção para raízes. Além disso, será implementados para a solução de problemas matemáticos que permitem sua utilização utilizando o programa MATLAB.
1) Sistemas Lineares Vários problemas encontrados nas áreas da ciências, tecnológia e econômica é o da solução numérica de um sistema linear Sn de n equações com n incógnitas. Por exemplo:
𝑛
𝑗= Podemos classificar um sistema linear quanto ao número de soluções em compatível (tem uma solução) e incompatível (não tem solução). Podemos ainda classificar os sistemas compatíveis em determinado (uma única solução) e indeterminado (mais de uma soluções). Abaixo vemos um exemplo de sistema linear.
𝑆 = { 𝑥 − 𝑦 = 0𝑥 + 𝑦 = 0
É possível observar que esse sistema é compatível porque tem uma solução. Além disso é determinada também pois apresenta uma única solução.
Metodo de Jordan
O método de Jordan consiste em transformar o sistema dado não apenas em um sistema triangular, mas sim em um sistema diagonal equivalente. Nesse método o pivô é utilizado para zerar todos os elementos de sua coluna (acima e abaixo de pivô). Em seguida pode-se encontrar a resolução de um sistema por esse método.
etc...
Percebe-se que os valores de X(i) vão se aproximando da solução exata, que é x 1 = 2 e x 2 = 1, a medida que é calculada novas iterações.
Resultados obtidos após x iterações:
Iterações X(k) 1 2,500 2, 2 1,500 -0, 3 2,625 1, 4 1,875 0, 5 2.156 1, ... ... Solução exata 2.000 1. Tabela 1
Pode-se observar que quanto mais iterações forem realizadas, mais próximo estará o vetor x da solução exata do sistema linear.
2) Cálculo de Raízes de uma função O cálculo da raiz de uma equação é dividido em duas fases:
Isolamento da raiz: encontrar um intervalo [𝑎, 𝑏] que contenha apenas uma raiz de 𝑓(𝑥) = 0 Refinamento da raiz: a partir de um valor inicial 𝑥 0 ∈ [𝑎, 𝑏], gerar uma sequencia {𝑥 1 , 𝑥 2 , 𝑥 3 , … , 𝑥𝑘} que convirja para a raiz exata de 𝑓(𝑥) = 0. Uma equação algébrica de grau n tem exatamente n raízes, reais ou complexas, contando cada raiz de acordo com sua multiplicidade.
O método gráfico é a maneira mais simples de encontrar um intervalo de uma função. Ele consiste em esboçar a função no intervalo de interesse e estimar o intervalo a partir da tentativa e erro.
Determinando-se um intervalo [𝑎, 𝑏], uma função possui uma raiz ou um numero ímpar de raízes caso 𝑓(𝑎). 𝑓(𝑏) < 0. Quando 𝑓(𝑎). 𝑓(𝑏) > 0, então a função não tem raízes no intervalo escolhido ou tem um numero par de raízes.
Convergencia e erro da raiz
Uma vez determinado o intervalo [𝑎, 𝑏] de uma raiz ξ, será gerado uma seqüencia {𝑥 1 , 𝑥 2 , 𝑥 3 , … , 𝑥𝑘, … , 𝜉} ∈ [𝑎, 𝑏] que convirja para a raiz exata ξ de 𝑓(𝑥) = 0. A geração dessa seqüencia de valores é interrompida quando se atinge um critério de parada:
|𝑥𝑘 − 𝑥𝑘−1| ≤ 𝜀 |𝑥𝑘 − 𝑥𝑘−1| 𝑥𝑘^ ≤ 𝜀 |𝑓(𝑥𝑘)| ≤ 𝜀
Sendo 𝜀 o erro estabelecido.
I) Método de Jordan Na implementação desse método, foi usado o programa computacional MATLAB para a solução de sistema lineares.
Inicialmente, todas as funções dentro do MATLAB deve começar declarando que m-file é uma função. Na primeira linha do código encontra-se as definições das função. Esta função resolve um conjunto de equações de primeira ordem, onde o principal coeficiente pode ser representando em uma matriz A tal que o sistema fique na forma de Ax = b. Nesta função deve=se entrar com o coeficiente da matriz A and a solução b.
Abaixo encontra-se a implementaçã completa do método Jordan.
function [x,err]= jordan_elim(A,b)
[n,m]=size(A); % size of matrix A
err =0;
x=zeros(n,1);
if n ~= m
disp('error: n~=m'); err = 1;
end
if length(b) ~= n
disp('erro: tamanho errado de b'); err = 2;
else
if size(b,2) ~= 1 b=b'; end
if size(b,2) ~= 1
disp('erro: b é uma matriz); err = 3; end
end
if err == 0
Aa=[A,b]; for i=1:n [Aa(i:n,i:n+1),err]=gauss_pivot(Aa(i:n,i:n+1)); if err == 0 Aa(1:n,i:n+1)=gauss_jordan_step(Aa(1:n,i:n+1),i); end end x=Aa(:,n+1);
end
A=0;
function A1=gauss_jordan_step(A,i)
[n,m]=size(A); % tamanho da matriz A
A1=A;
s=A1(i,1);
A1(i,:) = A(i,:)/s;
k=[[1:i-1],[i+1:n]];
for j=k
s=A1(j,1); A1(j,:)=A1(j,:)-A1(i,:)*s;
end
function [A1,err]=gauss_pivot(A)
[n,m]=size(A); % tamanho da matriz A
A1=A;
err = 0; % erro
if A1(1,1) == 0
check = logical(1); % logica(1) - VERDADE i = 1;
while check
for j=1:ne if(j~=i) soma = soma + mc(i,j)*VC(j)/A(i,i); end x(i) = (b(i)/mc(i,i)) - soma; end end if (abs(norm(x) - norm(VC))< E) parar = 0; else VC=x; end ni = ni + 1; end
disp('Resposta do sistema:'); disp(VC'); disp('Número de iterações utilizadas:'); disp(ni);
III) Método de Bisseção O método de bisseção deste trabalho foi implementado no programa de matemática computacional MATLAB, por oferecer linguagem que se adequa particularmente bem para os cálculos matemáticos exigidos para o presente método.
Para o cálculo, o usuário deverá entrar com 5 parâmetros: A função para a qual será calculada a raíz; O limite superior; O limite inferior; O valor do erro; O numero máximo de iterações; É essencial que o usuário conheça ou possa estimar ao menos um dos intervalos das raízes para que o programa calcule corretamente o que lhe é pedido. Caso estes sejam
desconhecidos, o próprio usuário pode tentar estima-los através do próprio matlab, que fornece o comando plot(eixo, função), cuja finalidade é plotar uma função em um gráfico.
Conhecida a função e os limites, basta executar o código abaixo:
%Entrada de parâmetros. disp('Insira a função'); f = input('','s'); disp('Insira o valor do intervalo inferior'); intI = input(''); disp('Insira o valor do intervalo superior'); intS = input(''); disp('Insira o valor do erro'); erro = input(''); disp('Insira o numero máximo de iterações'); iteracao = input('');
%Auxiliar para contagem de iterações executadas i = 1;
%O while será executado enquanto o numero execuções for menor que o %numero de iterações while (i < iteracao)
x = (intS+intI)/2; %realiza a operação [a,b]/ % %se f(x) = 0 ou se satisfeita a condição de erro, imprime o % valor da raiz, o valor do erro de o numero de iterações % necessárias para se chegar ao valor, e termina a execução if (subs(f,x) == 0 || (intS - intI) < erro) fprintf('A raiz é: %d \n', x); fprintf('Erro atingido: %d\n', intS - intI); fprintf('Numero de iterações realizadas: %d\n', i); break end %se sinal de f(x) = sinal de f(intI), x recebe valor intI. Senão, %x = intS if sign(subs(f,x)) == sign(subs(f, intI)) intI = x; else intS = x; end i = i + 1; %incrementa 1 à variável auxiliar
end
Caso o intervalo não possua raizes ou o numero de iterações escolhido não tenha sido adequado, não será encontrado e nem exibido nenhum valor.
raíz foi calculda, ou Info=1 significa que, com a tolerância e número máximo de iterações fornecidas, a raíz nao pode ser encontrada.
Algoritmo Newton-Raphson
{ Objetivo: calcular a raíz de uma equação pelo método de Newton-Raphson}
Parâmetros de entrada x0, Toler, Itermax
{valor inicial, tolerância e número máximo de iterações}
Parâmetros de saída: Raiz, Iter, Info
{raíz, número gasto de interações e informação, sendo Info=0: raiz calculada e Info=1: não convergiu}
𝑥 ← 𝑥0; 𝐼𝑡𝑒𝑟 ← 0; 𝑑𝑒𝑙𝑡𝑎𝑥 ← 1 repita 𝐹𝑥 ← 𝑓(𝑥); 𝐷𝐹𝑥 ← 𝑓′(𝑥) {avaliar a função e sua derivada em x} escreva Iter, x, Fx, DFx se (abs(deltax)≤Toler e abs(Fx)≤Toler) ou DFx=0 ou Iter≥IterMax entao interrompa fimse
deltax←Fx/DFx; x←x – deltax; Iter←Iter + 1; escreva deltax fimrepita Raiz←x {teste de convergência} se abs(deltax)≤Toler e abs(Fx)≤Toler entao Info← 0 senao
Info← 1
fimse
fimalgoritmo
Implementação no MATLAB
function [Raiz, Iter, Info] = newton_raphson(funcao, derivada, x0, Toler, IterMax, Exibe)
% newton_raphson calcular raiz de equacao pelo metodo Newton-Raphson
%
% Introducao ao MATLAB
%
% Parametros de entrada:
% funcao: cadeia de caracteres que especifica a funcao,
% derivada: cadeia de caracteres que especifica a derivada,
% x0: valor inicial,
% Toler: tolerancia no calculo da raiz,
% IterMax: numero maximo de iteracoes e
% Exibe: opcao para exibir resultados: 0 nao exibe e 1 exibe.
% Parametros de saida:
% Raiz: zero da funcao,
% Iter: numero de iteracoes e
% Info: informacao, sendo
% Info=0: convergiu e
% Info=1: nao convergiu com os parametros dados.
%
x = x0; Iter = 0; deltax = 1;
De acordo com as saídas obtidas, concluímos que para a função dada, encontra-se uma raíz 1,07912, utilizando-se de seis iterações. Além disso, como obtemos Info = 0, concluímos que o método convergiu.
Como já foi dito é de grande interesse como engenheiro o conhecimento desses métodos para a resolução de variados problema práticos.
Analisando os métodos de sistema linear: Jordan e Jacobi, não se pode garantir qual método é melhor. Entretando observa-se que os método diretos são mais satisfatório na resolução de sistema de pequeno porte com matrizes de coeficientes densa. Já os mpetodos interativo são mais utilizados na resolução de matrizes de grande porte com matrizes de coeficientes do tipo esparso.
Comparando agora os outros dois métodos, o de Bisseção é um método menos eficiente quando comparado com o de Newton, porem este fato é atenuado pela sua simplicidade e facilidade de implementação, constituindo uma poderosa ferramenta para a análise numérica e para a solução de funções por engenheiros e matemáticos.
