Apostila Métodos Numéricos Aplicados Parte 1

Prévia do material em texto

UNIVERSIDADE ESTADUAL DO MARANHÃO - UEMA 
CENTRO DE CIÊNCIAS TECNOLÓGICAS – CCT 
CURSO DE ENGENHARIA MECÂNICA 
ESPECIALIZAÇÃO EM MECÂNICA COMPUTACIONAL 
 
 
 
 
 
 
 
 
MÉTODOS NUMÉRICOS 
Prof. Eng. Carlos Ronyhelton Santana de Oliveira 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
São Luís 
2018
 
 
SUMÁRIO 
 
1. INTRODUÇÃO ................................................................................................................. 1 
2. POR QUE ESTUDAR MÉTODOS NUMÉRICOS?........................................................... 2 
3. RAÍZES DE FUNÇÕES REAIS ........................................................................................ 4 
3.1 Problema 1 .................................................................................................................. 4 
3.2 Problema 2 .................................................................................................................. 4 
3.3 Método da Bissecção ................................................................................................... 5 
 3.3.1 Programando o Método da Bissecção ............................................................ 5 
3.4 Método de Newton-Raphson........................................................................................ 7 
 3.4.1 Programando a Função newton1 ................................................................... 8 
3.5 Método da Secante....................................................................................................... 9 
4. SISTEMAS LINEARES E NÃO LINEARES .................................................................. 10 
4.1 Problema 3: ............................................................................................................... 11 
4.2 Método de Jacobi ....................................................................................................... 11 
4.3 Método de Gauss-Seidel ............................................................................................ 12 
 4.3.1 Programando a Função GaussS .................................................................... 13 
4.4 Método de Newton-Raphson...................................................................................... 14 
5. INTERPOLAÇÃO POLINOMIAL .................................................................................. 15 
5.1 Problema 4: ............................................................................................................... 15 
5.2 Polinômio de Lagrange .............................................................................................. 16 
 5.2.1 Programando a Função InterpLagrange ........................................................ 16 
6. LISTA DE FUNÇÕES/COMANDOS/OPERADORES DO MATLAB ............................ 19 
7. REFERÊNCIAS ............................................................................................................... 21 
 
 
 
 
 
 
 
1 
 
1. INTRODUÇÃO 
 
O objetivo deste curso é auxiliar a todos os estudantes do curso de Especialização 
em Mecânica Computacional que querem obter conhecimentos em Métodos Numéricos e ao 
mesmo tempo compreender a formulação de seus algoritmos na linguagem de programação 
do MATLAB®, para que dessa forma, adquiram competências necessárias para solução de 
diversos problemas relacionados à engenharia. 
A escolha da referida plataforma se deu pela sua grande quantidade de recursos e 
funções nativas que por si só já facilitam muito a vida do usuário na resolução de problemas 
cujas soluções demandem aplicações de métodos numéricos e isso somado ao fato de que sua 
linguagem possui amplas facilidades de programação oferecidas ao usuário que dependa de 
implementar rotinas ou funções de mesma natureza. Sob esses aspectos a plataforma 
MATLAB® se torna mais recomendada para a finalidade deste curso do que mesmo outras 
linguagens de programação de uso técnico e científico como C/C++, Fortran ou Python. 
Os principais tópicos abordados nesta apostila divididos por grandes áreas de 
atuações são: 
 
 Métodos para obtenção de raízes de funções reais: 
 Resolução de sistemas lineares e não lineares 
 Interpolação polinomial 
 Diferenciação e integração numérica 
 Métodos para problemas de valor inicial (PVIs) 
 
A contextualização com problemas reais de engenharia para cada um desses temas 
será feita através de estudos de casos que serão apresentados no inicio de cada novo capítulo 
associando-se a necessidade do estudo aprofundado desses temas como única opção para 
resolução dos mesmos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2 
 
2. POR QUE ESTUDAR MÉTODOS NUMÉRICOS? 
 
A resposta mais adequada a essa pergunta parte da própria essência dos métodos 
numéricos de serem algoritmos baseados em lógicas e operações matemáticas simples e que 
mesmo resultando em soluções baseadas em aproximações não deixam de serem ferramentas 
extremamente poderosas na resolução de problemas de diversas naturezas, não se prendendo 
“apenas” ao grande universo das ciências básicas e engenharias, mas tendo também 
aplicações em economia, meteorologia, astronomia, administração, e mesmo em áreas de 
saúde. 
A capacidade dos métodos numéricos de resolverem um número muito grande de 
equações decorrentes de problemas reais transcritos em modelos matemáticos, solucionar 
problemas de não linearidade e geometrias complexas (cenários muito presentes dentro das 
mais diversas engenharias nos quais os procedimentos analíticos de cálculo não ofertam 
respostas mesmo que se prove que haja soluções possíveis) exemplifica muito bem a distinção 
de atuação e quão vasto é o universo de aplicações existentes para os métodos numéricos. 
Vários matemáticos renomados (para os quais existem métodos que levam os seus 
nomes) como Newton, Laplace, Euler, Gauss, etc. se empenharam no desenvolvimento desse 
ramo do conhecimento que de fato teve real intensificação de utilização após a evolução 
necessária da computação. A capacidade de execução de rotinas de cálculos muito extensas e 
cansativas para seres humanos trabalharem manualmente atrelado as possibilidades criadas 
em resultados gráficos exuberantes e animações com alta riqueza de fidelidade tornaram os 
computadores elementos de altíssima requisição dentro dos estudos e aplicações dos métodos 
numéricos. 
A implementação desses algoritmos, que funcionam por iterações responsáveis 
por criar as aproximações exigidas nas soluções, demanda muito esforço humano e tempo 
para os quais a computação moderna oferta desde facilidades de programação em linguagens 
técnico científicas (como exemplificado com o MATLAB) à opções de processamento 
altamente poderosas, fatos que proporcionam entregas de respostas em intervalos de tempo 
extremamente mais reduzidos e soluções gráficas inigualáveis. É neste cenário que se destaca 
a importância do desenvolvimento desta disciplina atrelada a prática de programação de 
computadores. 
Um exemplo significativo para ilustrar essa necessidade de infraestrutura 
computacional é apresentado no capítulo 4 (Resolução de sistemas lineares e não lineares) 
onde a distribuição estacionária de temperatura em uma placa submetida a 4 temperaturas 
bem distintas em suas arestas pode ser modelada pela Equação de Laplace. Se a mesma placa 
for tomada como uma malha de 75x75 nós (ver figura 1) do qual se quer prever as 
temperaturas em cada um deles (tomado do conhecimento das temperaturas de todas as quatro 
arestas) e as derivadas segundas forem substituídas por diferenças divididas finitas centradasresultam em um sistema de equações lineares de 5625 variáveis e o mesmo número de 
equações para serem resolvidas em 1806 iterações pelo método de Gauss-Seidel como pode 
ser visualizado na figura abaixo. 
 
 
 
3 
 
Figura 1 – Distribuição de temperaturas em uma malha de 75x75 pontos 
 
Além de tudo isso, um engenheiro com conhecimentos profundos sobre os 
métodos numéricos e suas possibilidades vastas de aplicações está muito mais preparado para 
utilizar softwares de simulação e ser realmente capaz de analisar e interpretar seus resultados 
e realizar julgamentos sobre suas coerências do que qualquer outro engenheiro menos íntimo 
desse ramo do conhecimento. 
Inúmeras falhas catastróficas históricas já ocorreram por problemas de má 
utilização de sistemas computacionais que operavam com manipulação de procedimentos 
numéricos. Um exemplo disso se desenvolveu com o famoso caso do Foguete Ariane 5. Seu 
software de trajetória de voo operava com uma função que recebeu um valor de 64 bits em 
ponto flutuante, enquanto esperava apenas um inteiro de 16 bits sem sinal, fato que levou a 
um procedimento de manobra inesperado tendo consequentemente proporcionado à explosão 
do mesmo. Todo o problema do Ariane 5 girou em torno da capacidade do armazenamento do 
sistema comportar tal valor adquirido em tempo real, impasse que sua rotina de tratamento de 
dados deveria estar totalmente condicionada a resolver por se tratar de um problema clássico 
em cálculos numéricos. 
 
Figura 2 - Desastre do Ariane 5 por overflow 
 
Fonte: BBC (2012) 
4 
 
3. RAÍZES DE FUNÇÕES REAIS 
 
Neste capítulo vamos estudar métodos numéricos para obtenção de soluções de 
equações algébricas lineares e não lineares. O objetivo é determinar os valores de x ∈ ℝ que 
anulam a função f, isto é, resolver a equação para: 
𝑓(𝑥) = 0 
Problemas clássicos de engenharia recaem sobre modelos matemáticos que estão 
associados a expressões não lineares para o qual o nível de complexidade das soluções e até 
mesmo impossibilidades por métodos analíticos se torna realidade. A análise dos casos abaixo 
demonstra a necessidade de aplicação dos métodos numéricos para resolver esses tipos de 
problemas. 
 
3.1 Problema 1 
 
(Chapra, 2013) - Os rolamentos de rolos cilíndricos da figura abaixo estão sujeitos a falhas 
por fadiga causadas por grandes cargas de contato F. 
 
Figura 3 – Rolamento de rolos 
 
Fonte: Chapra (2013) 
 
Pode-se mostrar que o problema de determinar a localização da tensão máxima ao 
longo do eixo x é equivalente a maximizar a função: 
 
𝑓(𝑥) = 
0,4
√1 + 𝑥²
− √1 + 𝑥2 (1 −
0,4
1 + 𝑥2
) + 𝑥 
 
Encontre o x que maximiza a f(x). 
 
3.2 Problema 2 
 
(UNIVESP, 2013) Um fabricante de graxas tem 60% de seu faturamento da venda em latas de 
200 cm³. Ele precisa renovar seu estoque de latas vazias e quer manter o formato cilíndrico, 
mas usando o mínimo de material. Quais as dimensões que essas latas devem ter? 
Lembrando que : 
 
5 
 
V(r, h) = πr²h 
𝑀(𝑟, ℎ) = 2πr² + 2πrh 
 
 
3.3 Método da Bissecção 
 
Como pontos de entradas do algoritmo fornecemos um intervalo [a, b] tal que a 
função tenha sinais contrários nos seus extremos, ou seja, f(a)*f(b)<0. Divide-se o intervalo 
ao meio (𝑥𝑛 = 
𝑎+𝑏
2
, para n = 1, 2, 3, ...) e prossegue-se escolhendo o subintervalo onde a 
função continua apresentado sinais contrários nos extremos e assim sucessivamente até o 
critério de parada ser satisfeito (|𝑥𝑛 − 𝑥𝑛−1| < 𝐸𝑟𝑟𝑜 𝑜𝑢 𝑓(𝑥𝑛) = 0). 
 
Figura 4 – Continuidade de f(x) no intervalo [a, b] 
 
O número de iterações necessárias por esse método pode ser previsto por: 
 
𝑛 ≥
𝑙𝑜𝑔(𝑏 − 𝑎) − log (𝐸𝑟𝑟𝑜)
log (2)
 
 
3.3.1 Programando o Método da Bissecção 
 
Exibe-se abaixo o algoritmo do método programado na linguagem do MATLAB: 
 
clc; 
clear all; 
 
%Etapa 1: Entradas do método da bissecção 
fprintf('Digite a função: \n'); 
f = input('','s'); 
fprintf('Digite o limite inf: \n'); 
limInf = input(''); 
fprintf('Digite o limite sup: \n'); 
limSup = input(''); 
fprintf('Digite o erro: \n'); 
erro = input(''); 
fprintf('Digite o n max de it: \n'); 
n = input(''); 
6 
 
cont = 0; 
 
%Etapa 2: Verificação se o lim inf ou o lim sup zeram a função 
if(subs(f,limInf)==0 || subs(f,limSup)==0 ) 
 fprintf('Raiz encontrada!'); 
else 
 imalimInf = subs(f,limInf); 
 imalimSup = subs(f,limSup); 
 if(imalimInf*imalimSup>=0) 
 fprintf('Limitantes invalidos!'); 
 else 
 
 tic; %Abrindo a contagem de tempo 
 fprintf(' \t n \t\ta \t\t b \t\t x \t\t erro\n') 
 %Etapa 3: Processamento do método 
 while(cont<=n) 
 x = (limInf+limSup)/2; 
 
 if(cont==0) 
 disp([cont,limInf,limSup,x]) 
 else 
 %Mostrando os valores a cada iteração 
 disp([cont,limInf,limSup,x,limSup-limInf]) 
 end 
 
 %Etapa 4: Verificação do valor de x para testar se 
é raiz ou não 
 if(subs(f,x) == 0 || abs(limInf-limSup)<erro) 
 fprintf('Raiz = %f \n Numéro de It. = 
%d',x,cont) 
 break; 
 end 
 
 %Etapa 5: Selecionando qual será o novo intervalo 
adotado 
 if(subs(f,x)*imalimInf<0) 
 limSup = x; 
 else 
 limInf = x; 
 end 
 
 %Etapa 6: Atualizando o número de iterações do 
método 
 cont = cont+1; 
 end 
 
 end 
 tempo = toc; %Fechando a contagem de tempo 
 fprintf('\nTempo de processamento: %.3fs \n', tempo); 
end 
 
7 
 
O resultado encontrado para a solução da função minimizada 𝑓(𝑥) = 4𝜋𝑟 −
400𝑟−2 que soluciona o caso 2, utilizando o limite inferior igual a 1, superior igual a 10, erro 
de 0.001 e limite de iterações em 100 é exibido: 
 
Figura 5 – Aplicação do Método da Bisseção 
 
 
 
 
3.4 Método de Newton-Raphson 
 
Para a mesma f(x) anterior (uma função contínua no intervalo [a, b]) e seja 𝑥𝑛 
uma raiz desta função, para 𝑥𝑛 ∈ (a, b), tal que f(𝑥𝑛) = 0 e f’(x) ≠ 0 obtemos o seguinte 
gráfico 
 
Figura 6 – Retas tangentes a curva f(x) 
 
A partir deste cenário podemos facilmente deduzir que: 
8 
 
 
𝑥𝑛 = 𝑥𝑛−1 −
𝑓(𝑥𝑛−1)
𝑓′(𝑥𝑛−1)
 para n = 1, 2, 3, . .. 
 
Esta equação deve ser reproduzida repetidamente e para cada iteração seguinte 
fazer 𝑥𝑛−1 assumir o valor de 𝑥𝑛 até o critério de parada ser satisfeito (|𝑥𝑛 − 𝑥𝑛−1| <
𝐸𝑟𝑟𝑜 𝑜𝑢 𝑓(𝑥𝑛) = 0). 
 
3.4.1 Programando a Função newton1 
 
Exibe-se abaixo a função do método programado na linguagem do MATLAB: 
 
function raiz2 = newton1(fun, x0, erro) 
dfun = diff(sym(fun)); 
f = subs(fun,x0); 
df = subs(dfun,x0); 
iteracoes = 0; 
 
fprintf(' \t n \t\traiz \t erro\n') 
tic; %Abrindo a contagem de tempo 
while abs(f)>erro 
 raiz = x0-(f/df); 
 
 if(iteracoes==0) 
 disp([iteracoes,double(raiz)]) 
 else 
 %Mostrando os valores a cada iteração 
 disp([iteracoes,double(raiz),double(abs(f))]) 
 end 
 
 f = subs (fun,raiz); 
 df = subs(dfun,raiz); 
 x0=raiz; 
 iteracoes = iteracoes+1; 
 
end 
 
%Mostrando a última iteração 
disp([iteracoes,double(raiz),double(abs(f))]) 
 
tempo = toc; %Fechando a contagem de tempo 
fprintf('Numero de iterações = %d \n', iteracoes); 
raiz2 = double(x0);fprintf('Raiz encontrada = %f\n', raiz2); 
fprintf('Tempo = %fs', tempo); 
end 
 
9 
 
Para compararmos o número de iterações exigidos pelo método de Newton-
Raphson para solucionar o caso 2 tal qual foi feito com o método da bissecção e repetindo os 
mesmos dados chegamos ao resultado exposto abaixo. 
 
Figura 7 – Aplicação do Método de Newton-Raphson 
 
 
 
3.5 Método da Secante 
 
A grande desvantagem do método de Newton é a necessidade de se obter a 
derivada f’(x) (que muitas vezes pode ser de difícil determinação) e calcular o seu valor a 
cada iteração. Para contornar este problema podemos substituir o cálculo da derivada f’(𝑥𝑛) 
pelo quociente das diferenças das imagens pelas suas respectivas abscissas facilmente 
percebido pela análise gráfica: 
 
Figura 9 – Reta secante a curva f(x) 
 
 
f’(𝑥𝑛) ≈ tg(α) = 
f(𝑥𝑛−1)−f(𝑥𝑛) 
𝑥𝑛−1− 𝑥𝑛
 
 
10 
 
Dessa forma após poucas manipulações algébricas chegamos à expressão: 
 
𝑥𝑛+1 = 𝑥𝑛 − 
f(𝑥𝑛)∗(𝑥𝑛−1−𝑥𝑛) 
𝑓(𝑥𝑛−1)−f(𝑥𝑛)
 
 
onde 𝑥𝑛 e 𝑥𝑛−1 são duas aproximações para a raiz. 
O mesmo critério de parada de ambos os métodos anteriores deverá ser atendido 
igualmente aqui. O desenvolvimento do seu algoritmo na linguagem do MATLAB fica como 
um exercício para o leitor haja visto que os códigos anteriores dão uma excelente ideia de 
como será essa implementação. 
 
 
4. SISTEMAS LINEARES E NÃO LINEARES 
 
Sistemas lineares são sistemas de equações com i equações e j incógnitas 
formados por equações lineares. Usualmente são escritos na forma: 
 
 𝑎11𝑥1 + 𝑎12𝑥2 + 𝑎13𝑥3 + ⋯+ 𝑎1𝑛𝑥𝑛 = 𝑦1 
𝑎21𝑥1 + 𝑎22𝑥2 + 𝑎23𝑥3 + ⋯+ 𝑎2𝑛𝑥𝑛 = 𝑦2 
𝑎31𝑥1 + 𝑎32𝑥2 + 𝑎33𝑥3 + ⋯+ 𝑎3𝑛𝑥𝑛 = 𝑦3 
⋮ 
𝑎𝑛1𝑥1 + 𝑎𝑛2𝑥2 + 𝑎𝑛3𝑥3 + ⋯+ 𝑎𝑛𝑛𝑥𝑛 = 𝑦𝑛 
 
Para solucionar estes sistemas devemos calcular os valores de 𝑥𝑗, para j = 1, 2,..., 
n, caso eles existam, que satisfaçam as i equações ao mesmo tempo. A mesma lógica de 
montagem desse sistema de representação é utilizada para sistemas não lineares obviamente 
quando formados por equações não lineares. 
Problemas de engenharia relacionados à determinação de reações a esforços em 
corpos (vigas ou parafusos, por exemplo), transferência de calor, determinação de parâmetros 
de circuitos elétricos, resolução de problemas de vibrações, acústica e etc. necessitam serem 
representados de forma direta por sistemas lineares e também não lineares para obtenção de 
suas soluções. Neste cenário, os métodos numéricos proporcionam além da possibilidade de 
solução mesmo para sistemas não lineares mais complexos também algoritmos de respostas 
baseados em aritmética simples e a facilidade de implementação computacional que garante a 
solução numa fração de tempo muito reduzida se comparada ao tempo gasto por um ser 
humano para chegar à mesma solução. 
A resposta do exemplo citado no capítulo 2 desta apostila é consequência da 
aplicação direta de métodos como os que serão estudados nesta sessão para obtenção da 
distribuição de temperaturas em uma malha que representa uma superfície. 
 
 
 
 
 
11 
 
4.1 Problema 3: 
 
(Adaptado de GILAT e SUBRAMANIAM, 2008) A força axial 𝐹𝑖 em cada um dos 13 
membros da treliça conectada por pinos mostrada na figura abaixo pode ser calculada com a 
solução do seguinte sistema de 13 equações: 
 
Figura 10 – Treliça 
 
Fonte: GILAT, SUBRAMANIAM (2008) 
 
𝐹2 + 0.7071𝐹1 = 0 
−𝐹2 + 𝐹6 = 0 
𝐹3 − 2000 = 0 
𝐹4 + 0.6585𝐹5 − 0.7071𝐹1 = 0 
0.7071𝐹1 + 𝐹3 + 0.7526𝐹5 + 1000 = 0 
𝐹7 + 0.6585𝐹8 − 𝐹4 = 0 
𝐹10 − 0.6585𝐹5 − 𝐹6 = 0 
𝐹9 + 0.7526𝐹5 − 4000 = 0 
0.7071𝐹11 − 𝐹7 = 0 
0.7071𝐹11 + 𝐹12 + 500 = 0 
𝐹12 + 0.7526𝐹8 − 2000 = 0 
𝐹13 + 0.7071𝐹11 = 0 
 
Determine as forças do sistema. 
 
 
4.2 Método de Jacobi 
 
Dado um sistema linear como apresentado anteriormente podemos garantir sua 
convergência através do atendimento ao conceito dele ser diagonalmente dominante para o 
qual: 
|𝑎𝑖𝑖| > ∑|𝑎𝑖𝑗|
𝑛
𝑗=1
𝑗≠𝑖
 
12 
 
 
Para este conceito os elementos das diagonais principais tomados em módulo 
deverão ser maiores que a soma dos demais termos restantes da mesma linha também em 
módulo. Vale ressaltar aqui que o não cumprimento do critério referido não indica 
automaticamente que o sistema analisado venha ser divergente em sua solução apenas indica 
que não o satisfazendo poderá não ser convergente. 
Assim, a solução pelo método de Jacobi é dado pelo isolamento das variáveis 𝑥1, 
𝑥2, 𝑥3, ... , 𝑥𝑛 sequencialmente linha após linha originando as seguintes equações iterativas: 
 
𝑥1
𝑘 =
𝑦1 − 𝑎12𝑥2
𝑘−1 − 𝑎13𝑥3
𝑘−1 − ⋯− 𝑎1𝑛𝑥𝑛
𝑘−1
𝑎11
 
𝑥2
𝑘 =
𝑦2 − 𝑎21𝑥1
𝑘−1 − 𝑎23𝑥3
𝑘−1 − ⋯− 𝑎2𝑛𝑥𝑛
𝑘−1
𝑎22
 
𝑥3
𝑘 =
𝑦3 − 𝑎31𝑥3
𝑘−1 − 𝑎32𝑥2
𝑘−1 − ⋯− 𝑎3𝑛𝑥𝑛
𝑘−1
𝑎33
 
⋮ 
𝑥𝑛
𝑘 =
𝑦𝑛 − 𝑎𝑛1𝑥1
𝑘−1 − 𝑎𝑛2𝑥2
𝑘−1 − ⋯ −𝑎𝑛𝑛−1𝑥𝑛−1
𝑘−1
𝑎𝑛𝑛
 
 
Ou seja: 
 
𝑥𝑖
𝑘 = 
1
𝑎𝑖𝑖
(𝑦𝑖 − ∑𝑎𝑖𝑗𝑥𝑗
𝑘−1)
𝑛
𝑗=1
𝑗≠𝑖
 
 
Este método deve ser reproduzido repetidamente sempre atualizando 𝑥1
𝑘−1 para o 
último valor de 𝑥1
𝑘 calculado até o critério de parada ser satisfeito (𝑚𝑎𝑥|𝑥𝑖
𝑗 − 𝑥𝑖
𝑗−1| <
𝐸𝑟𝑟𝑜). 
Dada a grande semelhança entre as implementações do método de Jacobi e Gauss-
Seidel (visto no próximo tópico) será exibido aqui apenas à implementação do segundo. Fica 
como exercício ao aluno elaborar o script ou função no MATLAB para o método de Jacobi. 
 
4.3 Método de Gauss-Seidel 
 
Para o mesmo tipo de sistema linear apresentado no item 4.1, a mesma garantia de 
convergência pelo atendimento ao critério diagonalmente dominante e também mesmo 
critério de parada a solução pelo Método de Gauss-Seidel é mais acelerada por basear-se na 
substituição dos termos calculados em mesma iteração (já atualizados na iteração atual) a 
partir de 𝑥2
𝑘. Ficamos então com a seguinte proposta de solução: 
 
𝑥1
𝑘 =
𝑦1 − 𝑎12𝑥2
𝑘−1 − 𝑎13𝑥3
𝑘−1 − ⋯− 𝑎1𝑛𝑥𝑛
𝑘−1
𝑎11
 
13 
 
𝑥2
𝑘 =
𝑦2 − 𝑎21𝑥1
𝑘 − 𝑎23𝑥3
𝑘−1 − ⋯− 𝑎2𝑛𝑥𝑛
𝑘−1
𝑎22
 
𝑥3
𝑘 =
𝑦3 − 𝑎31𝑥3
𝑘 − 𝑎32𝑥2
𝑘 − ⋯− 𝑎3𝑛𝑥𝑛
𝑘−1
𝑎33
 
⋮ 
𝑥𝑛
𝑘 =
𝑦𝑛 − 𝑎𝑛1𝑥1
𝑘 − 𝑎𝑛2𝑥2
𝑘 − ⋯−𝑎𝑛𝑛−1𝑥𝑛−1
𝑘
𝑎𝑛𝑛
 
 
O mesmo método pode ser reescrito como: 
 
𝑥𝑖
𝑘 = 
1
𝑎𝑖𝑖
(𝑦𝑖 − ∑𝑎𝑖𝑗𝑥𝑗
𝑘−1 
(𝑘) 𝑝𝑎𝑟𝑎 𝑖 > 𝑗
(𝑘 − 1)𝑝𝑎𝑟𝑎 𝑖 < 𝑗
 )
𝑛
𝑗=1
𝑗≠𝑖
 
 
4.3.1 Programando a Função GaussS 
 
Exibe-se abaixo a função simplificada do método programado na linguagem do 
MATLAB: 
 
function [x] = GaussS(A, y, E, num) 
%A = matriz de coeficientes do sistema linear 
%y = vetor coluna de termos independentes 
%E = erro adotado 
%num = número máximo de iterações 
C = A; 
[m,n] = size(A); 
 
%Atribuindo a diagonal principal de C os valores zeros 
for i = 1:n 
 C(i,i) = 0; 
 x(i) = 0; 
end 
 
%Tornando x um vetor coluna de zeros (chute inicial) 
x = x'; 
for i = 1:n 
 C(i,1:n) = C(i,1:n)/A(i,i); 
end 
 
for i = 1:n 
 d(i) = y(i)/A(i,i); 
end 
cont = 0; 
 
%Processamento do método 
while (1) 
 x_ant = x; 
 for i = 1:n 
14 
 
 x(i) = d(i)-C(i,:)*x; 
 
 %Cálculo do erro para cada iteração 
 if(x(i)~=0) 
 erro(i) = abs((x(i)-x_ant(i))/x(i))*100; 
 end 
 end 
 cont=cont+1; 
 
 %Analisando os critérios de parada 
 if(max(erro)<=E || cont >=num) 
 break; 
 end 
end 
 
end 
 
 
 
4.4 Método de Newton-Raphson 
 
Uma vez que o Método de Newton-Raphson já foi apresentado anteriormente 
voltado para a solução de funções reais tanto representadas por equações lineares como não 
lineares, com poucas analogias podemos entender como sua transcrição para a equação abaixo 
o torna aplicável a soluções de sistemas de equações não lineares. 
 
𝐹(𝑋) = [
𝑓1(𝑥1,𝑥2,…,𝑥𝑛)
𝑓2(𝑥1,𝑥2,…,𝑥𝑛)
⋮
𝑓𝑛(𝑥1, 𝑥2…,𝑥𝑛)
] , X = [
𝑥1
𝑥2
⋮
𝑥𝑛
] 𝐽𝑐 =
[
 
 
 
 
𝜕𝑓1(𝑥1,𝑥2,…,𝑥𝑛)
𝜕𝑥1
⋯
𝜕𝑛(𝑥1,𝑥2,…,𝑥𝑛)
𝜕𝑥𝑛
⋮ ⋱ ⋮
𝜕𝑓𝑛(𝑥1,𝑥2,…,𝑥𝑛)
𝜕𝑥1
⋯
𝜕𝑓𝑛(𝑥1,𝑥2,…,𝑥𝑛)
𝜕𝑥𝑛 ]
 
 
 
 
 
 
Pelas expressões acima definidas podemos então propor que se considerem as 
analogias para simplificação da dedução da expressão mostrada abaixo para o Método de 
Newton-Raphson ajustado a soluções de sistemas não lineares a partir de: 𝑥 → 𝑋, 𝑓 → 𝐹 e 
𝑓′ → 𝐽𝑐. A partir desses conceitos chegamos em: 
 
𝑋(𝑘+1) = 𝑋𝑘 − 𝐽𝑐
−1(𝑋𝑘) ∗ 𝐹(𝑋𝑘) 
 
Ao leitor cabe a atividade de elaborar o script ou função no MATLAB para o 
método de Newton para solução de sistemas não lineares. 
 
 
 
 
 
 
15 
 
5. INTERPOLAÇÃO POLINOMIAL 
 
É muito comum em engenharia ocorrer a necessidade de se estimar um valor 
intermediário a partir de dois dados precisos. Tal situação ocorre, por exemplo, quando se 
quer realizar a descrição mais fidedigna da queda de um corpo em queda livre e deseja-se 
considerar além do efeito da sua massa e do coeficiente de arrasto também as características 
geométricas do mesmo e a densidade do ar. Normalmente este último parâmetro é dado em 
função da temperatura em tabelas encontradas nas mais diversas literaturas de mecânica dos 
fluídos. 
As duas motivações principais que levam a utilização de interpolação são: 
primeiro, o fato de não se conhecer uma 𝑓(𝑥) procurada, entretanto seja conhecido valores 
discretos de pontos da mesma e na segunda situação nela é conhecida a função porém a 
mesma possui uma expressão muito complexa e deseja-se aproxima-la para um modelo mais 
simples. 
De toda forma, este capítulo completo é baseado em o leitor conhecer uma dada 
quantidade 𝑛 de pontos e a interpolação ofertar uma boa aproximação das imagens para 
valores intermediários de abscissas contidos dentro desse intervalo dos pontos dados. Ou seja, 
qualquer que seja o valor de 𝑥𝑖 para o qual queira se conhecer a sua respectiva imagem deve-
se ter primeiramente o valor desta abscissa dentro do intervalo [min(x), max(x)]. 
Para 𝑛 pontos teremos sempre 𝑛 − 1 grau para a função polinomial obtida e 
teremos 𝑛 termos na sua expressão. 
 
5.1 Problema 4: 
 
A carga de ruptura mínima, f(x), de uma certa cordoalha de aço com sete fios 
varia com o diâmetro nominal da mesma, x. Foram medidas as cargas para 5 cordoalhas de 
diversos diâmetros e os resultados encontram-se na tabela abaixo: 
 
𝑥𝑖 (mm) 6.4 7.9 11 12.7 15.2 
𝑓(𝑥𝑖) (KN) 36.5 56 106.3 141 207.6 
 
Figura 11 – Exemplo de cordoalha 
 
(Figura meramente ilustrativa) 
 
A interpolação desses valores nos fornece uma boa previsão de qual será a carga 
de ruptura mínima para uma cordoalha de 9.5 mm de diâmetro. 
16 
 
5.2 Polinômio de Lagrange 
 
A expressão do polinômio interpolador de Lagrange para uma 𝑛 quantidade de 
pontos dados como entradas segue abaixo: 
 
𝑃(𝑥) = 𝑓(𝑥0)𝐿0(𝑥) + 𝑓(𝑥1)𝐿1(𝑥) + 𝑓(𝑥2)𝐿2(𝑥) + ⋯ + 𝑓(𝑥𝑛−1)𝐿𝑛−1(𝑥) 
 
A mesma expressão pode ser ajustada ao somatório apresentado abaixo: 
 
𝑃(𝑥) = ∑ 𝑓(𝑥𝑖)𝐿𝑖(𝑥)
𝑛−1
𝑖=0
 
 
Os termos ponderadores 𝐿𝑖(𝑥) são obtidos através dos produtórios: 
 
𝐿𝑖(𝑥) = ∏
(𝑥 − 𝑥𝑗)
(𝑥𝑖−𝑥𝑗)
0≤𝑗≠𝑖≤𝑛−1
 
 
Essas expressões nos levam a afirmar que dados 3 pontos ( 𝑃0(𝑥0, 𝑦0), 𝑃1(𝑥1, 𝑦1),
𝑃2(𝑥2, 𝑦2)) teremos então através deste método uma função polinomial de segundo grau na 
forma: 
 
𝑃(𝑥) = 𝑓(𝑥0)𝐿0(𝑥) + 𝑓(𝑥1)𝐿1(𝑥) + 𝑓(𝑥2)𝐿2(𝑥) 
 
e seus respectivos termos ponderados calculados para: 
 
𝐿0(𝑥) =
(𝑥 − 𝑥1)
(𝑥0−𝑥1)
(𝑥 − 𝑥2)
(𝑥0−𝑥2)
 
𝐿1(𝑥) =
(𝑥 − 𝑥0)
(𝑥1−𝑥0)
(𝑥 − 𝑥2)
(𝑥1−𝑥2)
 
𝐿2(𝑥) =
(𝑥 − 𝑥0)
(𝑥2−𝑥0)
(𝑥 − 𝑥1)
(𝑥2−𝑥1)
 
 
5.2.1 Programando a Função InterpLagrange 
 
Exibe-se abaixo a coleção de funções que devidamente conectadas formam o 
algoritmo do método de Lagrange programado na linguagem do MATLAB: 
 
1ª Função: 
function [x,y] = entradas_de_pontos(n) 
%n = quantidade de pontos dados como entradas para o método 
fprintf('\nInsira os valores das coordenadas dos pontos'); 
for i=1:n 
 %Pedindo para cada ponto suas respectivas abiscissa e ordenada 
 fprintf('\nPonto %d:\nX: ',i); 
17 
 
 x(i)= input(''); 
 fprintf('Y: '); 
 y(i)= input(''); 
end 
end 
 
2ª Função: 
function [] = saidas_de_pontos(x,y,n) 
%n = quantidade de pontos dados como entradas para o método 
%x = abscissas obtidas na função "entradas_de_pontos(n)" 
%y = ordenadas obtidas na função "entradas_de_pontos(n)" 
fprintf('\nCoordenadas dos pontos\n\t\t X\t\tY\n'); 
for i=1:n 
 fprintf('P%i\t %.4f\t%.4f\n',i,x(i), y(i)); 
end 
 
end 
 
3ª Função: 
function [x_maior] = abiscissa_maior(x,n) 
%x = abscissas obtidas na função "entradas_de_pontos(n)" 
%n = quantidade de pontos dados como entradas para o método 
%x_maior = maior valor de x 
x_maior = x(1); 
for i=1:n 
 %Selecionando o maior valor de x 
 if (x(i)>x_maior) 
 x_maior = x(i); 
 end 
end 
 
end 
 
4ª Função: 
function [x_menor] = abiscissa_menor(x,n) 
%x = abscissas obtidas na função "entradas_de_pontos(n)" 
%n = quantidade de pontos dados como entradas para o método 
%x_menor = menor valor de x 
x_menor = x(1); 
for i=2:n 
 %Selecionando o maior valor de x(i) 
 if (x(i)<x_menor) 
 x_menor = x(i); 
 end 
end 
end 
 
5ª Função: 
function [] = InterpLagrange(n) 
%n = quantidade de pontos dados como entradas para o método 
fprintf('\tFunção Polinômio Interpolador de Lagrange ativa!\n'); 
[x,y] = entradas_de_pontos(n); 
%x = abscissas obtidas na função "entradas_de_pontos(n)" 
%y = ordenadas obtidas na função "entradas_de_pontos(n)" 
opcao=1; 
18 
 
while (opcao==1) 
 clc; 
 fprintf('\tPolinômio Interpolador de Lagrange\n'); 
 saidas_de_pontos(x,y,n); 
 fprintf('\nInsira um valor válido do intervalo do dominio 
proposto [%f,%f] \npara determinar sua imagem: ',min(x),max(x)); 
 X= input(''); 
 clc; 
 fprintf('\tPolinômio Interpolador de Lagrange\n'); 
 saidas_de_pontos(x,y,n); 
 fprintf('\nValor da abscissa: %.4f', X); 
 
 %Verificando se X está no intervalo válido 
 while (X<abiscissa_menor(x,n) || X>abiscissa_maior(x,n)) 
% Equivalente a while (X<min(x) || X>max(x)) 
 clc; 
 fprintf('\tPolinômio Interpolador de Lagrange\n'); 
 saidas_de_pontos(x,y,n); 
 fprintf('\nPor favor, insira um valor dentro do intervalo 
do dominio proposto [%f,%f]\nValor do dominio: ',min(x),max(x)); 
 X = input(''); 
 end 
 S=0; 
 for i=1:n 
 P=1; 
 for j=1:n 
 if (i~=j) 
 %Gerando os valores de Li(x) 
 P =(X-x(j))/(x(i)-x(j))*P; 
 end 
 end 
 %Gerando os valores do somatório de f(xi)*Li(x) 
 P=y(i)*P; 
 S=P+S; 
 end 
 %Menu para sair da função ou gerar uma nova imagem a partir de 
uma nova 
 %abscissafprintf('\nValor da respectiva imagem: %.4f\n\n0 - Pressione 
qualquer tecla (exceto 1) para sair da função: \n1 - Inserir uma 
nova abscissa: \nOpcao: ',S); 
 opcao = input(''); 
end 
 
end 
 
 
 
 
 
 
 
 
 
 
19 
 
6. LISTA DE FUNÇÕES/COMANDOS/OPERADORES DO MATLAB 
 
Funções mais utilizadas nesta apostila e em aplicações da mesma área. 
 
Função/comando Descrição 
clc Limpa a janela de comandos. 
clear Limpa da memória variáveis 
ver 
Mostra o número da versão do MATLAB e dos "toolboxes" 
instalados. 
pi 3.1415.... 
diag Cria matriz diagonal 
abs(x) Valor absoluto 
sin(x) Seno de um ângulo x (em radianos) 
sind(x) Seno de um ângulo x (em graus) 
cos(x) Cosseno de um ângulo x (em radianos) 
sqrt(x) Raiz quadrada 
exp(x) Exponencial (𝑒𝑥) 
log(x) Logaritmo natural, na base 𝑒 (ln) 
log10(x) Logaritmo na base 10 
round(x) Arredonda para o inteiro mais próximo 
format short Ponto fixo com quatro algarismos decimais 
format long Ponto fixo com quatorze algarismos decimais 
length(A) Retorna o número de elementos no vetor A 
size(A) 
Retorna um vetor linha [m,n], onde m é o número de linhas e n é o 
número de colunas de A 
zeros(m,n) Cria uma matriz com m linhas e n colunas de elementos zeros 
ones(m,n) Cria uma matriz com m linhas e n colunas de elementos uns 
eye(n) Cria uma matriz identidade de ordem nxn 
sum(A) Se A é um vetor, a função retorna a soma dos elementos do vetor 
det(A) A função retorna o determinante da matriz quadrada A 
&& AND 
|| OR 
~ NOT 
xlabel(‘texto no 
formato string’) 
Coloca rótulo no eixo-x. 
ylabel(‘texto no 
formato string’) 
Coloca rótulo no eixo-y. 
title(‘texto no formato 
string’) 
Coloca título. 
diff(x) Calcula a derivada de x 
int(x) Calcula a integral de x 
linspace(x,y,n) 
Cria vetor de componentes linearmente espaçados começando em 
x indo até y com n elementos. 
logspace(x,y,n) cria vetor de n componentes que estão logaritmicamente espaçados 
rand(A) Gera matriz de números aleatórios com distribuição uniforme. 
Inv(A) Matriz inversa 
sign(var) Sinal do valor var. 
20 
 
error Mostra mensagem e aborta a execução da função. 
break Interrompe a execução dos laços for e while. 
lasterr Última mensagem de erro emitida pelo MATLAB. 
pause Força uma parada até que se pressione uma tecla. 
tic , toc Aciona e faz a leitura de um cronômetro, respectivamente. 
int2str(num) Converte número inteiro em string. 
max(x) Determina maior componente de x. 
mean(x) Determina média ou valor médio de x. 
min(x) Determina menor componente de x. 
roots Determina as raízes de um polinômio. 
ode45 Método de Runge-Kutta-Fehlberg de 4ª/5ª ordens. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
21 
 
7. REFERÊNCIAS 
 
CHAPRA, Steven C. Métodos numéricos aplicados com o matlab: para engenheiros e 
cientistas. Mc Graw Hill – Bookman, 2013. 
 
GILAT, Amos. SUBRAMANIAM, Vish. Métodos Numéricos para Engenheiros e 
Cientistas: uma introdução com aplicação usando o Matlab. Bookman, 2008. 
 
UNIVESP. Licenciatura em Matemática UNIVESP - Cálculo Numérico - 12º Bimestre. 
Joyce Bevilaqua. Coordenador Professor Cláudio Possani Disponível 
em: <https://www.youtube.com/playlist?list=PLxI8Can9yAHdytibfatcKa1MQk6k3JAjz>. 
Acesso em: 20 de abril de 2018.