Notas de Aula (Cálculo Numérico - CNUE5)

Prévia do material em texto

INSTITUTO FEDERAL DE EDUCAÇÃO 
TECNOLÓGICA 
Av. Jerônimo Figueira da Costa, 3014 - Bairro Pozzobon. 
CEP 15503-110 - Votuporanga - SP 
www.ifsp.edu.br 
 
 
 
 
 
 
 
 
 
 
ENGENHARIA CIVIL: 
 NOTAS DE AULA 
 
 
CÁLCULO NUMÉRICO 
 
 
 
Prof. Msc. Gustavo Cabrelli Nirschl 
 
 
 
 
 
 
 
Dezembro de 2015
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Agradecimentos: 
 
Carlos Eduardo Alves da Silva - Técnico de TI do Campus 
Fernando Parreira - Técnico de TI do Campus 
Isabela Cassia Dominical Parra – orientada de iniciação científica relacionada aos 
assuntos desta apostila (2015 e 2016) e discente da 1ª turma do curso de 
Engenharia Civil 
Marcelo Yugi Nomoto – ajudou nos meus primeiros passos na programação web 
 
 
PROVAS E TRABALHOS DA DISCIPLINA 
 
1º BIMESTRE: 
Media1 = (Prova1 * 0,7) + (Trabalhos1 * 0,3) 
 
2º BIMESTRE: 
Media2 = (Prova2 * 0,7) + (Trabalhos2 * 0,3) 
 
MÉDIA = (Media1 + Media2) / 2 
 
SE 4,0  MÉDIA < 6,0  RECUPERAÇÃO FINAL 
 
CRITÉRIOS DE APROVAÇÃO 
 
FREQUENCIA ≥ 75% E MÉDIA FINAL ≥ 6,0 
 
SOBRE ESTAS NOTAS DE AULA 
 
Estas notas de aula foram escritas, a partir de 2015, com base em outras 
bibliografias e na experiência acumulada do professor, para a disciplina de Cálculo 
Numérico do curso de Engenharia Civil do IFSP campus Votuporanga. Elas são 
constantemente revisadas tentando atender às mudanças necessárias decorrentes 
de possíveis erros e necessidades dos alunos não identificadas previamente. Por 
isso é importante o aluno estar com a revisão mais recente e não reutilizar materiais 
de turmas anteriores. Lembra-se ao aluno que essas notas de aula não substituem 
os livros em hipótese alguma. 
 
BIBLIOGRAFIA COMPLEMENTAR 
 
BARROSO, L.C. et al. Cálculo numérico: com aplicações. 2.ed. São Paulo: 
Harbra, 1987. 
 
LIPSCHUTZ, S. Álgebra Linear. 3.ed. São Paulo: Pearson, 1994. 
 
FARRER, H. et al. Pascal estruturado. 3.ed. Rio de Janeiro: LTC, 1999. 
 
FORBELLONE, A.L.; EBERSPACHER, H.F. Lógica de programação. 3.ed. São 
Paulo: Prentice Hall, 2005. 
 
RUGGIERO, M.A.G; LOPES, V.L.R. Cálculo numérico: aspectos teóricos e 
computacionais. 2.ed. São Paulo: Makron Books, 1996. 
 
SALIBA, L.W. Técnicas de programação: uma abordagem estruturada. São 
Paulo: Makron Books,1993. 
 
GUIDORIZZI, H.L. Um curso de cálculo. v.2. 5.ed.Rio de Janeiro: LTC, 2001. 
 
GUIDORIZZI, H.L. Um curso de cálculo. v.3. 5.ed.Rio de Janeiro: LTC, 2001. 
 
 
 
LEITURA OBRIGATÓRIA: 
O QUE IMPORTA É O CONHECIMENTO E A COMUNICAÇÃO 
 
 
 
 
Caro estudante, o professor tem o dever não só de te passar conhecimento, mas de 
fazer você aprender a aprender. Isso é o que um bom professor deve ter como 
objetivo. Para isso, o professor te direciona aos estudos e avalia a tua evolução por 
meio das notas. E elas podem ser cruéis: são um número que não percebe se você 
está com problemas familiares, pessoais, de saúde. Naquele dia de avaliação você 
tem que ter aquele conteúdo na cabeça, ou o número será baixo! É o sistema! Você 
tem que se adequar! 
Como um futuro profissional, saiba avaliar a tua própria nota, individualmente, 
considerando o que está acontecendo com todo o resto da tua vida naquele 
momento. Se não for por preguiça de estudar, não se martirize e nem culpe o 
professor. Apenas refaça os estudos, repita o processo. Isso é a repetência! Isso 
não é vergonha! 
Quando você entrar no mercado de trabalho, o contratante irá te entrevistar para 
tentar perceber se você o ajudará a lucrar e a desenvolver a empresa, mesmo que 
não de imediato, mas num futuro próximo. Então ele irá tentar ver o que você sabe 
fazer, se aquilo é suficiente para tocar os trabalhos da empresa. Ele pode até querer 
ver tuas notas, mas elas não serão mais importantes do que o teu conhecimento 
adquirido. 
Hoje em dia ninguém consegue trabalhar isoladamente, sozinho num canto. Os 
grandes projetos exigem trocas de conhecimento entre diversas áreas, cooperação. 
É a multidisciplinaridade! Então as corporações irão gostar do teu trabalho se você 
souber se comunicar oralmente e de forma escrita. Se falar inglês, será um 
profissional diferenciado! Porque é bonito saber inglês? Não, porque os grandes 
projetos exigirão informações e estudos em inglês, terão contato com pessoas 
internacionais, e até serão executados em outros países. 
Saber escrever é mera formalidade? Também não! Você precisará de muitas 
pessoas para executar aquilo que está na tua cabeça e se você conseguir dizer a 
elas exatamente como deve ser feito, o projeto ficará bom. Não adianta saber tudo e 
não ter a chave da porta que leva tudo isso pro mundo exterior: a comunicação oral 
e escrita! 
Então, meu amigo e aluno, estude sim a técnica, e muito, mas estude português e 
inglês, no mínimo. Comunique-se com os colegas, não por amizade somente, mas 
para dar e receber novas informações a cada dia. Isso sim te levará a ser um ótimo 
Engenheiro Civil! 
 
 
 
 
Bons estudos! 
 
Prof. Gustavo Cabrelli Nirschl 
 
 
SUMÁRIO 
 
1 MÉTODOS NUMÉRICOS NA SOLUÇÃO DE PROBLEMAS .................................. 6 
2 INTRODUÇÃO À TEORIA DE ERRO E ESTABILIDADE ....................................... 9 
3 SISTEMAS DE EQUAÇÕES LINEARES ............................................................... 14 
4 CÁLCULO DE DETERMINANTES DE MATRIZES ............................................... 50 
5 MATRIZ INVERSA ................................................................................................. 52 
6 ZEROS DE FUNÇÕES........................................................................................... 56 
7 FUNÇÕES DE INTERPOLAÇÃO DE DADOS ...................................................... 66 
8 FUNÇÕES DE APROXIMAÇÃO DE DADOS ........................................................ 76 
9 INTEGRAÇÃO NUMÉRICA DE FUNÇÕES ........................................................... 87 
10 DERIVAÇÃO NUMÉRICA DE FUNÇÕES ........................................................... 93 
11 SOLUÇÃO DE EQUAÇÕES DIFERENCIAIS ...................................................... 99 
12 CONSIDERAÇÕES FINAIS ............................................................................... 112 
13 REFERÊNCIAS BIBLIOGRÁFICAS .................................................................. 113 
APÊNDICE A - INTRODUÇÃO À PROGRAMAÇÃO EM LAZARUS/PASCAL ..... 115 
APÊNDICE B - INTRODUÇÃO À PROGRAMAÇÃO EM HTML/JAVASCRIPT .... 122 
APÊNDICE C - PUBLICAÇÃO DO SITE NO GITHUB ........................................... 128 
 
 
 
 
 6 
 
1 MÉTODOS NUMÉRICOS NA SOLUÇÃO DE PROBLEMAS 
 
Segundo Quadros e Bortoli (2009), a maioria dos problemas da matemática é 
originária da necessidade de resolver situações da natureza. Numa primeira etapa, 
tem-se que obter um modelo matemático que representa de maneira conveniente 
um problema a ser analisado. Obtido o modelo matemático, procura-se encontrar a 
sua solução. 
Os mesmos autores citam que, quando se quer resolver um problema em 
engenharia, deve-se ter em mente o modelo que representa a situação física. Tal 
modelo é transformado em equações matemáticas (modelo matemático) que serão 
resolvidas por métodos analíticos ou por métodos numéricos. Como muitas 
situações não têm solução analítica ou a solução analítica é de difícil implementação 
computacional, os métodos numéricos se tornam a alternativa mais econômica em 
comparação à possibilidade de experimentação em laboratório. Este é um dos 
escopos do CÁLCULO NUMÉRICO. Outro objetivo é a programação computacional. 
Um exemplo importante é o cálculo de uma integral, frequentemente 
necessário em problemas da Engenharia Civil. Abaixo seguem duas integrais que 
têm solução analítica,ou seja, resolve-se substituindo a variável na solução por um 
número: 
 
 
 
Porém, existem integrais de funções que não têm solução analítica. Por 
exemplo, seja a integral de uma função f(x) no domínio a,b, que se quer resolver 
numericamente: 
 
 
 Um dos métodos numéricos possíveis consiste em resolver a função f(x) em 
alguns pontos e somar as áreas sobre a curva da função, já que a integral nada 
mais é do que esse somatório: 
 
Figura: Área sobre a curva f(x) aproximada por um trapézio. 
Fonte: Quadros e Bortoli (2009). 
 
 Do exemplo da figura anterior, pode-se entender também que todos os 
métodos numéricos são aproximações da solução analítica, com exatidão suficiente 
para seu propósito. Se dividirmos o intervalo a,b em vários intervalos menores, 
pode-se aumentar significativamente a exatidão do método. A integração numérica 
será estudada com mais detalhes posteriormente. 
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
Edited by Foxit ReadernullCopyright(C) by Foxit Corporation,2005-2009nullFor Evaluation Only.null
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
 7 
 
1.1 CÁLCULOS COMPUTACIONAIS: PROGRAMAÇÃO 
 
 Obviamente, hoje em dia, a maioria dos cálculos numéricos de Engenharia 
não é feita com lápis e papel, já que lidamos com grande quantidade de cálculos e 
podemos utilizar os computadores. As calculadoras são usadas apenas para 
verificações simplificadas. 
 Ocorre que existem muitos softwares com soluções prontas para vários tipos 
de situações e problemas, mas existem inúmeros problemas específicos que exigem 
cálculos também específicos. Podem-se citar aqui as variações regionais de 
materiais, mão-de-obra, climáticas, financeiras, etc. que exigem o desenvolvimento 
de soluções bem específicas. Citam-se ainda as pesquisas envolvendo novos 
materiais e novos processos de cálculo. Sendo assim, procura-se, nesta disciplina, 
fornecer as bases MATEMÁTICAS para o desenvolvimento de aplicativos 
computacionais. 
 Sabe-se que as planilhas de cálculo (ex: Excel) possibilitam a resolução 
automatizada de inúmeras situações, por meio de fórmulas criadas para cada 
finalidade. Porém, casos que exigem maiores quantidades de cálculo e, 
especialmente, cálculos iterativos (“só param quando se atinge certa exatidão”) e 
cálculos em loop (“vai e volta”) são difíceis de realizar nas planilhas. Aplicativos de 
computador com entradas de dados mais “amigáveis” e possibilidades infinitas de 
cálculos são então a melhor solução na resolução dos problemas específicos de 
engenharia. 
 Existem vários softwares (gratuitos e pagos) para a criação dos softwares, 
usando várias linguagens. Um bom software gratuito para este fim é o Lazarus 
(linguagem Pascal), que é livre e pode ser baixado do site: 
http://sourceforge.net/projects/lazarus/?source=dlp (acesso em 09/09/2013). O 
Lazarus permite a criação de aplicativos que rodam off-line (sem necessidade de 
internet), em qualquer computador. O aluno pode começar a estudar este software 
pelo conteúdo do Apêndice A desta apostila, que apresenta o passo-a-passo para a 
criação de um aplicativo simples (exercício 1.1 a seguir). Outros 
softwares/linguagens são FORTRAN e C++. Uma linguagem interessante para se 
aprender é a linguagem de programação dentro do Auto CAD, chamada AutoLisp 
(comando “vlisp”), sendo possível criar programas que geram e lêem desenhos 
dentro e arquivos dwg. 
 Seja qual for a linguagem, o primeiro passo do aluno é aprender a lógica de 
programação, a montagem e resolução de algoritmos (sequencias de cálculo), algo 
que independe da linguagem. O mesmo algoritmo pode ser implementado em 
qualquer linguagem, apenas se verificando como determinado comando é feito 
naquela linguagem. 
Atualmente, no mundo globalizado, é coerente criar os programas para 
execução num site da internet, on-line. Uma das possibilidades é usar a linguagem 
HTML combinada com o Javascript. Nesta disciplina, o aluno fica convidado a criar 
aplicações envolvendo as teorias estudadas em HTML/Javascript, sob a orientação 
do professor. Para tanto, o primeiro passo é aprender os conceitos básicos sobre a 
linguagem, sendo que o aluno pode fazer isso estudando, desde já, o Apêndice B 
desta apostila (exercício 1.2 a seguir). Aprendida uma linguagem, é relativamente 
fácil aprender qualquer outra, dependendo da futura necessidade profissional. 
O objetivo deste item é o primeiro contato do aluno com a programação. 
 
************************************************************************************************ 
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
Edited by Foxit ReadernullCopyright(C) by Foxit Corporation,2005-2009nullFor Evaluation Only.null
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
GUSTAVO
Line
 8 
 
 
TRABALHOS EM GRUPO: prezado aluno, todos os exercícios e criação de 
softwares desta disciplina serão em grupo. Cada grupo deve entregar um trabalho. 
Aproveitando a oportunidade, entenda que trabalhar em grupo significa se reunir 
com todos os integrantes e discutir cada exercício (ou parte do software) com todos, 
aproveitando as ideias dos colegas para criar a resposta final. Se fosse para cada 
integrante resolver um exercício (ou parte do software), o professor já faria a divisão 
desta maneira. Porém, se assim fosse, cada aluno só aprenderia a parte que fez. 
Aliás, nas avaliações, o conteúdo cobrado será de todas as partes de todos os 
trabalhos, e não partes deles. Aproveite que o curso é integral e que você tem a 
oportunidade de se reunir com o grupo, já que, profissionalmente, você não tem 
outro compromisso nesta fase da vida além de estudar (são raras as exceções de 
alunos que trabalham). Bom trabalho! 
 
EXERCÍCIOS 
 
1.1) Criar o programa principal descrito no Apêndice A (área de triângulo). Cada 
grupo deve passar o arquivo executável para o professor, via pen-drive. 
 
1.2) Criar o programa principal descrito no Apêndice B (área de triângulo). Cada 
grupo deve criar um site, conforme explicações no próprio Apêndice B, contendo o 
programa e enviar o link para o professor, via e-mail. 
 
************************************************************************************************ 
 
 9 
 
2 INTRODUÇÃO À TEORIA DE ERRO E ESTABILIDADE 
 
2.1 FONTES DE ERROS 
 
A solução numérica dos problemas pode ser “contaminada” por alguns tipos 
de erro. 
 
ERRO DE TRUNCAMENTO 
 
Os erros de TRUNCAMENTO surgem exatamente quando se precisa parar a 
resolução quando o processo analítico seria infinito. Por exemplo, conforme Quadros 
e Bortoli (2009), podemos calcular numericamente o cos(x) pela resolução do 
polinômio abaixo (POLINÔMIO DE MCLAURIN), que vai até o infinito. Então é 
necessário truncar, parar num dado momento, gerando um erro. 
 
 
Obs: x tem que ser o ângulo em radianos. 
 
No caso acima, como conhecemos a solução exata, o erro “E” absoluto (neste 
caso, um erro de truncamento) é dado por: 
 
E = cos(x) – P(x) 
 
 Em que: 
P(x) é uma função que aproxima a função exata. 
 
 A tarefa é sempre, nas soluções, impor um erro máximo, uma tolerância “e”, e 
verificar se isso se satisfaz (E ≤ e), antes de continuar os cálculos. Obviamente, se 
estamos programando uma resolução numérica, é porque não existe solução 
analítica ou ela é inviável. Porém, sempre há uma maneira de estimar se a solução 
numérica converge para a solução exata. Isso é estudado de acordo com cada 
método numérico de solução, especificamente. 
 Pode-se ainda calcular o erro relativo: 
 
)cos(
)()cos(
x
xPx
Er


*100 (em %)É muito mais conclusivo se trabalhar com o erro relativo. Note que um erro de 
1 km na medida da distância entre a Terra e a Lua é menos significativo que um erro 
de 1 cm na realização de uma cirurgia cerebral via robô. 
 
************************************************************************************************ 
 
EXERCÍCIO 
 
2.1) Na página do teu grupo na internet (criada no exercício 1.2), crie um aplicativo 
que resolva o cosseno de um número segundo o explicado acima (polinômio de 
Mclaurin), digitando o código a seguir. Estude o código. 
(...)
!6!4!2
1
642 xxx

 10 
 
ARQUIVO cosseno.html 
 
 
 
ARQUIVO funcoes-cos.js 
 
 
 
- Rode o programa off-line e verifique os resultados conforme abaixo: 
 
 
 
 11 
 
- Envie os arquivos para a página do grupo. O professor irá verificar diretamente. 
 
- Faça testes aumentando cada vez mais o número de termos e perceba que, após 
muitos termos, o erro de truncamento não se altera. Ou seja, não seria necessário 
tanto esforço computacional para resolver o polinômio com ótima precisão. Assim, 
você, programador, poderia limitar o número de termos em função de um erro 
aceitável, para reduzir esforço computacional. 
 
************************************************************************************************* 
 
ERRO DE ARREDONDAMENTO 
 
Os erros de ARREDONDAMENTO surgem pelo fato de que as operações 
aritméticas quase nunca podem ser efetuadas com precisão completa, devido às 
aproximações dos números. 
Os tipos de arredondamento mais utilizados são, segundo Quadros e Bortoli 
(2009): 
 
- CORTE: as casas em excesso são simplesmente abandonadas; 
 
- MAIS PRÓXIMO: considerando-se “d” algarismos significativos, se o algarismo 
“d+1” for maior ou igual a 5, soma-se uma unidade ao algarismo de ordem “d”; caso 
contrário, o algarismo de ordem “d” permanece inalterado. 
 
 Por exemplo, a solução exata da soma: 
 
 
 Se uma máquina/aplicativo opera com 3 dígitos de precisão, considerando 
arredondamento por corte: 
 
 
 Neste caso, o erro de arredondamento por corte é igual a 2-1,999=0,001. 
 Na computação atual, as máquinas trabalham com muitos dígitos de precisão 
e o erro de arredondamento é automaticamente minimizado. A questão da precisão 
fica somente para os resultados numéricos mostrados pelo programa. Por exemplo, 
no programa anterior, veja que os valores mostrados do cosseno exato e do 
polinômio de McLaurin estão mostrados com todas as casas decimais padrão. O 
programador pode alterar essa precisão mostrada, de acordo com a aplicação e 
público-alvo. 
 
************************************************************************************************* 
 
EXERCÍCIO 
 
2.2) Altere o aplicativo do exercício 2.1 e defina a precisão dos resultados para: 
 
Cosseno analítico  precisão de mais próximo, 5 casas decimais 
Cosseno numérico  precisão de mais próximo, 5 casas decimais 
Erro  precisão de corte, 6 casas decimais 
 12 
 
As funções que podem ser usadas são: 
 
n.toPrecision(5) // “n” com precisão de mais próximo em 5 algarismos (total de 
algarismos, incluindo decimais) 
 
n.toFixed(5) // “n” com precisão de mais próximo em 5 casas decimais 
 
Math.floor(n*Math.pow(10,5))/Math.pow(10,5); //“n” com precisão de corte em 5 
casas decimais 
 
- O professor irá verificar diretamente na página do grupo. 
 
************************************************************************************************* 
 
2.2 PRECISÃO E EXATIDÃO 
 
 Torna-se aqui necessário distinguir precisão de exatidão. Precisão é 
relacionada à quantidade de algarismos significativos. Exatidão é a medida da 
perfeição do resultado. A exatidão depende da precisão da máquina/aplicativo e do 
método utilizado para a obtenção do resultado. 
Veja o exemplo de Quadros e Bortoli (2009), envolvendo o número que 
vale 3,1415926: 
 
 
 
2.3 ESTABILIDADE 
 
Um método numérico diz-se instável se a acumulação de pequenos erros 
durante o cálculo pode ter grande influência na precisão dos resultados. Um método 
estável produz bons resultados mesmo com o acúmulo de pequenos erros. 
Chamam-se os algoritmos (sequencia de solução) instáveis também de algoritmos 
mal condicionados. 
Cherri et. al. (????) exemplifica o seguinte problema instável: supondo-se que 
as operações abaixo sejam processadas em uma máquina ou aplicativo com 4 
dígitos significativos: 
 
 
 
ALGORITMO A) 
 
 
 
 
 
 
 13 
 
ALGORITMO B) 
 
 
Os dois resultados são diferentes, quando não deveriam ser, pois a adição é 
uma operação distributiva. A causa dessa diferença foi um arredondamento feito na 
adição (x2 + x1), cujo resultado tem 8 dígitos. Como a máquina só armazena 4 
dígitos, os menos significativos foram desprezados. Por isso é importante somente 
arredondar os números no momento em que for apresentado o resultado final, 
deixando o programa trabalhar nos cálculos internos com todas as casas decimais 
possíveis. 
 
Concluindo, ao se utilizar softwares de programação ou máquinas 
calculadoras, deve-se ficar atento aos erros que podem acontecer, sejam por 
truncamento ou por arredondamento, que podem levar a um algoritmo instável. 
 
 14 
 
3 SISTEMAS DE EQUAÇÕES LINEARES 
 
3.1 SISTEMAS DE EQUAÇÕES LINEARES NA ENGENHARIA CIVIL 
 
 Podemos aplicar o cálculo numérico, por exemplo, à análise de estruturas de 
Engenharia Civil, no cálculo dos esforços. Um dos métodos numéricos existentes é o 
Método dos Elementos Finitos (MEF)1, que reduz o cálculo de esforços à resolução 
de um sistema de equações lineares, com a matriz (chamada matriz de rigidez) 
vezes o vetor de deslocamentos igual ao vetor de forças (
GG PK *
). 
No caso de flexão de vigas (isostáticas ou hiperestáticas), após 
desenvolvimento matemático e divisão da viga em trechos chamados elementos, 
considerando função aproximadora de grau 3 (cúbica), o MEF apresenta, para cada 
elemento, a seguinte matriz de rigidez 4 x4: 
 



























iiii
iiii
iiii
iiii
ii
llll
llll
llll
llll
IEK
4626
612612
2646
612612
*
22
2323
22
2323
 
 
Em que: 
Ei é o módulo de elasticidade do material do trecho da viga; 
Ii é o momento de inércia do trecho da viga; e 
li é o comprimento do trecho. 
 
Vamos analisar um exemplo, sendo que queremos calcular os esforços da 
seguinte viga hiperestática (biengastada): 
 
 
 
Devem-se criar nós onde há vínculo e onde há cargas concentradas, 
obrigatoriamente. No exemplo acima, isso deu origem a 3 elementos e 4 nós. 
Para cada elemento, com comprimento li = 1 m, adotando Ei*Ii=1 (a rigidez 
importa para os deslocamentos, não para os esforços): 
 
 
1 O MEF será estudado em outra(s) disciplina(s) ou na pós-graduação. 
 15 
 





























































4626
612612
2646
612612
4626
612612
2646
612612
*
4626
612612
2646
612612
*
22
2323
22
2323
ii
iiii
iiii
iiii
iiii
ii IE
llll
llll
llll
llll
IEK
 
 
O próximo passo é montar a matriz de rigidez GLOBAL do sistema, o que, 
para o caso de 3 elementos, será: 
 


































46260000
6126120000
2644662600
61266121261200
0026446626
00612661212612
00002646
0000612612
GK
 
 



































46260000
6126120000
26802600
61202461200
00268026
00612024612
00002646
0000612612
GK
 
 
No MEF para flexão de vigas, o vetor para carga F e/ou momento M 
concentrado, para cada elemento, é: 
 















j
j
i
i
M
F
M
F
P
 
 
No nosso exemplo, o vetor de forças, para cada elemento, é: 
 
 
 
 16 
 
ELEMENTO 1: ELEMENTO 2: ELEMENTO 3: 














0
4,0
0
0
 














0
4,0
0
4,0
 














0
0
0
4,0
 
 
Ficamos com o seguinte vetor global (não duplicar as cargas): 



























0
0
0
4,0
0
4,0
0
0
GP
 
 
O sistema a resolver fica (
GG PK *
): 
 




























































'4
4
'3
3
'2
2
'1
1
*
46260000
6126120000
26802600
61202461200
00268026
00612024612
00002646
0000612612
v
v
v
v
v
v
v
v
=


























0
0
0
4,0
0
4,0
0
0
 
 
Em que ∆ é o vetor de deslocamentos globais, sendo v1 o deslocamento 
vertical no nó 1, v‟1 o giro no nó 1 e assim sucessivamente para os outros nós. 
Por fim, colocam-se as condições de contorno, em termos de deslocamento v 
e giro v‟, em cada nó. Considerando que os nós 1 e 4 são engastes, portanto, com 
deslocamentos e giros nulos (v e v‟), v1 = v1‟=v4=v4‟=0, o sistema fica: 
 




























































0
0
'3
3
'2
2
0
0
*
46260000
6126120000
26802600
61202461200
00268026
00612024612
00002646
0000612612
v
v
v
v
=


























0
0
0
4,0
0
4,0
0
0
 
 17 
 
A partir daí, tendo uma função computacional que resolve sistemas lineares, 
pode-se encontrar o vetor de deslocamentos global (). Para encontrar os valores do 
cortante V e do momento M em cada nó de um elemento, faz-se: 
 
i
j
j
i
i
i
j
j
i
i
P
v
v
v
v
K
M
V
M
V
][
'
'
*][ 





























 
 
A partir das equações anteriores, temos o seguinte sistema a resolver: 
 
-12*v2-6*v2‟=0 (1) 
-6*v2+2*v2‟=0 (2) 
24*v2-12*v3+6*v3‟=0,4 (3) 
8*v2‟-6*v3+2*v3‟=0 (4) 
-12*v2-6*v2‟+24*v3=0,4 (5) 
6*v2+2*v2‟+8*v3‟=0 (6) 
-12*v3-6*v3‟=0 (7) 
6*v3+2*v3‟=0 (8) 
 
Computacionalmente o problema está resolvido. Porém, vamos fazer algumas 
simplificações para resolver o problema exemplo. Matematicamente, podemos retirar 
do sistema as linhas onde o vetor de forças é nulo, ou seja, as linhas 1, 2, 7 e 8 
(porque temos 4 incógnitas e 8 equações). Ficamos com 4 equações, suficientes 
para resolver o problema: 
 
24*v2-12*v3+6*v3‟=0,4 (3) 
8*v2‟-6*v3+2*v3‟=0 (4) 
-12*v2-6*v2‟+24*v3=0,4 (5) 
6*v2+2*v2‟+8*v3‟=0 (6) 
 
Resolvendo o sistema, os deslocamentos, ficam: 
v2 = 0,0667 m 
v2‟= 0,0667 rad 
v3 = 0,0667 m 
v3‟ = -0,0667 rad 
Para o elemento 1 (nós 1 e 2): 
 













































0,0667
0,0667
0
0
*
4626
612612
2646
612612
2
2
1
1
M
V
M
V
-














0
4,0
0
0
 
 
V1 = -12*(0,0667) + 6*(0,0667) - 0 = - 0,40 tf 
M1 = -6*(0,0667) + 2*(0,0667) - 0 = - 0,27 tf*m 
V2 = 12*(0,0667) - 6*(0,0667) – 0,4 = 0 tf 
M2 = -6*(0,0667) + 4*(0,0667) - 0 = - 0,13 tf*m 
 18 
 
Para o elemento 2 (nós 2 e 3): 
 













































0,0667-
0,0667
0,0667
0,0667
*
4626
612612
2646
612612
3
3
2
2
M
V
M
V
-














0
4,0
0
4,0
 
 
V2 = 12*0,0667+6*0,0667-12*(0,0667) + 6*(-0,0667) – 0,4 = - 0,4 tf 
M2 = 6*0,0667+4*0,0667-6*(0,0667) + 2*(-0,0667) – 0 = - 0,13 tf*m 
V3 = -12*0,0667-6*0,0667+12*(0,0667) - 6*(-0,0667) – 0,4 = - 0,4 tf 
M3 = 6*0,0667+2*0,0667-6*(0,0667) + 4*(-0,0667) – 0 = - 0,13 tf*m 
 
Para o elemento 3 (nós 3 e 4): 
 













































0
0
0,0667-
0,0667
*
4626
612612
2646
612612
4
4
3
3
M
V
M
V
-














0
0
0
4,0
 
 
V2 = 12*0,0667+6*(-0,0667) – 0,4 = 0 tf 
M2 = 6*0,0667+4*(-0,0667) – 0 = 0,13 tf*m 
V3 = -12*0,0667-6*(-0,0667) – 0 = - 0,4 tf 
M3 = 6*0,0667+2*(-0,0667) – 0 = 0,27 tf*m 
 
Comparando os valores com os diagramas exatos, obtidos pelo aplicativo 
FTOOL, a seguir, percebe-se a validade do MEF: 
 
 
 
 
 O que o aluno tem que entender aqui não é o MEF em si, mas que o MEF 
utiliza a resolução de um sistema linear de equações, o que se vai estudar a seguir. 
 Cumpre destacar que há muitos outros métodos em Engenharia Civil, em 
suas diversas subáreas, que precisam da resolução de sistemas lineares. 
 
 19 
 
3.2 SOLUÇÃO NUMÉRICA COMPUTACIONAL DE SISTEMAS LINEARES DE 
EQUAÇÕES 
 
Um sistema linear da forma AX = B pode ser resolvido por meio de métodos 
diretos ou de métodos iterativos. Um método é direto quando a solução exata é 
obtida realizando-se um número finito de operações aritméticas. Um método é 
iterativo quando a solução é obtida como limite de uma sequencia de aproximações 
sucessivas, ou seja, deve-se truncar, parar a solução após certo número de 
iterações. 
 
3.2.1 MÉTODOS DIRETOS PARA A SOLUÇÃO DE SISTEMAS LINEARES 
 
Considere um sistema triangular da forma: 
 
Ele pode ser resolvido por retro substituição, ou seja, resolve-se a última 
linha, substituindo o resultado na penúltima, e assim por diante. Como regra geral, 
podem-se assim obter as soluções: 
; 
 
A seguir apresentam-se os algoritmos para resolução de sistemas 
triangulares superiores (exemplo acima, onde se começa a resolução pela última 
linha) e inferiores (contrário, onde a primeira linha só tem 1 termo e a resolução 
começa por ela): 
 
RESOLUÇÃO DE SISTEMAS TRIANGULARES SUPERIORES 
 
 
 
 
 
 
 
 
 
 
 
 20RESOLUÇÃO DE SISTEMAS TRIANGULARES INFERIORES 
 
 
 
 
 Daqui para frente o aluno irá se deparar com algoritmos, que são as 
sequencias de cálculo de uma determinada tarefa. Quando se quer entender o que 
um algoritmo faz, pode-se calculá-lo passo-a-passo. Segue um exemplo usando o 
algoritmo para resolução de SISTEMAS TRIANGULARES SUPERIORES 
apresentado: 
 
  
 
n=4 
x4=b4/a44=2/2=1 
i=n-1=3 
soma=0 
 j=i+1=4 (=n, portanto último e único passo) 
 soma=soma+a34*x4=0+(-5)*1=-5 
x3=(b3-soma)/a33=(3-(-5))/4=8/4=2 
i=i-1=2 
soma=0 
 j=i+1=3 
 soma=soma+a23*x3=0+1*2=2 
 j=j+1=4 (=n, portanto último passo) 
 soma=soma+a24*x4=2+(-2)*1=0 
x2=(b2-soma)/a22=((-1)-0)/1=-1 
i=i-1=1 (=n, portanto último passo) 
soma=0 
 j=i+1=2 
 soma=soma+a12*x2=0+4*(-1)=-4 
 j=j+1=3 
 soma=soma+a13*x3=(-4)+(-5)*2=-14 
 j=j+1=4 (=n, portanto último passo) 
 soma=soma+a14*x4=(-14)+1*1=-13 
x1=(b1-soma)/a11=((-10)-(-13))/3=3/3=1 
 
 Esta resolução passo-a-passo verificando a variação do valor de cada 
variável ao longo da execução do algoritmo é chamada DEPURAÇÃO (“DEBUG”, 
em inglês, referindo-se ao ato de procurar erros, “bugs”). 















1
2
1-
1
x
 21 
 
 A maioria dos softwares para criar softwares, como o Lazarus, tem uma 
função debug, em que apresenta uma tabela mostrando a variação dos valores das 
variáveis passo-a-passo. 
 Para resolver em papel um algoritmo, pode-se fazer conforme apresentado 
anteriormente ou fazer uso de uma tabela de depuração como a apresentada a a 
seguir, onde são colocadas as variáveis uma em cada coluna e cada linha apresenta 
a variação dos valores passo-a-passo. Veja: 
 
EXEMPLO DE TABELA DE DEPURAÇÃO – SISTEMA TRIANGULAR SUPERIOR 
 
  
 
 
 
************************************************************************************************* 
 
EXERCÍCIOS 
 
3.1) Resolver, em papel, usando o algoritmo apresentado, o seguinte sistema linear 
triangular superior de ordem 4 (apresentar o passo-a-passo com todas as variáveis; 
pode ser na forma de tabela de depuração, mas não é obrigatório): 
 
3x1+2x2-4x3+3x4=-5 
6x2-x3+x4=14 
2x3+x4=11 
5x4=10 
 
 22 
 
3.2) Resolver, em papel, usando o algoritmo apresentado, o seguinte sistema linear 
triangular inferior de ordem 4 (apresentar o passo-a-passo com todas as variáveis): 
 
2x1=8 
5x1+2x2=16 
x1-x2+x3=5 
3x1+5x2-2x3+2x4=19 
 
3.3) Crie um programa em HTML/Lazarus, na página do GRUPO, para resolver um 
sistema linear triangular qualquer superior de ordem n (n x n) qualquer. Abaixo 
segue um algoritmo possível para a página HTML e arquivo .js com algoritmos para 
a leitura e impressão dos dados (sem os cálculos). O aluno deve implementar o 
algoritmo de resolução descrito. O professor irá verificar diretamente na página do 
grupo. 
 
ARQUIVO sistemasuperior.html 
 
<html> 
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> 
<title>Sistema Linear Triangular Superior</title> 
<script src='funcoes-sistemasuperior.js'></script> 
SISTEMA LINEAR TRIANGULAR SUPERIOR 
<br><br> 
Ordem do sistema (n): 
<input type="number" id="ordem" value="4"> 
<br><br> 
</form> 
<button onclick="gerar()">GERAR</button> 
<br><br> 
Obs: Matriz COMPLETA (a última coluna - cinza - contém as constantes, os valores após a igualdade). 
<br><br> 
<ins id="tabela"></ins> <!-- TABELA IMPRESSA, DE ACORDO COM A FUNÇÃO gerar() no arquivo .js --> 
<br> 
<button onclick="calcular()">CALCULAR</button> 
<br><br> 
<ins id="resultado"></ins> <!-- IMPRESSÃO DOS RESULTADOS, DE ACORDO COM A FUNÇÃO calcular() no 
arquivo .js --> 
<br><br> 
</html> 
 
ARQUIVO funções-sistemasuperior.js 
 
function gerar(){ 
 n=document.getElementById("ordem").value; //lê n 
 n=Number(n); //para definir que n é número, não texto 
 col=n+1; //número de colunas, porque a última coluna são os valores após a igualdade 
 //abaixo, html dentro do javascript, para criar a tabela dinamicamente (nxn) 
 html=""; 
 html+='<table border>'; 
 for (i=1;i<=n;i++){ 
 html+='<tr>'; 
 for(j=1;j<=n;j++){ 
 ntermo=i+','+j; 
 conteudo='<input type="number" id='+ntermo+' value="0"/>'; 
 html+='<td>'+conteudo+'</td>'; 
 } 
 ntermo=i+','+col; 
 conteudo='<input type="number" style="background-color: #C0C0C0" id='+ntermo+' value="0"/>'; 
 html+='<td>'+conteudo+'</td>'; 
 html+='</tr>'; 
 23 
 
 } 
 html+='</table>'; 
 document.getElementById('tabela').innerHTML=html; 
 } 
 
function calcular(){ 
 n=document.getElementById("ordem").value; 
 n=Number(n); 
 
 //ler os termos aij 
 a=[]; //criar o vetor 
 for (i=1;i<=n;i++){ 
 for(j=1;j<=n;j++){ 
 ntermo=i+','+j; 
 a[ntermo]=document.getElementById(""+ntermo+"").value; 
a[ntermo]=Number(a[ntermo]); 
 } 
 } 
 
 //ler os termos bi 
 col=n+1; 
 b=[]; //criar o vetor 
 for (i=1;i<=n;i++){ 
 ntermo=i+','+col; 
 b[i]=document.getElementById(""+ntermo+"").value; 
b[i]=Number(b[i]); 
 } 
 
 sistemasuperior(n,b,a); //chama a função que calcula o sistema triangular superior 
 
 //imprimir os resultados xi 
 res=''; 
 for (i=1;i<=n;i++){ 
 res=res+'\r\nx'+i+'\r\n='+x[i]+'<br>' 
 } 
 document.getElementById('resultado').innerHTML = res; 
 
 } 
 
function sistemasuperior(n,b,a){ //AQUI ENTRA O ALGORITMO DOS ALUNOS 
 
//entra n, b e a. Sai x. 
IMPLEMENTE O ALGORITMO AQUI. 
(...) 
 
} 
 
O exemplo cujo passo-a-passo do algoritmo foi mostrado anteriormente está a 
seguir, no formato que deve ficar o programa: 
 
 24 
 
 
 
3.4) Duplique o programa anterior e o altere para resolver um sistema linear 
triangular qualquer inferior de ordem n. O professor irá verificar diretamente na 
página do grupo. 
 
 Um exemplo adaptado a partir do anterior, invertendo as equações, fica: 
2x1=2 
-5x1+4x2=3 
-2x1+x2+x3=-1 
x1-5x2+4x3+3x4=-10  
 
 
 
************************************************************************************************* 
 















1
1-
2
1
x
 25 
 
As soluções dos sistemas lineares inferior e superior são necessárias no 
MÉTODO DA ELIMINAÇÃO DE GAUSS. 
 
MÉTODO DA ELIMINAÇÃO DE GAUSS (OU MÉTODO DO ESCALONAMENTO) 
 
Este método consiste em construir, a partir de um sistema de equações 
lineares qualquer, um sistema triangular A′X = B′ equivalente que pode ser resolvido 
por retro substituição, com os algoritmos estudados anteriormente. 
Quadros e Bortoli (2009) citam que dois sistemas lineares de dimensão n x n 
são equivalentes desde que os seus conjuntos de soluções sejam os mesmos. 
Teoremas de álgebra linear mostram que, quando certas operações são aplicadas a 
um dado sistema, a solução não muda. 
Citam os autores que as seguintes operações, quando aplicadas a um 
sistema linear, resultam num sistema equivalente: 
1. Mudança de ordem de duas equações. 
2. Multiplicação de uma equação por uma constante não nula. 
3. Adição de um múltiplo de uma equação a outra equação. 
Quadros e Bortoli (2009) descrevem o método de eliminação de Gauss para 
um sistema de ordem 3, sendo que o mesmo processo pode ser aplicado a sistemas 
de qualquer ordem. Apresentam o seguinte sistema: 
 
 
 
 Considere-se somente a matriz dos coeficientes aij aumentada contendo os 
termos independentes bi: 
 
 
 
O objetivo é obter um sistema triangular da forma abaixo, sendo que os 
elementos da segunda até a última linha (no caso, a terceira) não serão os mesmos 
da matriz original (por isso estão indicados com o índice linha): 
 
 
 
O processo consiste em fazer uma combinação linear para zerar os 
elementos da primeira coluna abaixo do pivô (primeiro elementonão-nulo de cada 
linha), obtendo: 
 
 26 
 
 
 
 Uma combinação linear (considerando os critérios 1 a 3 dispostos no começo 
do capítulo) que chega ao resultado da matriz anterior é, segundo Cantão (????), 
para cada linha “i”, a partir da segunda, subtrair a primeira linha multiplicada pelo 
fator: 
 
 
 Então, cada elemento da linha i modificada fica (o expoente “(2)” é para 
indicar que os elementos são de uma 2ª matriz): 
 
 
Sendo assim, os novos valores para o exemplo de 3 linhas são dados por: 
 
 linha 2 linha 3 
 
 
 Repete-se o processo para zerar os elementos inferiores da segunda coluna, 
sendo que os elementos da matriz ficam: 
 
linha 3 
 
 
 O processo é conhecido também como ESCALONAMENTO. 
Quadros e Bortoli (2009) lembram que o sistema final não pode ter elementos 
nulos na diagonal, ou seja, os elementos a11, a22, a33 etc. não podem ser nulos, o 
que resultaria num sistema sem solução por este método. 
Quadros e Bortoli (2009) apresentam o seguinte exemplo: 
 
 
Jessica
Nota
m= a21/a11 null= a21-a11*m1null= a21-a11(a21/a11)null= a21-a21 =0
Jessica
Nota
Começa no a33, porque o a32 vai zerar.nullColocar no algoritmo a32=0
 27 
 
 
 A matriz aumentada para este sistema é (o pivô está sublinhado): 
 
 
 
m21 = a21/a11 = 2/1 = 2 
m31 = a31/a11 = 4/1 = 4 
m41 = a41/a11 = -3/1 = -3 
 
a‟21 = a21 – m21*a11 = 2-2*1 = 0 (ok) 
a‟22 = a22 – m21*a12 = 0-2*2 = -4 
a‟23 = a23 – m21*a13 = 4-2*1 = 2 
a‟24 = a24 – m21*a14 = 3-2*4 = -5 
b‟2 = b2 – m21*b1 = 28-2*13 = 2 
 
a‟31 = 0 
a‟32 = a32 – m31*a12 = 2-4*2 = -6 
a‟33 = a33 – m31*a13 = 2-4*1 = -2 
a‟34 = a34 – m31*a14 = 1-4*4 = -15 
b‟3 = b3 – m31*b1 = 20-4*13 = -32 
 
a‟41 = 0 
a‟42 = a42 – m41*a12 = 1-(-3)*2 = 7 
a‟43 = a43 – m41*a13 = 3-(-3)*1 = 6 
a‟44 = a44 – m41*a14 = 2-(-3)*4 = 14 
b‟4 = b4 – m41*b1 = 6-(-3)*13 = 45 
 
Portanto, o resultado, após a eliminação, para a 2ª matriz, é (já informando os 
parâmetros pivô e “m” para a próxima etapa): 
 
 
 
A terceira matriz fica: 
 
m32 = a32/a22 = -6/-4 = 1,5 
m42 = a42/a22 = 7/-4 = -1,75 
 
 
a‟31 = 0 
a‟32 = 0 
a‟33 = a33 – m32*a23 = (-2)-1,5*2 = -5 
a‟34 = a34 – m32*a24 = (-15)-1,5*(-5) = -7,5 
b‟3 = b3 – m32*b2 = (-32)-1,5*2 = -35 
 28 
 
 
a‟41 = 0 
a‟42 = 0 
a‟43 = a43 – m42*a23 = 6-(-1,75)*2 = 9,5 
a‟44 = a44 – m42*a24 = 14-(-1,75)*(-5) = 5,25 
b‟4 = b4 – m42*b2 = 45-(-1,75)*2 = 48,5 
 
 
 
 A quarta e última matriz fica: 
 
m43 = a43/a33 = 9,5/-5 = -1,9 
 
a‟41 = 0 
a‟42 = 0 
a‟43 = 0 
a‟44 = a44 – m43*a34 = 5,25-(-1,9)*(-7,5) = -9 
b‟4 = b4 – m43*b3 = 48,5-(-1,9)*(-35) = -18 
 
 
 
 Observando que todos os elementos da diagonal são não nulos, a solução, 
calculada conforme exposto anteriormente (sistema triangular superior), fica: 
 
Para n = 4; i = 4: 
 
  
2
9
18
44
4
4 



a
b
x
 
Para n = 4; i = 3: 
  4
5
)2*5,7(35
*
33
4
4
33
3 







a
xab
x
j
jj
 
 
Para n = 4; i = 2: 
  1
4
))2*)5((4*2(2
*
22
4
3
22
2 







a
xab
x
j
jj
 
 
 29 
 
Para n = 4; i = 1: 
  3
1
))2*4()4*1())1(*2((13
*
11
4
2
11
1 






a
xab
x
j
jj
 
 
Conforme Quadros e Bortoli (2009), o método de Gauss irá falhar quando um 
pivô for nulo, pois, neste caso, não seria possível calcular os multiplicadores “m” 
Este sério problema pode ser evitado pelo uso da estratégia de pivoteamento. Esta 
consiste em trocar linhas (ou colunas) de forma a ter sempre o pivô não-nulo. A 
técnica de pivoteamento parcial tem o seguinte esquema de escolha do pivô: 
1º Pivô = elemento de maior valor absoluto (módulo) na coluna 1; 
2º Pivô = elemento de maior valor absoluto na coluna 2; 
E assim sucessivamente. 
 
A seguir apresenta-se um exemplo com pivoteamento parcial: 
 
 
 
A matriz aumentada para este sistema é: 
 
 
 
Fazendo-se o pivoteamento parcial, ou seja, colocando a linha com o maior 
pivô como a primeira: 
 













4584
3742
3309
 
 
 Fazendo uma operação para zerar os termos abaixo da linha do pivô, 
conforme explicado anteriormente: 
 
m21 = a21/a11 = 2/9 = 0,222 
m31 = a31/a11 = 4/9 = 0,444 
 
a‟21 = 0 
a‟22 = a22 – m21*a12 = (-4)-0,222*0 = -4 
a‟23 = a23 – m21*a13 = 7-0,222*(-3) = 7,666 
b‟2 = b2 – m21*b1 = 3-0,222*3 = 2,334 
 
a‟31 = 0 
 30 
 
a‟32 = a32 – m31*a12 = (-8)-0,444*0 = -8 
a‟33 = a33 – m31*a13 = 5-0,444*(-3) = 6,332 
b‟3 = b3 – m31*b1 = (-4)-0,444*3 = -5,332 
 













332,5332,680
334,2666,740
3309
 
 
Fazendo-se novamente o pivoteamento parcial, ou seja, colocando a linha 
com o maior pivô (em módulo) como a próxima linha de resolução: 
 













334,2666,740
332,5332,680
3309
 
 
Para o segundo pivô: 
 
m32 = a32/a22 = -4/-8 = 0,5 
 
a‟31 = 0 
a‟32 = 0 
a‟33 = a33 – m32*a23 = 7,666-0,5*6,332 = 4,5 
b‟3 = b3 – m32*b2 = 2,334-0,5*(-5,332)= 5 
 












55,400
332,5332,680
3309
 
 
 E, finalmente, resolvendo o sistema triangular superior: 
 
x1 = 0,7037; x2 = 1,5462; x3 = 1,1111 
 
 A seguir apresenta-se um algoritmo para a resolução de sistema de equações 
lineares pelo Método de Eliminação de Gauss com pivoteamento: 
 
Dado n, Anxn e bnx1 
 
1: Para k=1 até k=n-1 faça //para cada coluna 
2: w=|akk| //w é o pivô 
3: r=k //r é o nº da linha que está o pivô 
4: Para j=k até j=n faça //para cada linha 
5: Se |ajk|>w então //encontra o maior pivô em módulo 
6: w=|ajk| 
7: r=j 
8: Fim do condicional 
9: Fim do laço 
10: Se w=0 então 
11: „Todos os pivôs são nulos.‟ PARE. 
Jessica
Nota
É até n-1, porque n=colunas, mas zera só até a coluna n (nesse caso 3).
 31 
 
12: Senão 
13: Troque a linha k com a linha r 
14: Fim do condicional 
15: Para i=k+1 até i=n faça //para cada linha, menos a anterior (que tem o pivô) 
16: mik=aik/akk 
17: bi=bi-mikxbk 
18: aik=0 
19: Para j=k+1 até j=n faça //para cada coluna, a partir da k 
20: aij=aij-mikxakj 
21: Fim do laço 
22: Fim do laço 
23: Fim do laço 
24: Execute o algoritmo de solução de sistemas triangulares superiores. 
 
Para estudar mais aprofundadamente o Método da Eliminação de Gauss com 
pivoteamento parcial, acesse: 
http://vtp.ifsp.edu.br/nev/Sistema-gauss/sistemagauss.html 
 
************************************************************************************************* 
 
EXERCÍCIOS 
 
3.5) Resolver, em papel, o seguinte sistema linear pelo Método de Gauss, com 
pivoteamento parcial: 
 
 
3.6) Resolver, em papel, o exercício anterior usando o algoritmo apresentado, 
apresentando o passo a passo. 
 
3.7) Duplique o programa do exercício 3.3 (sistema triangular superior) e modifique-o 
para resolver sistemas pelo algoritmo de eliminação de Gauss com pivoteamento 
parcial, que acabou de ser apresentado. 
 Para implementar o algoritmo, seguem algumas informações, na ordem do 
algoritmo proposto: 
 
Módulo de um número n: 
Math.abs(n) 
 
Condicional: 
if (a<0) { 
//qualquer código 
} 
Obs: use os operadores lógicos a seguir: 
== igual a //ATENÇÃO, NA COMPARAÇÃO COLOQUE 2 IGUAIS 
!= diferente 
>, <, >=, <= maior, menor, maior ou igual e menor ou igual 
 
PARE (parar o programa): 
return; 
 32 
 
 
Condicional com “SENÃO”: 
 
if (a==0) { 
//código} else { 
//código 
} 
 
Trocar a linha k pela linha r: 
 
for(c=1;c<=n+1;c++) { //coluna 1 a n+1 
atemp=a[k+','+c]; //variável temporária 
a[k+','+c]=a[r+','+c]; 
a[r+','+c]=atemp; 
} 
btemp=b[k]; //variável temporária para b 
b[k]=b[r]; 
b[r]=btemp; 
 
O professor irá verificar diretamente na página do grupo. 
 
3.8) EXTRA (desafio): Crie um aplicativo que calcule os esforços nos nós de uma 
viga com 2 vínculos de extremidade (o usuário deve escolher entre apoio móvel, 
apoio fixo e engaste), semelhante à apresentada no exemplo inicial deste capítulo 
(com 4 nós), sendo que o usuário poderá colocar quaisquer forças e/ou momentos 
concentrados em seus nós 2 e 3 e qualquer comprimento de viga. 
 
************************************************************************************************* 
 
MÉTODO DA FATORAÇÃO LU 
 
O método da fatoração LU é um método derivado do Método da Eliminação 
de Gauss, que apresenta a vantagem de que o escalonamento é feito 
independentemente do vetor dos termos independentes b i. Então se pode escalonar 
o sistema e salvá-lo na memória, resolvendo-o para qualquer vetor de termos 
independentes bi. No processo de Gauss, toda vez que se muda o vetor b i, deve-se 
fazer novamente todo o escalonamento. Lembre-se que, no caso do MEF, por 
exemplo, para uma viga qualquer, a matriz de rigidez (A) é fixa e o vetor bi contém 
as ações. 
De acordo com Ruggiero (1996), neste método, para resolver o sistema linear 
Ax=b, se pudermos realizar a fatoração A=CD, o sistema fica (CD)x=b. Se y=Dx, 
então resolver o sistema é equivalente a resolver Cy=b e, depois, Dx=y. 
Cantão (????) cita que LU é um termo que vem do inglês lower e upper, já 
que o método se baseia na decomposição da matriz A na forma A = L*U, onde L é 
uma matriz triangular inferior (todos os elementos acima da diagonal são nulos) com 
elementos da diagonal principal iguais a 1 e U é uma matriz superior (todos os 
elementos abaixo da diagonal são nulos) qualquer. 
Para encontrar L e U, faz-se o escalonamento da matriz aumentada composta 
da matriz identidade I (elementos da diagonal iguais a 1 e o restante dos elementos 
 33 
 
nulos) e a matriz principal A. Depois resolvem-se as duas partes do sistema (Ly=b, 
obtendo y e Ux=y, obtendo a solução final x). 
Primeiro vamos teorizar o método, usando um sistema linear literal, conforme 
Ruggiero (1996): 
 
  
 
Considerando o escalonamento somente da matriz dos coeficientes A, sem o 
vetor das constantes b, porque queremos fatorar somente A, conforme 
anteriormente explicado, os multiplicadores da etapa 1 são: 
 
 
E, normalmente, os coeficientes para gerar a matriz A(1) são calculados como: 
 
 
 Percebe-se que os mesmos resultados são conseguidos, para a matriz A(1) da 
1ª etapa, multiplicando A(0) por M(0) conforme abaixo: 
 
 
 
Para a 2ª etapa, supondo : 
 
 
 
 34 
 
 Percebe-se que os mesmos resultados são conseguidos, para a matriz A(2) da 
2ª etapa, multiplicando A(1) por M(1) conforme abaixo: 
 
 
 
Em resumo: 
A(1) = M(0)A(0) 
A(2) = M(1)A(1) = M(1)M(0)A(0) 
 
 Então: 
A(0) = (M(1))(-1)(M(0))(-1)A(2) 
 
 
 
Então, sendo A a matriz original (ou A(0)), encontra-se a fatoração LU 
procurada: 
 
 
Note que a dedução não considerou o pivoteamento parcial. Cantão (????) 
apresenta um exemplo: 
 
 
 
 A*x = b 
 
 Para a matriz A, o escalonamento é feito normalmente como apresentado no 
Método de Eliminação de Gauss: 
 
1ª Etapa: 
 
m21 = a21/a11 = 1/3 
m31 = a31/a11 = 4/3 
 
= A
(2) 
 35 
 
a‟21 = 0 
a‟22 = a22 – m21*a12 = 1-1/3*2 = 1/3 
a‟23 = a23 – m21*a13 = 2-1/3*4 = 2/3 
 
a‟31 = 0 
a‟32 = a32 – m31*a12 = 3-4/3*2 = 1/3 
a‟33 = a33 – m31*a13 = 2-4/3*4 = -10/3 
 
 
 
2ª Etapa: 
 
m32 = a32/a22 = (1/3)/(1/3) = 1 
 
a‟31 = 0 
a‟32 = 0 
a‟33 = a33 – m32*a23 = (-10/3)-1*(2/3) = -4 
 
U = 
 
L = = 
 
 Resolvendo Ly=b: 
 
 
 Na resolução anterior, lembre-se que o expoente T significa que o vetor y é 
transposto, ou seja, que, na verdade, os valores estão em coluna, não em linha. 
 Resolvendo Ux=y: 
 
 
 Exposto o método, obviamente é interessante resolver o Método 
considerando o pivoteamento parcial. Para entender os impactos do pivoteamento 
na fatoração LU, Ruggiero (1996) explica o conceito de MATRIZ DE PERMUTAÇÃO 
como sendo uma matriz obtida a partir da permutação de linhas e/ou colunas da 
 36 
 
matriz identidade. Então, permutar linhas e/ou colunas de uma matriz qualquer A é 
equivalente a permutar essas mesmas linhas e/ou colunas numa matriz identidade 
(gerando a MATRIZ DE PERMUTAÇÃO) e multiplicá-la pela matriz A. Veja: 
 
  quero permutar para  
 
 Se quisermos criar uma matriz A‟ com a 1ª linha sendo a 2ª linha de A, a 2ª 
linha sendo a 3ª linha de A e a 3ª linha sendo a 1ª linha de A, fazemos essas 
operações numa matriz identidade e multiplicamos por A: 
 











100
010
001
I  











001
100
010
P 
 
  OK 
 
 Seja o sistema linear Ax=b, permutando A temos que permutar b, então 
 e . Então: porque queremos fatorar 
A‟=LU. 
 Para resolver o sistema: 
 
 
 Lembrando que: 
L = com multiplicadores a partir da matriz A‟=PA; 
U é a matriz A‟ escalonada (Método de Gauss). 
 
 Ruggiero (1996) apresenta um exemplo: 
 
A
’
 = 
 37 
 
  
 
 Fazendo o pivoteamento (1ª etapa), o maior pivô está na linha 3 e, portanto, 
devemos trocá-la com a 1ª linha: 
 e 
 
 Ao efetuar a eliminação de Gauss, Ruggiero (1996) usa as posições zeradas 
para guardar os multiplicadores m. Isso é comum em algoritmos para economizar 
memória computacional. Dessa maneira, efetuando a eliminação na matriz A‟(0): 
 
 
 Fazendo o pivoteamento (2ª etapa), o maior pivô está na linha 3 e, portanto, 
devemos trocá-la com a 2ª linha: 
 
 
 
Efetuando a eliminação na matriz A‟(1): 
 
 
 
 E, portanto: 
 
 38 
 
 
 
 : 
 
X = = P 
 
 
 
 
 
 
 
 Para efeito do algoritmo que será apresentado, Ruggiero (1996) define um 
vetor pk contendo a ordem das linhas da matriz A em cada etapa k. Sendo assim, no 
exemplo apresentado, p0 = (1,2,3), p1 = (3,2,1) e p2 = (3,1,2). 
 
Dado n, Anxn e bnx1 
 
 
 39 
 
 
 
 
//veja que, até aqui, o algoritmo é parecido com o de resolução por Gauss, exceto 
pelo vetor p. 
 
 
//veja que a matriz a(i,j) já é a matriz L considerando sua parcela inferior, a menos da 
diagonal (a(i,i), que é toda igual a 1, que será usada na resolução do sistema. Então, 
na verdade, a função é quase a mesma da resolução de sistema triangular inferior, 
considerando a matriz A, exceto pela última linha, que não divide por a(i,i) porque já 
assume que vale 1. 
 40 
 
 
//veja que a matriz a(i,j) já é a matriz U considerando sua parcela superior, que será 
usada na resolução do sistema. Então, na verdade, a função é idêntica à de 
resolução de sistema triangular superior, considerando a matriz A. 
 
************************************************************************************************* 
 
EXERCÍCIOS: 
 
3.10) Resolver, em papel, o seguinte sistema linear (o mesmo do exercício 3.5) pela 
fatoração LU com pivoteamento normal (não parcial): 
 
 
3.11) Resolver, em papel, o sistema do exercício anterior pela fatoração LU com 
pivoteamento parcial. 
 
3.12) Usando como base os programas anteriormente criados, crie um software para 
resolver sistemas pelo algoritmo de fatoraçãoLU com pivoteamento parcial, que 
acabou de ser apresentado. O software deve mostrar as matrizes completas A|c 
(sendo que a parte inferior de A, exceto a diagonal com elementos iguais a 1, é L) e 
A|y (sendo que a parte superior é U) conforme o exemplo a seguir: 
 
 41 
 
 
 
O professor irá verificar diretamente na página do grupo. 
 
************************************************************************************************* 
 
3.2.2 MÉTODOS ITERATIVOS PARA A SOLUÇÃO DE SISTEMAS LINEARES 
 
 No caso de sistemas lineares maiores e esparsos (com grande quantidades 
de zeros), os métodos diretos consomem grande memória computacional ou até 
podem não ser eficientes. Por isso, existem métodos de resolução iterativa de 
sistemas, ou seja, calculando uma solução inicial e outras sucessivamente, até que 
o critério de convergência seja satisfeito. 
 
MÉTODO DE GAUSS-JACOBI (OU MÉTODO DE JACOBI OU MÉTODO DOS 
DESLOCAMENTOS SIMULTÂNEOS) 
 
 Considere o sistema: 
 42 
 
 
 
O que se faz, no Método de Jacobi, é isolar o vetor X (soluções x1 a xn) 
mediante a separação dos elementos diagonais. Assim: 
 
 
 
 Veja que a primeira parcela das soluções teria divisão por zero se um 
elemento diagonal fosse nulo. Portanto, exige-se que todos os elementos da 
diagonal sejam não nulos, ou seja, aii ≠ 0, para i = 1 até n. Para sistemas que 
apresentem esta característica, pode-se permutar linhas até que todos os elementos 
da diagonal sejam não-nulos, antes de resolver. 
 
 Podemos escrever: X = C*X + D, sendo: 
 
 Depois, “chuta-se” uma solução X(k) qualquer e calculam-se as soluções 
iterativamente até que haja uma convergência. Assim: 
 
 
Cantão (????) dá um exemplo para a resolução do seguinte sistema: 
 
 
 43 
 
 
 Rearranjando da forma anteriormente exposta: 
 
 
 
 Pode-se começar com uma solução X(0) = (0,0,0) e fazer as iterações. Veja: 
 
 
 
 Veja que as soluções começam a convergir rapidamente. No caso deste 
exemplo, sabemos que a solução exata é X = (1,1,1). 
 Normalmente, nos programas, fixa-se um erro relativo entre a iteração atual e 
a anterior que se quer atingir e calculam-se as iterações necessárias para isso. 
Mesmo assim deve-se fixar um número máximo de iterações, para evitar um tempo 
de resolução alto no caso em que o sistema demore a convergir ou nem convirja. 
 Apresenta-se a seguir um algoritmo para resolução de sistemas lineares pelo 
Método de Jacobi, devendo o usuário entrar com o vetor X0 contendo uma solução 
inicial arbitrada, com o número máximo de iterações a ser realizado (nit) e com o 
erro relativo alvo (Er). 
 
 
 
 
 
Dado n, Anxn, bnx1, xinxk, nit e Era 
 
//ler a solução inicial como x(„0,1‟), x(„0,2‟) ... x(„0,n‟) – iteração 0 
1: Er(0)=100 //erro relativo inicial, para entrar no “loop enquanto” 
2: k=1 //número da iteração 
3: Enquanto Er(k-1)>Era faça //para erro relativo maior que o alvo 
4: Para i=1 até n faça //para cada linha 
5: soma=0 
6: Para j=1 até n faça //para cada coluna 
7: Se ji então //não na diagonal 
8: Se aii=0 então // na diagonal 
9: 'Erro: Algum elemento da diagonal é nulo.' 
10: PARE 
11: Fim do condicional 
12: soma=soma+a(i,j)*x(k-1,j)/a(i,i) 
13: Fim do condicional 
14: x(k,i)=(b(i)/a(i,i))-soma 
15: Fim do laço 
16: Fim do laço 
17: Er = (|x(k,1)-x(k-1,1)|/|x(k,1)|)*100 
 44 
 
18: Para c=2 até n faça //para cada linha 
19: Se |x(k,c)-x(k-1,c)|/|x(k,c)| > Er(k) então //encontra o maior erro relativo entre os x 
20: Er(k) = (|x(k,c)-x(k-1,c)|/|x(k,c)|)*100 
21: Fim do condicional 
22: Fim do laço 
23: k=k+1 
24: Se (k-1)=nit então //número máximo de iterações atingido 
25: SAIR DO ENQUANTO 
26: Fim do condicional 
27: Fim do loop Enquanto 
 
************************************************************************************************* 
 
EXERCÍCIOS 
 
3.13) Resolver, em papel, o sistema linear a seguir pelo Método de Gauss-Jacobi. 
Faça 7 iterações e calcule o erro relativo em cada iteração k como: 
 
)(
)1()(
k
i
k
i
k
i
x
xx
Er


*100 (em %) * considerar o maior entre todas as soluções xi 
 
 
 
3.14) Resolver, em papel, o exercício anterior seguindo o algoritmo apresentado, 
mostrando seu passo a passo. 
 
3.15) Copie o conteúdo a seguir para criar, no site do grupo, um software para 
resolver sistemas pelo Método de Jacobi que acabou de ser apresentado. Estude 
todo o código para usar os conceitos nos próximos programas. 
ARQUIVO sistemajacobi.html 
 
<html> 
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> 
<title>Sistema Linear - Método de Jacobi</title> 
<script src='funcoes-sistemajacobi.js'></script> 
SISTEMA LINEAR - MÉTODO DE JACOBI 
<br><br> 
Ordem do sistema (n): 
<input type="number" id="ordem" value="4"> 
<br><br> 
</form> 
<button onclick="gerar()">GERAR</button> 
<br><br> 
Obs: Matriz COMPLETA (a última coluna - cinza - contém as constantes, os valores após a igualdade). 
<br><br> 
<ins id="tabela"></ins> <!-- TABELA IMPRESSA, DE ACORDO COM A FUNÇÃO gerar() no arquivo .js --> 
 45 
 
<br> 
<ins id="textonit"></ins> 
<ins id="hinit"></ins> 
<br> 
<br> 
<ins id="textoera"></ins> 
<ins id="hiera"></ins> 
<br><br> 
<ins id="textosolini"></ins> 
<br> 
<ins id="solini"></ins> 
<br> 
<button onclick="calcular()">CALCULAR</button> 
<br><br> 
<ins id="resultado"></ins> <!-- IMPRESSÃO DOS RESULTADOS, DE ACORDO COM A FUNÇÃO calcular() no arquivo .js --> 
<br><br> 
</html> 
 
ARQUIVO funções-sistemajacobi.js 
 
function gerar(){ 
 n=document.getElementById("ordem").value; //lê n 
 n=Number(n); //para definir que n é número, não texto 
 col=n+1; //número de colunas, porque a última coluna são os valores após a igualdade 
 //abaixo, html dentro do javascript, para criar a tabela dinamicamente (nxn) 
 html=""; 
 html+='<table border>'; 
 for (i=1;i<=n;i++){ 
 html+='<tr>'; 
 for(j=1;j<=n;j++){ 
 ntermo=i+','+j; 
 conteudo='<input type="number" id='+ntermo+' value="0"/>'; 
 html+='<td>'+conteudo+'</td>'; 
 } 
 ntermo=i+','+col; 
 conteudo='<input type="number" style="background-color: #C0C0C0" id='+ntermo+' value="0"/>'; 
 html+='<td>'+conteudo+'</td>'; 
 html+='</tr>'; 
 } 
 html+='</table>'; 
 document.getElementById('tabela').innerHTML=html; 
 //número máximo de iterações 
 document.getElementById('textonit').innerHTML = 'Número máximo de iterações:'; 
 document.getElementById('hinit').innerHTML = '<input type="number" id="init" value="50"/>'; 
 //erro relativo alvo 
 document.getElementById('textoera').innerHTML = 'Erro relativo alvo (%):'; 
 document.getElementById('hiera').innerHTML = '<input type="number" id="iera" value="0.1"/>'; 
 //solução inicial (chute) 
 document.getElementById('textosolini').innerHTML = 'Solução inicial (chute):'; 
 html=""; 
 html+='<table border>'; 
 html+='<tr>'; 
 for(j=1;j<=n;j++){ 
 46 
 
 ntermo='e0,'+j; 
 conteudo='<input type="number" id='+ntermo+' value="0"/>'; 
 html+='<td>'+conteudo+'</td>'; 
 } 
 html+='</tr>'; 
 html+='</table>'; 
 document.getElementById('solini').innerHTML=html; 
 } 
 
function calcular(){ 
 n=document.getElementById("ordem").value; 
 n=Number(n); 
 
 //ler os termos aij 
 a=[]; //criar a matriz 
 for (i=1;i<=n;i++){ 
 for(j=1;j<=n;j++){ 
 ntermo=i+','+j; 
 a[ntermo]=document.getElementById(""+ntermo+"").value; 
a[ntermo]=Number(a[ntermo]); 
 } 
 } 
 
 //ler os termos bi 
 col=n+1; 
 b=[]; //criar o vetor 
 for (i=1;i<=n;i++){ 
 ntermo=i+','+col; 
 b[i]=document.getElementById(""+ntermo+"").value; 
b[i]=Number(b[i]);} 
 
 nit=document.getElementById("init").value; //ler o número máximo de iterações 
nit=Number(nit); 
 Era=document.getElementById("iera").value; //ler erro relativo alvo 
Era=Number(Era); 
 
 //ler solução inicial 
 xi=[]; //criar o vetor 
 for (j=1;j<=n;j++){ 
 ntermo='e0,'+j; 
 xi[ntermo]=document.getElementById(""+ntermo+"").value; 
xi[ntermo]=Number(xi[ntermo]); 
 } 
 
 sistemajacobi(n,b,a,nit,Era,xi); //chama a função que calcula o sistema por eliminação de gauss 
 
 //imprimir os resultados de todas as iterações 
 document.getElementById('resultado').innerHTML = res; 
 
 } 
 
 47 
 
function sistemajacobi(n,b,a,nit,Era,x){ 
 
 Er=[]; //criar o vetor 
 Er[0]=100; //inicial pra entrar no while 
 k=1; //número da iteração 
 while(Er[k-1]>Era){ //para erro relativo maior que o alvo 
 for(i=1;i<=n;i++){ //para cada linha ou solução 
 soma=0; 
 for(j=1;j<=n;j++){ //para cada coluna 
 if (j!=i) { 
 if (a[i+','+i]==0) { //na diagonal 
 alert('Erro: Algum elemento da diagonal é nulo.'); 
 return; //pára o programa 
 } 
 soma=soma+a[i+','+j]*x['e'+(k-1)+','+j]/a[i+','+i]; 
 } 
 x['e'+k+','+i]=(b[i]/a[i+','+i])-soma; 
 } 
 } 
 Er[k]=(Math.abs(x['e'+k+',1']-x['e'+(k-1)+',1'])/Math.abs(x['e'+k+',1']))*100; 
 for(c=2;c<=n;c++){ //para cada linha ou solução, a partir da 2 
 if (Math.abs(x['e'+k+','+c]-x['e'+(k-1)+','+c])/Math.abs(x['e'+k+','+c])>Er[k]) { 
 Er[k]=(Math.abs(x['e'+k+','+c]-x['e'+(k-1)+','+c])/Math.abs(x['e'+k+','+c]))*100; 
 } 
 } 
 k=k+1; 
 if ((k-1)==nit) { 
 break; //sai do laço enquanto 
 } 
 } 
 k=k-1; 
 
 //impressão em res 
 res=""; 
 res+='<table border>'; 
 res+='<tr style="background-color: #C0C0C0"><td>ITERAÇÃO</td>'; 
 for(j=1;j<=n;j++){ //linhas 
 res+='<td>x'+j+'</td>'; 
 } 
 res+='<td>ERRO REL. (%)</td>'; 
 res+='</tr>'; 
 for (i=1;i<=k;i++){ //iterações 
 res+='<tr>'; 
 res+='<td style="background-color: #C0C0C0">'+i+'</td>'; 
 for(j=1;j<=n;j++){ //linhas 
 termo=x['e'+i+','+j]; 
 res+='<td>'+termo+'</td>'; 
 } 
 res+='<td style="background-color: #C0C0C0">'+Er[i]+'</td>'; 
 res+='</tr>'; 
 } 
 48 
 
 res+='</table>'; 
} 
 
O software deve mostrar as soluções de cada iteração, conforme o exemplo a 
seguir: 
 
 
O professor irá verificar diretamente na página do grupo. 
 
************************************************************************************************* 
 
MÉTODO DE GAUSS-SEIDEL (OU MÉTODO DOS DESLOCAMENTOS 
SUCESSIVOS) 
 
 Outro método existente para resolução iterativa de sistemas lineares é o 
Método de Gauss-Seidel, que nada mais é que uma pequena modificação do 
Método de Jacobi, onde, no mesmo passo, já são usadas as soluções obtidas. Veja, 
na generalização abaixo, que x2
(k+1) já usa x1
(k+1) que foi calculado na linha anterior, 
dentro da mesma iteração. E o mesmo ocorre para as outras linhas da iteração k+1: 
 
 49 
 
 
 
 Cantão (????) apresenta o mesmo exemplo descrito pelo Método de Jacobi, 
agora resolvido pelo Método de Gauss-Seidel: 
 
 
 
 
 
 As iterações são mostradas na tabela abaixo: 
 
 
 Observe que a solução converge mais rapidamente no Método de Gauss-
Seidel do que no Método de Jacobi. 
 
************************************************************************************************* 
 
EXERCÍCIOS 
 
3.16) Resolver, em papel, o sistema linear a seguir (o mesmo do exercício 3.13) pelo 
Método de Gauss-Seidel. Faça 4 iterações e calcule o erro relativo em cada iteração. 
 
 
3.17) Duplique o exercício 3.15 e transforme-o de modo que a solução seja pelo 
Método de Gauss-Siedel. O professor irá verificar diretamente na página do grupo. 
 
************************************************************************************************* 
 50 
 
4 CÁLCULO DE DETERMINANTES DE MATRIZES 
 
O cálculo de determinantes de matrizes pode não ter aplicação direta nos 
problemas de engenharia, mas aparece indiretamente para verificar se os sistemas 
lineares têm solução. 
 
Dado um sistema linear nxn e sua matriz de coeficientes A: 
- se det(A) ≠ 0  sistema tem solução única (possível e determinado) 
- se det(A) = 0  sistema tem infinitas soluções (possível e indeterminado) ou não 
tem soluções (impossível) 
 
Segundo Massago (2014), o determinante de uma matriz triangular (todos os 
elementos acima ou abaixo da diagonal são zeros) é dado pelo produto dos 
elementos das diagonais. O autor dá um exemplo: 
 
 
 
 É óbvio que nem todas as matrizes são triangulares. Porém, foi estudado 
anteriormente, no MÉTODO DA ELIMINAÇÃO DE GAUSS, um meio de transformar 
um sistema qualquer num sistema triangular. Então, para calcular um determinante 
de uma matriz qualquer, usa-se o ESCALONAMENTO para transformá-lo em uma 
matriz triangular e depois se calcula o produto dos seus elementos diagonais. 
 
************************************************************************************************* 
 
EXERCÍCIOS 
 
4.1) Utilizando o esquema de entrada de dados do programa que calcula sistemas 
lineares por ELIMINAÇÃO DE GAUSS, crie um programa para calcular 
determinantes de matrizes. O resultado deve ficar como o do exemplo a seguir. 
 
 
 
 51 
 
 O algoritmo para multiplicar os elementos da diagonal de uma matriz pode 
ser: 
 
1: det=1; 
2: para j=1 até n { //para cada linha 
3: det=det*a(j,j); 
4: } 
 
O professor irá verificar diretamente na página do grupo. 
 
4.2) No programa que calcula sistemas lineares por ELIMINAÇÃO DE GAUSS, 
incorpore uma verificação que pare a execução quando ele for possível e 
indeterminado ou impossível (det = 0). Teste o seguinte exemplo: 
 
 
 
 
 
O professor irá verificar diretamente na página do grupo. 
 
************************************************************************************************* 
 
 
 52 
 
5 MATRIZ INVERSA 
 
Um sistema linear pode ser resolvido numericamente por meio de um dos 
métodos apresentados no capítulo 3. Porém, poderia ser resolvido um sistema de 
equações usando a matriz inversa: 
 
[A]*[X]=[B]  [X]=[A]-1*[B] 
 
Porém, é consenso que, computacionalmente, a obtenção da matriz inversa 
gera mais operações do que a resolução do sistema pelos outros métodos 
estudados. Isso será explícito no exemplo a seguir. Sendo assim, evita-se usar a 
matriz inversa em resoluções computacionais. 
Porém, se você se deparar com algum problema específico que exija a 
resolução de uma matriz inversa, Quadros e Bortoli (2009) apresentam uma solução, 
com um exemplo reproduzido seguir, semelhante ao processo de escalonamento de 
Gauss, porém usando a matriz aumentada com a matriz identidade (todas as 
diagonais valendo 1 e os outros elementos valendo zero). Ou seja, o que se faz é 
escalonar a matriz até que o sistema se torne triangular superior. Depois disso 
resolvem-se “n” sistemas triangulares superiores sendo que cada solução é uma 
coluna da matriz inversa (“n” é a ordem da matriz original). Resumindo, temos o 
seguinte esquema, segundo Castilho (2001): 
 
- matriz a inverter: 
 
- matriz aumentada: 
 
- sistemas a resolver: 
 
- matriz inversa: 
 
 Obviamente, da mesma maneira feita no processo de pivoteamento de 
Gauss, transforma-se a matriz aumentada em triangular superior antes de resolver 
cada sistema em separado. 
 53 
 
 Castilho dá um exemplo numérico: 
 
  matriz aumentada com I  
 
após escalonamento  
 
 Resolve-se os 3 sistemas (triangulares superiores): 
 
  
 
  
 
  
 
 E, portanto, a inversa fica: 
 
 
 
 Castilho (2001)explica que, no exemplo anterior, a inversa de A é a própria 
matriz A, sendo que é um caso muito útil na verificação do método. 
 Quadros e Bortoli (2005) apresentam outro exemplo: 
 
   
 
 Resolvendo os sistemas triangulares superiores: 
 











3
3
4
)1(X











1
2
1
)2(X














5
6
6
)3(X
 54 
 
 Verificando os procedimentos anteriores, fica claro que o número de 
operações para encontrar a matriz inversa de um sistema é maior do que o custo 
para encontrar diretamente sua solução, pelo Método da Eliminação de Gauss. Isto 
sem considerar que, depois de encontrar a matriz inversa, deve-se multiplicá-la pelo 
vetor solução para definitivamente encontrar o vetor resposta do problema. Sendo 
assim, somente se usa o cálculo numérico de matriz inversa em casos onde é 
necessária sua dedução, o que não ocorre em sistemas lineares. 
 
************************************************************************************************* 
 
EXERCÍCIOS 
 
5.1) Calcular, em papel, a inversa da matriz a seguir, pelo método apresentado 
anteriormente. 
 
 
 
5.2) Partindo do algoritmo que calcula determinantes de matrizes, faça as 
adaptações e crie um programa para calcular inversas de matrizes. O resultado deve 
ficar como o do exemplo a seguir. 
 
 
 
 O algoritmo para acrescentar a matriz identidade à matriz original lida pode 
ser: 
 
 
 
 
 
 
 55 
 
1: para i=1 até n { //linhas 
2: para j=n+1 até 2*n { //colunas 
3: se i=(j-n) { //diagonal da identidade 
4: a(i,j)=1; 
5: } senão { 
6: a(i,j)=0; 
7: } fim do condicional 
8: } fim do para i 
9: } fim do para j 
 
O professor irá verificar diretamente na página do grupo. 
 
************************************************************************************************* 
 56 
 
6 ZEROS DE FUNÇÕES 
 
Antes de iniciarmos os estudos deste capítulo, vamos relembrar as definições 
de FUNÇÃO e EQUAÇÃO. 
 
f(x) = x² + 2x – 8  FUNÇÃO: para qualquer valor de x, podemos calcular o valor 
correspondente de f(x). Especialmente quando 
 xf
=0, o valor de 
x
 é chamado raiz 
da função ou zero da função. Pode haver várias raízes, inclusive. 
 
x² –2x – 8 = 0  EQUAÇÃO: x só podem ser as raízes da função correspondente. 
 
x² –2x – 8 < 0  INEQUAÇÃO: existe um intervalo de valores de x que satisfazem a 
inequação. 
 
Sendo assim, este capítulo dedica-se ao estudo da obtenção de ZEROS DE 
FUNÇÕES, ou seja, raízes das EQUAÇÕES. Veja a figura que ilustra as raízes de 
uma função genérica: 
 
Figura: Raízes de uma função genérica. Fonte: Asano e Colli (2009). 
 
Sabemos que existe, por exemplo, a fórmula de Bhaskara para encontrar as 
raízes de polinômios de segundo grau. Porém, para polinômios de graus superiores, 
usam-se métodos do tipo iterativo para encontrar as soluções. 
Para polinômios de grau “n”, “n” raízes existem, podendo as mesmas serem 
reais ou complexas, diferentes ou não. Pode haver ainda um número infinito de 
soluções, como os casos de senos e cossenos. 
 
6.1 MÉTODO DA BISSECÇÃO (OU DA DICOTOMIA) 
 
 O Método da Dicotomia é um dos métodos numéricos mais simples usados 
para achar as raízes de uma função. O primeiro passo é isolar a raiz x* dentro de um 
intervalo onde a função seja monótona (ou crescente ou decrescente). Veja, na 
figura a seguir, o exemplo de um intervalo [a0,b0] de uma função f crescente, 
contendo a solução x* quando f=0: 
 
Figura: Intervalo [a0,b0] de uma função f crescente, contendo a solução x*. Fonte: 
Asano e Colli (2009). 
 57 
 
 Veja, no exemplo anterior, que f(a0)<0 e f(b0)>0 (seria ao contrário se a função 
fosse decrescente), o que leva a f(a0)*f(b0)<0. 
 Em seguida, passamos a cercar a raiz com intervalos, cada intervalo com a 
metade do tamanho do intervalo anterior, até que se chegue a um intervalo tão 
pequeno que se possa assumir que o centro dele é a solução, com pouco erro. 
 Asano e Colli (2009) apresentam um exemplo com a função f(x)=x3-20: 
 
1) Escolhemos a0 = 2 porque f(a0) < 0 (2
3-20=-12<0) e b0 = 3 porque f(b0) > 0 (3
3-
20=7>0). Este é o chamado TEOREMA DE BOLZANO. 
 
2) Escolhemos o ponto médio do intervalo, ao qual chamaremos provisoriamente de 
c0: 
  c0=2,5 
 
3) Calculamos f(c0) = 2,5
3-20=-4,375<0. Como f(c0) < 0 e a raiz está em f(x*)=0, 
concluímos que a raiz está à direita de c0. Assim, definimos um novo intervalo 
[a1,b1]= [c0,b0]= [2,5;3] 
 
4) Repete-se o procedimento até que o erro seja satisfatório. O erro en é dado por 
, assumindo que a solução está no ponto médio do intervalo. 
 
 Abaixo está a tabela até a décima iteração, contendo a solução rn = cn  en 
 
 
 
 Portanto, a raiz da função f(x)=x3-20 está no intervalo 2,71440,0006. 
 
Segundo Quadros e Bortoli (2009), este método possui baixa velocidade de 
convergência, mas a convergência é garantida. 
Apresenta-se a seguir um algoritmo para o método, sendo dados a função 
f(x), o intervalo [a,b] tal que f(a)*f(b)<0, o erro alvo ea e o número máximo de 
iterações itm. 
 
 
 
 
 58 
 
Dado f(x), a, b, ea, itm 
 
1: xa[0]=a; 
2: xb[0]=b; 
3: k=0; //número da iteração 
4: xm[k]=(xa[k]+xb[k])/2; 
5: se ((f(xa[k])* f(xm[k]))<=0) { 
6: xa[k+1]=xa[k]; 
7: xb[k+1]=xm[k]; 
8: } senão { 
9: xa[k+1]=xm[k]; 
10: xb[k+1]=xb[k]; 
11: } fim do condicional 
12: En[k]=módulo((xb[k]-xa[k])/2); 
13: enquanto (En[k]>ea) { //a partir da iteração 1 
14: k=k+1; 
15: se (k=itm) { 
16: break; //sai do laço enquanto 
17: } fim do condicional 
18: xm[k]=(xa[k]+xb[k])/2; 
19: se ((f(xa[k])* f(xm[k]))<=0) { 
20: xa[k+1]=xa[k]; 
21: xb[k+1]=xm[k]; 
22: } senão { 
23: xa[k+1]=xm[k]; 
24: xb[k+1]=xb[k]; 
25: } fim do condicional 
26: En[k]=módulo((xb[k]-xa[k])/2); 
27: } fim do loop equanto 
 
************************************************************************************************* 
 
EXERCÍCIOS 
 
6.1) Calcular, em papel, a raiz da função no intervalo , 
usando o Método da Dicotomia. Faça iterações até que o erro seja menor que 0,001. 
 
6.2) Considere uma viga biapoiada submetida a uma ação q que segue uma 
variação triangular conforme a figura a seguir. Neste caso, o diagrama de momento 
fletor é dado pela função M(x) e o diagrama de esforço cortante é dado por Q(x) 
(veja a seguir). Usando o Método da Dicotomia, calcule a posição x onde o momento 
fletor é máximo (Q=0) e o valor do momento máximo, para o caso de q = 1,5 tf/m e L 
= 4 m. Faça iterações até que o erro seja menor que 0,001. 
 
 
 
 59 
 
6.3) O professor irá enviar aos grupos, via e-mail, um programa para calcular a raiz 
de uma função qualquer pelo Método da DICOTOMIA, contendo a plotagem do 
gráfico da função. A plotagem de gráficos necessita de arquivos específicos que 
estão na pasta “funcoes_grafico”. Tais arquivos não são necessários de serem 
estudados. Eles são funções disponibilizadas on-line, mas que não são de código 
aberto (não se pode editar), apesar de serem gratuitas. 
O aluno deve estudar somente os arquivos zerodicotomia.html e funcoes-
zerodicotomia.js, além de testar e entender o funcionamento do programa. 
O programa deve ser colocado no site do grupo. O resultado deve ficar como 
o do exemplo a seguir. O professor irá verificar diretamente na página do grupo. 
_________________________________________________________________ 
 
 
 
 
 
 60 
 
 
 
*************************************************************************************************