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 ELÉTRICA:
NOTAS DE AULA

CÁLCULO NUMÉRICO PARA

ENGENHARIA ELÉTRICA

Prof. Msc. Gustavo Cabrelli Nirschl

Janeiro de 2023
 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
 VIDEOAULAS DOS CONTEÚDOS DA APOSTILA DA ENGENHARIA CIVIL

1-CNUE5-Introducao (Métodos numéricos na resolução de problemas)

https://youtu.be/_f03wBfE56I

2-CNUE5-Erro e estabilidade
https://youtu.be/Y21U4W7awVk

3-1-CNUE5-Sistemas Triangulares
https://youtu.be/om9xI6uI1eI

3-2-CNUE5-Sistemas Gauss
https://youtu.be/_mMHHRZetYg

3-3-CNUE5-LU
https://youtu.be/ZW1i6IbAiM8

4-CNUE5-matrizes
https://youtu.be/E_PiKPhwBZg

5-CNUE5-zeros funções
https://youtu.be/t5YOU1jvzFA

6 e 7-CNUE5-interpolacao e aproximação
https://youtu.be/1_oZMgwZ8MQ

8-CNUE5-integracao
https://youtu.be/6fNX0EDxrYE

9-CNUE5-derivacao
https://youtu.be/Wwe00EfL04Y

10-1-CNUE5-ed PVI Euler

https://youtu.be/VCHSnCcKCT4

10-2-CNUE5-PVI Runge
https://youtu.be/gfQjx7-ziaU

10-3-CNUE5-PVC
https://youtu.be/kCUZ5TxRVbo
 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!

Bons estudos!

Prof. Gustavo Cabrelli Nirschl

 PROVAS E TRABALHOS DA DISCIPLINA

MÉDIA = 0,2*P1 + 0,2*P2 + 0,2*P3 + 0,2*P4 + 0,2*TR

SE 4,0  MÉDIA < 6,0 → IFA

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. Em 2023
foram adaptadas para o curso de Engenharia Elétrica. Elas são constantemente
revisadas devido a 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 e não podem ser usadas para outro fim que não para
os estudos desta disciplina.

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.

 SUMÁRIO

1 MÉTODOS NUMÉRICOS NA SOLUÇÃO DE PROBLEMAS ...................................7

2 INTRODUÇÃO À TEORIA DE ERRO E ESTABILIDADE .......................................10
3 SISTEMAS DE EQUAÇÕES LINEARES .................................................................15
4 OPERAÇÕES COM MATRIZES ...............................................................................42
5 ZEROS DE FUNÇÕES ..............................................................................................50
6 FUNÇÕES DE INTERPOLAÇÃO DE DADOS .........................................................60
7 FUNÇÕES DE APROXIMAÇÃO DE DADOS ..........................................................64
8 INTEGRAÇÃO NUMÉRICA DE FUNÇÕES .............................................................75
9 DERIVAÇÃO NUMÉRICA DE FUNÇÕES ................................................................82
10 SOLUÇÃO DE EQUAÇÕES DIFERENCIAIS ........................................................87
11 CONSIDERAÇÕES FINAIS ................................................................................. 103
12 REFERÊNCIAS BIBLIOGRÁFICAS .................................................................... 106
APÊNDICE - INTRODUÇÃO À PROGRAMAÇÃO EM HTML/JAVASCRIPT ....... 108
 7

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 e Elétrica. 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.
 8

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. 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 (sequências 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
desta apostila (exercício 1.1 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.

************************************************************************************************
 9

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 idéias 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ÍCIO

1.1) Criar o programa principal descrito no Apêndice (área de triângulo).

************************************************************************************************
 10

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.

x2 x4 x6
= 1− + − (...)
2! 4! 6!
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(x) − P( x)
Er = *100 (em %)
cos(x)

É 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 (criada no exercício 1.1), 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.
 11

ARQUIVO cosseno.html

ARQUIVO funcoes-cos.js

- Rode o programa off-line e verifique os resultados conforme abaixo:

 12

- 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.

Para estudar mais aprofundadamente o cálculo do cosseno via polinômio de

McLaurin, acesse:
http://vtp.ifsp.edu.br/nev/Cosseno/cosseno.php?

*************************************************************************************************

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.

*************************************************************************************************
 13

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
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

*************************************************************************************************

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 (sequência 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:
 14

ALGORITMO A)

ALGORITMO B)

Os dois resultados são diferentes, quando não deveriam ser, pois a adição é
uma operação distributiva e, obviamente, o resultado é x2 (ALGORITMO B). A causa
dessa diferença foi um arredondamento feito na adição (x2 + x1), cujo resultado tem
8 dígitos. Como a máquina, numa hipótese deste exemplo, 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.
 15

3 SISTEMAS DE EQUAÇÕES LINEARES

3.1 SISTEMAS DE EQUAÇÕES LINEARES NA ENGENHARIA ELÉTRICA

Avila (2019) apresenta um exemplo do cálculo numérico de sistemas lineares

para calcular a corrente (I) no resistor R5 do circuito elétrico a seguir. As
fontes têm valor de V1 = 10 V, V2 = 15 V e V3 = 10 V. Os resistores
são iguais e tem valor de 1 Ω.

Fonte: Ávila (2019).

O circuito elétrico pode ser equacionado pela lei das

tensões de Kirchhoff. Isto resultará num sistema linear com quatro incógnitas,
a saber, as correntes de cada malha. Um equacionamento possível
é:

Na forma matricial:
 16

Resolvendo o sistema por algum método, I = [2,3333 3,3333 2,3333 0,3333].

Fazendo IR5 = I2 + I4, tem-se 3,6667 A.

O que o aluno tem que entender aqui não é o MÉTODO DE MONTAGEM DO

SISTEMA em si, mas que ele 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 Elétrica, em
suas diversas subáreas, que precisam da resolução de sistemas lineares.
 17

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 sequência 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

1: x(n) = b(n)/a(n,n)
2: Para i=n-1 até i=1 faça //a partir da penúltima linha, até a primeira
3: soma=0
4: Para j=i+1 até j=n faça
5: soma=soma + a(i,j)*x(j)
6: Fim do laço
7: x(i) = (b(i)-soma) / a(i,i)
8: Fim do laço
 18

RESOLUÇÃO DE SISTEMAS TRIANGULARES INFERIORES

1: x(1) = b(1)/a(1,1)
2: Para i=2 até i=n faça //a partir da segunda linha, até a última
3: soma=0
4: Para j=1 até j=i-1 faça
5: soma=soma + a(i,j)*x(j)
6: Fim do laço
7: x(i) = (b(i)-soma)/a(i,i)
8: Fim do laço

Daqui para frente o aluno irá se deparar com algoritmos, que são as
sequências 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:

1
- 1
 
x= 
2
→  1 

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=2
soma=0
j=i+1=3
soma=soma+a23*x3=0+1*2=2
j=4 (=n, portanto último passo)
soma=soma+a24*x4=2+(-2)*1=0
x2=(b2-soma)/a22=((-1)-0)/1=-1
i=1 (=n, portanto último passo)
soma=0
j=i+1=2
soma=soma+a12*x2=0+4*(-1)=-4
j=3
soma=soma+a13*x3=(-4)+(-5)*2=-14
j=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”).
 19

Normalmente os softwares para criar softwares tem uma função debug, em

que apresenta uma tabela mostrando a variação dos valores das variáveis numa
execução passo-a-passo.

“PSEUDOCÓDIGO”

Se o algoritmo for apresentado genericamente, como o exemplo anterior, ou

seja, com comandos “para”, “fim”, etc., em português, e não nos comandos exatos
de uma linguagem de programação específica, é chamado PSEUDOCÓDIGO. O
que ocorre é que cada linguagem usa determinado nome para cada comando,
sendo que o mesmo algoritmo tem que ser escrito com os comandos da linguagem
de programação que será implementada. Por exemplo, uma iteração do tipo “para
i=1 até n” é criada como “do i=1 to n” em linguagem FORTRAN e “for (i=1; i<n; i++)”
em Javascript.
Uma forma equivalente e, algumas vezes, complementar ao pseudocódigo,
utilizada para se representar um algoritmo é o diagrama de fluxos (fluxograma). O
Fluxograma utiliza figuras geométricas para representar um algoritmo. Algumas das
formas básicas são:

Início ou fim do algortimo condicional procedimentos, contas etc.

ou
Leitura de dados saída de dados (impressão ou em tela)

Segue um exemplo simples de algoritmo criado com fluxograma:

 20

*************************************************************************************************

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

Obs: para garantir a exatidão das respostas dos

exercícios feitos no papel, é importante manter boa
precisão, ou seja, levar, internamente nos cálculos,
todas as casas decimais fornecidas pela calculadora.
Nas calculadoras mais avançadas tipo HP48G, as várias
linhas de memória da tela permitem levar facilmente toda
a precisão. Já nas calculadoras científicas mais simples,
é necessário ir gravando os valores na memória para
uso posterior. No caso da calculadora CASIO ao lado,
seja um exemplo que o número 18,98753 está no visor.
Para salvá-lo na variável “A”, clique na tecla SHIFT RCL
(que resulta em STO, que é do inglês storage –
armazenar). Clique na tecla (-) que resulta na variável
“A”, que está escrita acima da tecla. Para recuperar o
valor salvo em “A”, tecle em ALPHA e depois em (-).
Você pode fazer o mesmo processo para as outras
variáveis disponíveis, de A a F e X, Y e M.

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.
 21

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>
<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>
 22

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>';
}
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.
(...)

}
 23

O exemplo cujo passo-a-passo do algoritmo foi mostrado anteriormente está a

seguir, no formato que deve ficar o programa:

3.4 (EXTRA)) Duplique o programa anterior e o altere para resolver um sistema

linear triangular qualquer inferior de ordem n.

Um exemplo adaptado a partir do anterior, invertendo as equações, fica:

2x1=2 1 
-5x1+4x2=3 2
 
-2x1+x2+x3=-1 x= 
x1-5x2+4x3+3x4=-10 → - 1
 1 

*************************************************************************************************
 24

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), obviamente, 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 elemento – da esquerda para
a direita - não-nulo de cada linha; por isso se diz estar fazendo um
PIVOTEAMENTO).
 25

Então, em resumo, se quer forçar, a princípio, o elemento da primeira coluna

(coluna 1) de todas as linhas “i” (a partir da segunda) a dar zero, por meio de uma
combinação linear tirando dela um múltiplo da primeira linha. Portanto, conforme
Cantão (????), cria-se uma equação para achar esse múltiplo da seguinte maneira:

a’i1 = ai1 – mi1*a11 = 0 → (i = 2 até n; linhas)

Repete-se o processo para zerar os elementos inferiores da segunda coluna e

assim por diante. Então, zerando os elementos da coluna k, para cada linha (i > k),
que tem o pivô, o multiplicador “m” e o cálculo dos elementos assumem a forma
genérica:

i = k + 1 até n //para cada linha depois da anterior, que tem o pivô

a
mIK = IK (atenção: os coeficientes “a” são os modificados da etapa anterior)
aKK
K −1
bI = bI − mIK bK (obs: bI significa o bi da etapa k)
K K

j = k até n //para cada coluna, a partir da k

K −1
aIJ = aIJ − mIK aKJ
K

O processo é conhecido também como ESCALONAMENTO.

Quadros e Bortoli (2009) apresentam o seguinte exemplo:

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
 26

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

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

 27

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:

b4 − 18
→ x4 = = =2
a44 − 9
Para n = 4; i = 3:

4
b3 −  a3 j * x j
j =4 − 35 − (−7,5 * 2)
→ x3 = = =4
a33 −5
Para n = 4; i = 2:

4
b2 −  a2 j * x j
j =3 2 − (2 * 4 + ((−5) * 2))
→ x2 = = = −1
a22 −4

Para n = 4; i = 1:

4
b1 −  a1 j * x j
j =2 13 − ((2 * (−1)) + (1* 4) + (4 * 2))
→ x1 = = =3
a11 1

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, a princípio, por este método.

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
PARCIAL. 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;
 28

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:

9 0 − 3 3 
2 − 4 7 3
 
4 − 8 5 − 4

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
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

9 0 −3 3 
0 − 4 7,666 2,334 
 
0 − 8 6,332 − 5,332

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:
 29

9 0 −3 3 
0 − 8 6,332 − 5,332
 
0 − 4 7,666 2,334 

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

9 0 −3 3 
0 − 8 6,332 − 5,332
 
0 0 4,5 5 

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 parcial:
Dado n, Anxn e bnx1

1: Para k=1 até k=n-1 faça //para cada coluna (a última de “a” e a coluna “b” não entram)
//Encontrar o pivô (o maior em módulo)
2: w=|a(k,k)| //w é o pivô
3: r=k //r é o nº da linha que está o pivô
4: Para j=k+1 até j=n faça //para cada linha menos as anteriores a “k”, já escalonadas
5: Se |a(j,k)|>w então
6: w=|a(j,k)|
7: r=j
8: Fim do condicional referente à linha 5
9: Fim do laço referente à linha 4
10: Se w=0 então
11: ‘Todos os pivôs são nulos.’ PARE.
12: Senão
//Fim encontrar o pivô (o maior em módulo)
//Trocar a linha k com a linha r
13: Para c=1 até c=n faça //coluna 1 a n
14: atemp=a(k,c) //atemp é uma variável temporária
15: a(k,c) = a(r,c)
16: a(r,c) = atemp
17: Fim do laço referente à linha 13
18: btemp = b(k) //btemp é uma variável temporária
19: b(k) = b(r)
20: b(r) = btemp
21: Fim do condicional referente à linha 10
//Fim Trocar a linha k com a linha r
//Fazer o escalonamento
22: Para i=k+1 até i=n faça //para cada linha depois da que tem o pivô
23: m(i,k)=a(i,k)/a(k,k)
 30

24: b(i)= b(i) - m(i,k)* b(k)

25: a(i,k)=0 //vai dar zero, mas é bom colocar para evitar erro de precisão
26: Para j=k+1 até j=n faça //para cada coluna depois da que tem o pivô
27: a(i,j)= a(i,j) - m(i,k)* a(k,j)
28: Fim do laço referente à linha 26
29: Fim do laço referente à linha 22
30: Fim do laço referente à linha 1
//Fim fazer o escalonamento (“a” já está escalonado, ou seja, já é triangular superior)
31: Execute o algoritmo de solução de sistemas triangulares superiores com a,b,n.

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.php?

*************************************************************************************************
 31

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. Fazer até obter a matriz escalonada (não precisa
resolver o sistema).

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 sobre a
linguagem Javascript, 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;

Condicional com “SENÃO”:

if (a==0) {
//código
} else {
//código
}

*************************************************************************************************
 32

MÉTODO DA FATORAÇÃO LU

Voltemos ao exemplo do equacionamento do circuito elétrico apresentado no

item 3.1,sendo que podemos chamar o sistema de R*I=V.

De acordo com o problema, o sistema é formado pela matriz (R) com as

resistências e pelo vetor das fontes (V), formando o sistema linear R*I=V. Assim,
para as mesmas resistências (mesma matriz R), podem ser consideradas outras de
opções de fontes (vetor V). Neste caso, pelo escalonamento de Gauss estudado,
devem-se resolver vários sistemas lineares, escalonando-o a cada resolução.
Computacionalmente, isto pode ser tornar bastante demorado, especialmente se o
circuito for grande. Então, será a seguir estudado um método que permite escalonar
apenas a matriz (R) do circuito (uma única vez) e, para cada vetor de resistências
(R), resolver 2 sistemas lineares triangulares (sem qualquer escalonamento).
Sendo assim, 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 (Na nomenclatura Ax=b).
Então se pode escalonar a matriz dos coeficientes e salvá-la na memória,
resolvendo um sistema equivalente para qualquer vetor de termos independentes b i.
No processo de Gauss, toda vez que se muda o vetor b i, deve-se fazer novamente
todo o escalonamento.
De acordo com Ruggiero (1996), neste método, para resolver o sistema linear
Ax=b, se pudermos realizar a fatoração A=L*U, o sistema fica (L*U)x=b. Se
chamarmos Ux=y, então resolver o sistema Ax=b é equivalente a resolver Ly=b e,
depois, Ux=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.
Primeiro vamos teorizar o método, usando um sistema linear literal, conforme
Ruggiero (1996):

→
 33

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

(exatamente da mesma maneira que feito no Método de Gauss):

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 (exatamente da mesma maneira que feito

no Método de Gauss):

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:

= A(2)
 34

Em resumo:
A(1) = M (0)A(0)
A(2) = M (1)A(1) = M(1)M(0)A(0)

Então:
(0)
A = (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:

Então, resolver o sistema Ax=b é equivalente a resolver Ly=b e, depois, Ux=y.

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 com pivoteamento normal (não parcial):

1ª Etapa:

m21 = a21/a11 = 1/3

m31 = a31/a11 = 4/3

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
 35

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

A escalonada = U =

Montando a partir dos multiplicadores calculados → 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. Ruggiero (1996) diz que o impacto do
pivoteamento parcial é somente fazer a mesma troca de linhas feita na matriz A, no
escalonamento, no vetor b quando da resolução do sistema Ly=b. E esta troca de
linhas também deve ser realizada na matriz L, mas somente em sua parte inferior,
sendo que a diagonal se mantém unitária e a parte superior se mantém zerada. Na
prática, o que se faz é, durante o escalonamento, criar um vetor P com a ordem das
linhas e, a cada troca, trocar a ordem deste vetor. Ao final do escalonamento, ter-se-
á a troca que deve ser feita no vetor b.
 36

RESUMO DO PROCESSO LU COM PIVOTEAMENTO PARCIAL (resolver o sistema

linear Ax=b):

- escalonar, via Gauss com pivoteamento parcial, A até chegar a U. Portanto, U é a

matriz A escalonada (triangular superior)
- a cada etapa (“k”) do pivoteamento parcial, faz-se uma troca de linhas,
armazenando as trocas num vetor P, que é alterado a cada etapa
- portanto, ao final do escalonamento, além de U, obtém-se L (matriz triangular
inferior com os coeficientes multiplicadores m, já com as trocas de linha na parte
inferior) e P com a troca final de linhas
- Ly=Pb → obtém-se y (sistema linear triangular inferior). Obs: Pb quer dizer b com a
troca de linhas conforme P (não é multiplicar P por b, ATENÇÃO).
- Ux=y → obtém-se x (que é o objetivo; sistema linear triangular superior)

Ruggiero (1996) apresenta um exemplo:

→ P = (1,2,3) (ordem inicial)

Fazendo o pivoteamento (1ª etapa), o maior pivô está na linha 3 e, portanto,

devemos trocá-la com a 1ª linha:

e P=(3,2,1) (troca com relação a P anterior)

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:
 37

e P=(3,1,2) (troca com relação a P anterior)

Efetuando a eliminação na matriz A’(1):

E, portanto:

P=(3,1,2)

Pb é o mesmo que trocar as linhas de b segundo P (não é multiplicar P por b,

ATENÇÃO). Sendo assim, conforme P, a primeira linha de Pb será a linha 3 de b, a
segunda linha será a linha 1 e a terceira linha será a linha 2:

bT = (9, 3, -2) → (Pb) T = (-2,9,3)

O algoritmo para a resolução por fatoração LU está descrito a seguir. Estão

numeradas apenas as linhas acrescentadas ou que mudam em relação ao algoritmo
apresentado para resolução via Gauss com pivoteamento parcial.
 38

Dado n, Anxn e bnx1

//criação do vetor p inicial (com a ordem das linhas) – 1,2,3,...,n

1: Para i=1 até i=n faça
2: p(i)=i
3: Fim do laço
//fim da criação do vetor p inicial (com a ordem das linhas) – 1,2,3,...,n
//escalonamento da matriz A
Para k=1 até k=n-1 faça //para cada coluna (a última de “a” não entra)
//Encontrar o pivô (o maior em módulo)
w=|a(k,k)| //w é o pivô
r=k //r é o nº da linha que está o pivô
Para j=k+1 até j=n faça //para cada linha menos as anteriores a “k”, já escalonadas
Se |a(j,k)|>w então
w=|a(j,k)|
r=j
Fim do condicional
Fim do laço
Se w=0 então
‘Todos os pivôs são nulos.’ PARE.
Senão
//Fim encontrar o pivô (o maior em módulo)
//Trocar a linha k com a linha r
Para c=1 até c=n faça //coluna 1 a n
atemp=a(k,c) //atemp é uma variável temporária
a(k,c) = a(r,c)
a(r,c) = atemp
Fim do laço
//trocar as linhas do vetor p (não do b, como é no Gauss)
4: ptemp = p(k) //ptemp é uma variável temporária
5: p(k) = p(r)
6: p(r) = ptemp
Fim do condicional
//trocar as linhas do vetor p
//Fim Trocar a linha k com a linha r
//Fazer o escalonamento
Para i=k+1 até i=n faça //para cada linha depois da que tem o pivô
m(i,k)=a(i,k)/a(k,k)
7: //tirada esta linha com escalonamento de b
8: a(i,k)= m(i,k) //armazenando os multiplicadores na própria matriz A escalonada, no lugar de 0
Para j=k+1 até j=n faça //para cada coluna depois da que tem o pivô
a(i,j)= a(i,j) - m(i,k)* a(k,j)
Fim do laço
Fim do laço
Fim do laço
//fim escalonamento da matriz A (sendo sua parte inferior, a matriz L e sua parte superior a matriz U
9: //aqui não mais executa diretamente a resolução de um sistema triangular superior
//troca das linhas de b, conforme o vetor p que tem as trocas de linhas feitas em A. Estou chamando
“Pb” de “c”
10: Para i=1 até i=n faça
11: r=p(i)
12: c(i)=b(r)
 39

13: Fim do laço

//fim troca das linhas de b, conforme o vetor p que tem as trocas de linhas feitas em A
//resolver o sistema triangular inferior Ly=c – como L está em A, mas não tem a diagonal =1, só
alteramos o algoritmo de sistema triangular inferior tirando a divisão por a(i,i) na última linha (linha 20
a seguir), porque divisão por 1 não é necessária. Alteram-se também as variáveis
14: y(1) = c(1) //não divide por a(1,1), que é 1
15: Para i=2 até i=n faça //a partir da segunda linha, até a última
16: soma=0
17: Para j=1 até j=i-1 faça
18: soma=soma + a(i,j)*y(j)
19: Fim do laço
20: y(i) = (c(i)-soma) //aqui tirou a divisão por a(i,i), que é 1
21: Fim do laço
//fim resolver o sistema triangular inferior Ly=c
//resolver Ux=y (sistema triangular superior)
22: Execute o algoritmo de solução de sistemas triangulares superiores com a,y,n.
// veja que pode ser usada a mesma função que resolve sistema triangular superior, só que entra com
a,y,n e não a,b,n. “A” já é “U” na parte superior e o algoritmo só considera mesmo a parte superior

*************************************************************************************************

Para estudar mais aprofundadamente o Método de LU, acesse:

http://vtp.ifsp.edu.br/nev/Sistema-lu/sistemalu.php?

*************************************************************************************************
 40

EXERCÍCIOS:

3.8) 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.9) Resolver, em papel, o sistema do exercício anterior pela fatoração LU com

pivoteamento parcial.

3.10) Resolver, em papel, o exercício anterior usando o algoritmo apresentado,

apresentando o passo a passo.

3.11) Usando como base os programas anteriormente criados, crie um software para
resolver sistemas pelo algoritmo de fatoração LU com pivoteamento parcial, que
acabou de ser apresentado. O software deve mostrar as matrizes completas L|c
(sendo que L é a parte inferior de A, exceto a diagonal com elementos iguais a 1) e
U|y (sendo que U é a parte superior de A, inclusive com a diagonal; a parte inferior é
zerada) conforme o exemplo a seguir:
 41

*************************************************************************************************

3.2.2 MÉTODOS ITERATIVOS PARA A SOLUÇÃO DE SISTEMAS LINEARES

No caso de sistemas lineares maiores e esparsos (com grande quantidade 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
parada seja satisfeito. Eles não serão aqui estudados, mas seguem links para o
aluno que quiser se aprofundar no assunto.

MÉTODO DE GAUSS-JACOBI (OU MÉTODO DE JACOBI OU MÉTODO DOS

DESLOCAMENTOS SIMULTÂNEOS)
https://vtp.ifsp.edu.br/nev/Sistema-jacobi/sistemajacobi.html?

MÉTODO DE GAUSS-SEIDEL (OU MÉTODO DOS DESLOCAMENTOS

SUCESSIVOS)
https://vtp.ifsp.edu.br/nev/Sistema-seidel/sistemaseidel.html?
 42

4 OPERAÇÕES COM MATRIZES

4.1 DETERMINANTE DE MATRIZ

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:

Sendo assim, o determinante de uma matriz qualquer pode ser calculado

usando o escalonamento. A partir do escalonamento de uma matriz A via MÉTODO
DA ELIMINAÇÃO DE GAUSS da forma como foi estudado, determina-se uma matriz
escalonada A’ triangular superior equivalente. Para efeito do determinante,
multiplicar uma linha por um múltiplo de outra linha não causa alteração. Porém,
trocar uma linha por outra inverte o sinal do determinante. Sendo assim,
considerando que, na operação de escalonamento com pivoteamento parcial,
trocam-se linhas “t” vezes:

det [A] = (-1)t * (multiplicação dos elementos diagonais de A’)

Por exemplo, deseja-se calcular o determinante da seguinte matriz:

A=

ESCALONAMENTO COM PIVOTEAMENTO PARCIAL

Como o pivô é 4, troca-se a linha 1 com a linha 3:

 43

Realizando o escalonamento, chega-se a:

Como o pivô é 0,25, não há troca de linhas. Realizando o escalonamento,

chega-se a:

Ao final do escalonamento, houve 1 troca de linhas (t=1). Sendo assim:

det [A] = (-1)t vezes (multiplicação dos elementos diagonais de A’)

= (-1)1*(4*0,25*4) = -4

*************************************************************************************************

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.
 44

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: }

OBS: lembre-se de contar as trocas de linha e multiplicar o determinante por (-1) t

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:

*************************************************************************************************

4.2 MULTIPLICAÇÃO DE MATRIZES

Um exemplo para relembrar como se multiplicam matrizes:

 45

Considere as matrizes a seguir e a multiplicação:

A = [a]mxn
B = [b]nxp
A*B = [c]mxp

Um algoritmo para multiplicar matrizes é:

1: Para i=1 até m faça //para cada linha da matriz final (m é o nº de linhas da matriz A)
2: Para J=1 até p faça //para cada coluna da matriz final (p é o nº de colunas da matriz B)
3: c(i,J) = 0
4: Para k=1 até n faça // (n é o nº de linhas da matriz B)
5: c(i,J) = c(i,J)+a(i,k)*b(k,J)
6: Fim do laço
7: Fim do laço
8: Fim do laço

Lembre-se que A*B  B*A.

4.3 MATRIZ TRANSPOSTA

Considere uma matriz A = a[i,J]mxn. Sua transposta será B = b[J,i] nxm.

Um algoritmo para calcular a transposta de uma matriz é:

1: Para i=1 até m faça //para cada linha da matriz A

2: Para J=1 até n faça //para cada coluna da matriz A
3: b(J,i) = a(i,J)
4: Fim do laço
5: Fim do laço

4.4 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 é
resolve “n” sistemas, sendo que cada solução é uma coluna da matriz inversa (“n” é
a ordem da matriz). Resumindo, temos o seguinte esquema, segundo Castilho
(2001):
 46

- matriz a inverter:

- matriz aumentada:

- sistemas a resolver:

- matriz inversa:

Na prática, existem 2 maneiras de resolver o problema:

1) escalona-se a matriz aumentada e resolvem-se n sistemas triangulares, sendo o

vetor “b” cada coluna da matriz identidade escalonada (atenção).

2) montar os sistemas sem escalonar, sendo “b” exatamente cada coluna da matriz
identidade e escalonar cada sistema antes de resolver (como mostrado no esquema
acima)

Claramente o processo 1) resolve apenas 1 escalonamento e o 2) resolve “n”

escalonamentos. Dependendo da ordem do sistema inicial, o processo 2) se torna
inviável. Sendo assim, aqui, iremos resolver pelo processo 1).
Então, 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.
Castilho dá um exemplo numérico:

→ matriz aumentada com I →

 47

após escalonamento →

Resolve-se os 3 sistemas triangulares superiores:

 4
X (1) =  3
→  
3
1 
X ( 2) =  2
 
→ 1

− 6
X ( 3)
= − 6
 
→  − 5

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:

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
 48

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.

*************************************************************************************************
 49

EXERCÍCIOS

4.3) Calcular, em papel, a inversa da matriz a seguir, pelo método apresentado

anteriormente (método 1 com pivoteamento parcial – ATENÇÃO).

4.4) 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:

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

*************************************************************************************************
 50

5 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 f x =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. Para polinômios de graus superiores, podem-
se usar 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.

5.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).
 51

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)=x 3-20:

1) Escolhemos a0 = 2 porque f(a 0) < 0 (23-20=-12<0) e b0 = 3 porque f(b 0) > 0 (33-

20=7>0). Este é o chamado TEOREMA DE BOLZANO (sempre deve acontecer
f(a)*f(b)<0, senão não cruza o eixo e não há raiz no intervalo – ou há mais de uma
raiz, cruza mais de uma vez o eixo horizontal).

2) Escolhemos o ponto médio do intervalo, ao qual chamaremos provisoriamente de

c0:

→ c0=2,5

3) Calculamos f(c0) = 2,53-20=-4,375<0.

4) Para descobrir se a raiz está à esquerda ou à direita de c 0:

- se a função for crescente com f(a0) < 0 e f(c0) < 0 → raiz à DIREITA de c0
- se a função for crescente com f(a0) < 0 e f(c0) > 0 → raiz à ESQUERDA de c 0
- se a função for decrescente com f(a0) > 0) e f(c0) < 0 → raiz à ESQUERDA de c 0
- se a função for decrescente com f(a0) > 0) e f(c0) > 0 → raiz à DIREITA de c0

Portanto, independentemente da função ser crescente ou decrescente, faça:

- se f(a0)*f(c 0) < 0 → a raiz está à esquerda de c 0
- se f(a0)*f(c 0) > 0 → a raiz está à direita de c 0

No caso do exemplo, f(a0)*f(c0)=(-12)*(-4,375) > 0, portanto a raiz está à

direita de c0. Assim, definimos um novo intervalo [a1,b1]= [c0,b0]= [2,5;3]. Portanto, a
cada iteração “k”, deve-se verificar se a raiz está à esquerda ou à direita de ck.

5) Repete-se o procedimento até que o erro seja satisfatório. O erro real (ou seja,

intervalo de confiança de x) en é dado por (an e bn do intervalo inicial da

iteração, obviamente), assumindo que a solução está no ponto médio do intervalo.
Outra forma de verificar a convergência é calcular f(c0), que deve ir se aproximando
de zero a cada iteração.

Abaixo está a tabela até a décima iteração, contendo a solução cn  en.

 52

Portanto, a raiz da função f(x)=x3-20 está no intervalo 2,714417 

0,0000610352.
Segundo Quadros e Bortoli (2009), este método possui baixa velocidade de
convergência, mas a convergência é garantida.
Não iremos explorar o algoritmo deste método ou realizar exercícios, visto ser
mais interessante aprofundar o Método da Posição Falsa, uma derivação deste, com
melhor velocidade de convergência.

5.2 MÉTODO DA POSIÇÃO FALSA

Como comentado, este método é semelhante ao Método da Bissecção, só

que mais elaborado. Ao invés de tomar a média aritmética entre “a” e “b”, o método
da posição falsa toma a média aritmética ponderada entre “a” e “b” com pesos |f(b)|
e |f(a)|, respectivamente. Então, considerando que f(a) e f(b) têm sinais opostos:

Conforme Ruggiero (1996), graficamente, a solução x de cada iteração é

dada por uma reta que passa pelos pontos (a,f(a)) e (b,f(b)) onde ela corta o eixo x:

Fonte: Ruggiero (1996).

 53

A sequência de operações, chamando x0=a, x1=b e x2=c neste caso, é:

1) Escolhemos x0 e x1 tais que f(x0)*f(x1)<0 (idêntico ao Método da Bissecção)

2) Aproximamos x 2 a partir da expressão:

3) Se o critério de convergência não é satisfeito (aqui sendo f(x2) se aproximando de

zero), segue-se.

4) Se f(x0)*f(x2)<0, mantém-se x0 e substitui-se x1 por x2 e retorne-se ao passo 2. Se

f(x0)*f(x2)>0, mantém-se x1 e substitui-se x0 por x2 e retorne-se ao passo 2.
(exatamente a mesma coisa que feito para o método da Dicotomia).
Quadros e Bortoli (2009) apresentam um exemplo para a função p(x)=x3-
5x2+17x+21:

ITERAÇÃO 0)

1) Escolhemos x0=-1 e x1=0 tais que f(x 0)* f(x1)<0 (-2*21<0)

2) Aproximamos x 2 a partir da expressão:

x1 * f ( x0 ) − x0 * f ( x1 ) 0 * f (−1) − (−1) * f (0) 0 * (−2) − (−1) * 21 21

x2 = = = = = −0,91304
f ( x0 ) − f ( x1 ) f (−1) − f (0) (−2) − 21 − 23

3) f(x2) = f(-0,91304) = (-0,91304)3-5*(-0,91304)2+17*(-0,91304)+21=0,549. Veja que

está bem longe de zero. Então parte para uma próxima iteração. Na tabela a seguir,
encontram-se mais iterações até que haja uma convergência satisfatória:

Obs: para cada iteração, manter a nomenclatura x0, x1 e x2.

Portanto, uma das raízes da função (a que ocorre no intervalo -1 a 0) é igual a

-0,932115.

Um algoritmo possível é, 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”.
 54

Dado f(x), a, b, ea, itm

1: xa[0]=a;
2: xb[0]=b;
3: se ((f(xa[0])*f(xb[0]))>0) { //escolher outro intervalo
4: “Erro. Escolher outro intervalo com f(a)*f(b)<0”
5: }
6: k=0; //número da iteração
7: xm[k]=(xb[k]*f(xa[k])-xa[k]*f(xb[k]))/(f(xa[k])-f(xb[k])); //solução da iteração 0
8: se ((f(xa[k])*f(xm[k]))<=0) { //raiz da próxima iteração está à esquerda de xm
9: xa[k+1]=xa[k];
10: xb[k+1]=xm[k];
11: } senão { //raiz da próxima iteração está à direita de xm
12: xa[k+1]=xm[k];
13: xb[k+1]=xb[k];
14: } fim do condicional
15: En[k]=módulo(f(xm[k])); //erro relativo da iteração 0
16: enquanto (En[k]>ea) { //a partir da iteração 1
17: k=k+1;
18: se (k=itm) {
19: break; //sai do laço enquanto
20: } fim do condicional
21: xm[k]=(xb[k]*f(xa[k])-xa[k]*f(xb[k]))/(f(xa[k])-f(xb[k])); //solução da iteração k
22: se ((f(xa[k])* f(xm[k]))<=0) { //raiz da próxima iteração está à esquerda de xm
23: xa[k+1]=xa[k];
24: xb[k+1]=xm[k];
25: } senão { //raiz da próxima iteração está à direita de xm
26: xa[k+1]=xm[k];
27: xb[k+1]=xb[k];
28: } fim do condicional
29: En[k]=módulo(f(xm[k])); //erro relativo da iteração k
30: } fim do loop equanto

O professor irá enviar aos grupos, via e-mail, um programa para calcular a
raiz de uma função qualquer pelo Método da POSIÇÃO FALSA, 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 html e js, além de testar e
entender o funcionamento do programa.
Segue um exemplo de resultado:
 55

*************************************************************************************************

EXERCÍCIO

5.1) Calcular, em papel, a raiz da função no intervalo ,

usando o Método da Posição Falsa. Faça iterações até que a convergência seja
menor que 0,001.

5.2) Calcular o exercício anterior usando o algoritmo passo-a-passo. Considere o

número máximo de iterações igual a 10.

5.3) Exemplo Ávila (2019): Pretende-se calcular a corrente que circulará no circuito
eletrônico ilustrado. Saindo da idealidade, sabe-se que a operação do diodo varia
com a sua temperatura. Um possível modelo que relaciona a tensão (Vd), a
corrente (Id) e a temperatura de operação (T) no diodo pode ser a dada pela
equação apresentada ao lado do circuito.
 56

onde ICR é a corrente de condução reversa, n é o coeficiente de emissão,

k é a constante de Boltzmann e q é a carga do elétron.
Entendendo que a corrente no diodo é a corrente no circuito, por
análise de malha, tem-se:

A partir daqui, por mais que se tente manipular, não se consegue

resolver a equação de forma explícita para Id. O termo log (𝐼𝑑⁄𝐼𝐶𝑅 + 1)
não permite. Assim sendo, uma resolução direta fica inviável.
Uma maneira alternativa é subtrair dos dois lados da igualdade o
termo a sua esquerda, adquirindo uma nova função:

Agora, a resposta para o problema é encontrar um valor para Id que

torna a função igual a zero, portanto, a sua raiz.
Considere V = 24 V, R = 10 Ω e um diodo 1N4001 com ICR = 31,9824*10-9 A,
 = 2, k = 1,3806*10-23 J/K, T = 300K e q = 1,6022*10-19 C.

Os valores iniciais de x1 e x2 são adotados tendo por base a

experiência prévia sobre o problema, no caso a resolução analítica
próximo à idealidade. Ávila (2019) sugere usar x1,x2 = [2,0000 2,5000] A.
Considerando o exposto, faça a tabela de iterações, resolvida pelo MÉTODO
DA BISSECÇÃO, confirmando a corrente Id = 2,36 A (valor final de X).

*************************************************************************************************
 57

5.3 MÉTODO DE NEWTON-RAPSON (OU DAS TANGENTES)

A inspiração do método é vista na figura a seguir, onde olhamos para a reta

tangente ao gráfico de f no ponto (x k,f(xk)) e definimos xk+1 como sendo o ponto de
encontro dessa reta com o eixo x. Assim, sempre se terá uma aproximação mais
perto da solução x*.

Figura: Visualização geométrica do Método de Newton-Rapson.

Fonte: Asano e Colli (2009).

Deduzindo a expressão, a partir da figura anterior:

f ( xk )
f ' ( xk ) = (a derivada é o coeficiente angular da reta tangente)
( xk − xk +1 )
f ' ( xk ) * ( xk − xk +1 ) = f ( xk ) → f ' ( xk ) * xk − f ' ( xk ) * xk +1 = f ( xk ) →
f ' ( xk ) * xk − f ( xk ) f ( xk )
xk +1 = → xk +1 = xk −
f ' ( xk ) f ' ( xk )

Segundo Quadros e Bortoli (2009), este método pode ser mais eficiente por
causa da velocidade de convergência e da precisão. Porém, enquanto os métodos
anteriormente apresentados só necessitam da resolução da função em si, este
método necessita da resolução de sua derivada.
Agora não é mais necessário definir um intervalo inicial, mas somente um
valor de x inicial. Portanto, obviamente, não há verificação inicial.
Asano e Colli (2009) apresentam o mesmo exemplo mostrado em capítulo
anterior resolvido pelo Método da Posição Falsa, para encontrar uma raiz da função
f(x) = x3-20:

Chuta-se x 0 = 3:
 58

Observe, pela tabela anterior, que a convergência (f(xn) se aproximando de 0)

foi rápida, encontrando-se a solução (x = 2,7144) em apenas 3 iterações, sendo que,
pelo Método da Posição Falsa, precisou-se de 4 iterações (considerando a mesma
convergência alvo = 0,001). Porém, há que se atentar, conforme Ruggiero (1996),
que este método depende de uma aproximação inicial “suficientemente” próxima da
raiz. Se isto não ocorrer, ele pode não ser mais eficiente que os outros métodos
aproximados.

*************************************************************************************************

Quadros e Bortoli (2009) citam que os algoritmos de resolução de zeros de

funções devem prever a possibilidade de ocorrência de divisão por zero ou por um
valor muito pequeno, o que pode baixar muito a velocidade de convergência. Citam
ainda os autores que pode haver comportamento oscilante nas iterações quando a
função não apresenta raízes reais, quando a estimativa inicial não for adequada ou
quando a função for simétrica em relação ao eixo x (f’’(x*)=0). x* é a raiz da função.
Quadros e Bortoli (2009) apresentam em seu trabalho mais alguns métodos
para encontrar zeros de funções, que podem ser usados em estudos mais
aprofundados, entre eles o Método das Secantes.

*************************************************************************************************

EXERCÍCIOS

5.4) Calcular, em papel, a raiz da função usando o Método de

Newton-Rapson (a mesma função do exercício 5.1). Usar x 0=1. Faça iterações até
que a convergência seja menor que 0,001.

5.5) Crie um algoritmo que resolva a raiz de uma função pelo Método de Newton-
Rapson.

5.6) Duplique o programa do Método da Posição Falsa e adapte-o para que resolva
a raiz de uma função pelo Método de Newton-Rapson. Segue uma sugestão de
aparência:
59
 60

6 FUNÇÕES DE INTERPOLAÇÃO DE DADOS

Freqüentemente nos deparamos com um conjunto discreto de valores que

podem ser dados na forma de tabela ou de um conjunto de medidas. Por exemplo,
conforme Ávila (2019), a Tabela 40 da NBR 5410:2004 apresenta os fatores de
correção por temperaturas ambiente para linhas não-subterrâneas considerando
dois tipos de compostos isolantes. Parte desta tabela é:

Figura: Trecho da Tabela 40 da NBR 5410:2004, que apresenta os fatores de

correção por temperaturas ambiente para linhas não-subterrâneas considerando
dois tipos de compostos isolantes. Fonte: Ávila (2019).

Veja, na tabela anterior, que, se quisermos os fatores de correção para 30º ,

ele fica entre 25 ºC e 35 ºC. Neste caso, temos que fazer uma interpolação. Fazer a
conta da interpolação para um único valor é fácil. Porém, nos casos práticos, temos
muitos valores a interpolar, o que acaba necessitando interpolar todos os pontos e
encontrar uma função contínua que satisfaça todos os pontos. É a chamada função
interpoladora.

Figura: Polinômio interpolador para alguns dados discretos. Fonte:

http://www.math.ist.utl.pt/~calves/cursos/Interpola.HTM. Acesso em 04/11/2014.

A função interpoladora pode ser polinomial, exponencial, entre outras.

Observe que a função interpoladora somente deve ser usada dentro do domínio de
pontos conhecidos (x 0 a x3 no caso da figura anterior). O domínio fora dos pontos
conhecidos deve ser tratado como uma extrapolação, que será estudada em
capítulo posterior.

6.1 INTERPOLAÇÃO POLINOMIAL

Considere que se deseja interpolar n+1 pontos (x,f(x)) por um polinômio p(x)
de grau igual a n (para passar por todos os pontos). Sendo assim:
 61

O sistema apresentado tem n+1 equações e incógnitas (a 0 até an). Para

resolver o sistema, é necessário que a matriz dos coeficientes (a seguir) tenha seu
determinante diferente de zero para que a solução seja única e determinada.
Matricialmente, o sistema apresentado fica:

Computacionalmente, pode-se resolver o sistema por algum dos métodos

explicados em capítulo anterior.
Quadros e Bortoli (2009) apresentam um exemplo, em que se pede para
encontrar um polinômio de grau 2 para interpolar os seguintes pontos:

Adotando , tem-se:

p2(x0) = f(x0) → a0+a1*(-2)+a2*(-2)2=3 → a0-2*a1+4*a2=3

p2(x1) = f(x1) → a0+a1*(1)+a2*(1)2=0 → a0+a1+a2=0
p2(x2) = f(x2) → a0+a1*(3)+a2*(3)2=-3 → a0+3*a1+9*a2=-3

Matricialmente:

1 − 2 4 a0   3 
1 1 1 *  a  =  0 
   1  
1 3 9 a2  − 3

Resolvendo o sistema linear, chega-se ao polinômio:

a0 = 1,2; a1 = -1,1; a2 = -0,1 → p2(x) = 1,2 – 1,1*x – 0,1*x2

Um algoritmo para montar a matriz dos coeficientes é:

1: para i=1 até n+1 { //linhas

2: para j=1 até n+1 { //colunas
 62

( j −1)
3: a(i,j)= x( i −1) ;
4: } fim do para j
5: } fim do para i

Obs: o Javascript considera 00 = 1.

*************************************************************************************************

EXERCÍCIOS

6.1) Calcular, em papel, o polinômio interpolador para os dados a seguir.

6.2) Montar, em papel, a matriz “A” do exercício anterior usando o algoritmo

apresentado, passo a passo.

Obs: o Javascript considera 00 = 1.

6.3) O professor irá enviar aos grupos, via e-mail, um programa para calcular
funções interpoladoras polinomiais para quaisquer conjuntos de dados de entrada,
com a resolução do sistema via Gauss com pivoteamento parcial.
O aluno deve estudar somente os arquivos polinter.html e funcoes-polinter.js,
além de testar e entender o funcionamento do programa.
O resultado deve ficar como o do exemplo a seguir.

p(x)

*************************************************************************************************

Para estudar mais aprofundadamente a interpolação polinomial, acesse:

http://vtp.ifsp.edu.br/nev/Inter-poli/polinomiointer.php?.
 63

6.2 INTERPOLAÇÃO USANDO POLINÔMIOS DE LAGRANGE

O uso de Polinômios de Lagrange é uma alternativa ao uso de funções

polinomiais simples, que pode resultar em melhor precisão, especialmente para
poucos pontos a interpolar. Como os resultados, na maioria das vezes, são
semelhantes ao método estudado no item anterior, não estudaremos aqui este
método, mas o aluno que tiver interesse pode acessar http://vtp.ifsp.edu.br/nev/Inter-
lag/polinterlag.php?.

6.3 INTERPOLAÇÃO USANDO A FORMA DE NEWTON

Da mesma maneira que ocorreu com o item anterior, a Forma de Newton é

outra alternativa em que os resultados, na maioria das vezes, são semelhantes à
interpolação polinomial simples. Assim, não estudaremos aqui este método, mas o
aluno que tiver interesse pode acessar http://vtp.ifsp.edu.br/nev/Inter-f-
newton/polinternew.php?.

*************************************************************************************************

Cita-se ainda que existem, na bibliografia, outros métodos de interpolação,

não explorados nesta apostila. Uma aplicação prática da interpolação polinomial é
encontrar a curva de saída de uma fonte de tensão
senoidal com frequência de 60Hz, ou seja, V x tempo, após medições. Veja um
gráfico obtido experimentalmente:

Fonte: Ávila (2019).

Porém, como os dados são experimentais e sujeitos a interferências, não

necessariamente precisa-se de um polinômio interpolador, mas sim de uma curva
que mais se aproxime dos dados, não necessariamente englobando-os exatamente.
Essa curva será vista no capítulo posterior, sobre FUNÇÕES DE APROXIMAÇÃO
DE DADOS.
 64

7 FUNÇÕES DE APROXIMAÇÃO DE DADOS

Ao contrário da interpolação, na qual todos os pontos têm que estar sobre a

função interpoladora, há casos em que se precisa aproximar os dados por meio de
uma função mais simples, mesmo que os dados não façam parte da função agora
aproximadora. Veja o exemplo da figura a seguir, onde foi usada uma função linear
para aproximar um conjunto discreto de dados. Esse campo de estudo também é
chamado AJUSTE DE DADOS.

Figura: Aproximação linear para um conjunto de dados. Fonte: O próprio autor.

As funções aproximadoras permitem extrapolar dados, ou seja, encontrar

dados que aconteceriam caso a função seguisse uma tendência. A extrapolação
tenta estimar os valores fora do domínio de pontos conhecidos. Veja, na figura
anterior, que, no domínio de 0 a 1 no eixo horizontal, existem dados discretos e a
função aproximadora fica o mais próximo possível deles. Porém, fora do domínio
indicado, não há dados e foi considerada uma tendência dos dados, sendo que a
função aproximadora é também extrapoladora. A extrapolação deve ser feita a partir
de funções aproximadoras, e não interpoladoras.
Além do uso para extrapolação do domínio, o ajuste também é indicado
quando o número de pontos é muito grande. Preferem-se, geralmente, funções de
ajuste de baixa ordem, retas, parábolas, cúbicas, exponenciais, etc., ao invés de
polinômios de ordem elevada ou funções mais complexas.

7.1 APROXIMAÇÃO POR POLINÔMIOS

7.1.1 MÉTODO DOS MÍNIMOS QUADRADOS (MMQ)

Quando se aproxima f por uma função g, acontece um erro r, isto é:

De maneira simplória, uma boa aproximação é dada quando o somatório dos

erros é nulo ( ). Porém, pode haver cancelamentos dos erros positivos
 65

com os negativos, mascarando os resultados. Para evitar isso, trabalha-se com o

quadrado do erro, ou seja, exige-se que seja mínimo, resultando na base
do que se chama MÉTODO DOS MÍNIMOS QUADRADOS.

Obs: Ao invés de minimizar o quadrado dos erros, poderiam ser minimizados os

módulos dos erros. Porém, como será visto a seguir, a minimização exige a
derivação do erro e a mesma não existe, num ponto, para a função módulo.

Podemos usar uma função de ajuste do tipo polinomial:

g ( x) = a0 + a11 ( x) + a22 ( x) + ... + amm ( x)

Na função g(x), as funções i(x) devem ser preestabelecidas, de acordo com

a aproximação que se quer chegar.
Chamando M a função dos erros mínimos quadrados, podemos escrever:

Do cálculo diferencial, sabemos que, para encontrar o ponto de mínimo de

uma função, basta a derivarmos em relação às suas variáveis e igualarmos a zero.
No caso, as variáveis são ai. Sendo assim, temos que fazer:

7.1.1.1 MMQ POR AJUSTE LINEAR

O MMQ por ajuste linear é uma das maneiras de se fazer o que se chama de
REGRESSÃO LINEAR. Vamos considerar uma função de ajuste do tipo:
g ( x) = a0 + a1 x

Obviamente, o MMQ deverá determinar os valores dos coeficientes a i. Neste

caso (n+1 é o número de pontos conhecidos, a partir dos quais se encontrará a
função de ajuste):
M = ( f (x0 ) − g (x0 )) + ( f (x1 ) − g (x1 )) + ... + ( f (xn ) − g (xn ))
2 2 2

M = ( f (x0 ) − (a0 + a1 x0 )) + ( f (x1 ) − (a0 + a1 x1 )) + ... + ( f (xn ) − (a0 + a1 xn ))

2 2 2

Lembremos do cálculo que:

y = un → y’ = n*un-1*u’

Se chamarmos u = r (erro) = f (xi ) − (a0 + a1 xi ) , a derivada de u2 será:

y = u 2 = 2 * u * u'

A derivada de u depende de qual variável se quer derivar. No caso, temos

que derivar parcialmente em a 0 e depois em a1. Assim:
 66

M
= 2 * ( f ( x0 ) − (a0 + a1 x0 ))* (−1) + 2 * ( f ( x1 ) − (a0 + a1 x1 ))* (−1) + ... + 2 * ( f ( xn ) − (a0 + a1 xn ))* (−1)
a0
− 2 f ( x0 ) + 2a0 + 2a1 x0 − 2 f ( x1 ) + 2a0 + 2a1 x1 − ... − 2 f ( xn ) + 2a0 + 2a1 xn = 0
n n
2a0 (n + 1) + 2a1  xi = 2 f ( xi )
0 0
n n
a0 (n + 1) + a1  xi =  f ( xi )
0 0
M
= 2 * ( f ( x0 ) − (a0 + a1 x0 ))* (− x0 ) + 2 * ( f ( x1 ) − (a0 + a1 x1 ))* (− x1 ) + ... + 2 * ( f ( xn ) − (a0 + a1 xn ))* (− xn )
a1
− 2 f ( x0 ) x0 + 2a0 x0 + 2a1 x0 − 2 f ( x1 ) x1 + 2a0 x1 + 2a1 x1 − ... − 2 f ( xn ) xn + 2a0 xn + 2a1 xn = 0
2 2 2

n n n
2a0  xi + 2a1  xi = 2 f ( xi )xi
2

0 0 0
n n n
a0  xi + a1  xi =  f ( xi )xi
2

0 0 0

Com isso, obtém-se um sistema de equações lineares:

n n
a0 (n + 1) + a1  xi =  f ( xi )
0 0
n n n
a0  xi + a1  xi =  f ( xi )xi
2

0 0 0

Podendo ser escrito na forma:

 n
  n 
(n + 1) x i 
 
a   f ( xi ) 
 n n
0
 0  =  n0 
 x 2   a1   f ( xi )xi 
 
0
i 0 xi  
0


Quadros e Bortoli (2009) apresentam um exemplo para se encontrar uma

função de ajuste linear por MMQ para os seguintes dados:

(n+1) = 5 pontos (n=4)

n 4

 xi =  xi = 0 + 1 + 2 + 3 + 4 = 10
0 0
n 4

 xi =  xi = 02 + 12 + 22 + 32 + 42 = 30
2 2

0 0
n 4

 f ( xi ) =  f ( xi ) = 0 + 1 + 2 + 4 + 5 = 12
0 0
n 4

 f ( xi )xi =  f ( xi ) xi = 0 * 0 + 1*1 + 2 * 2 + 3 * 4 + 4 * 5 = 37
0 0

O sistema fica:
 67

 5 10 a0  12

10 30  a  = 37
  1   

A solução é a0 = -0,2 e a1 = 1,3. Portanto, a reta que aproxima f(x) é:

g(x) = 1,3*x-0,2

7.1.1.2 MMQ POR AJUSTE POLINOMIAL

O processo usado anteriormente para cálculo da função para ajuste linear

pode ser estendido para um polinômio de grau maior. Sendo assim, uma função
polinomial de grau “p” é dada por:
g ( x) = a0 + a1 x + a2 x 2 + ... + a p x p

A função M, dos erros mínimos quadrados é dada por (lembrando que n+1 é o
número de pontos conhecidos, a partir dos quais se encontrará a função de ajuste):

Os pontos mínimos (erro mínimo) ocorrem quando:

Calculando-se as derivadas, de forma semelhante ao que foi feito para o

ajuste linear, chega-se ao seguinte sistema (p+1) x (p+1), onde p é o grau do
polinômio desejado:

 n n n
p   n 
(n + 1)  xi  xi 2
... 0 i 
x   f ( xi ) 
 n n
0 0
n n   a0   n 0 
 x
0 i   a1   0 i i 
p +1   
 x x
2 3
... x  f ( x )x
i i i
0 0 0
 n n n n   a2  =  n 
  xi 2 x i
3
x i
4
... 0 i   ...   0 f ( xi )xi 2 
x
p+2

 0 0 0  
 ... ... ... ... ...  a p   ... 
 n p n n n
2p 
  n p
  xi x x 0 xi   f ( xi )xi 
p +1 p+2
i i ...
 0 0 0 0 

Note que a matriz parte do sistema anterior é simétrica (a matriz é igual à sua
transposta).
Obs: aqui, o grau do polinômio (“p”) não depende do nº de pontos (“n+1”), sendo
uma escolha do usuário.
Quadros e Bortoli (2009) apresentam um exemplo para se encontrar uma
parábola (polinômio de grau 2) para os seguintes dados:
 68

O sistema resultante fica:

A solução do sistema implica em:

g(x) = 2,9472 + 5,01862*x – 2,5022*x2

Um possível algoritmo para montar a matriz (p+1)x(p+1), considerando (n+1)

pares lidos x e f(x) de 0 a n, é:

1: f=-1;
2: para c=1 até p+1 { //colunas – p é o grau do polinômio
3: para l=1 até p+1 { //linhas
4: e=l+f;
5: soma=0;
6: para i=0 até n { //n+1 pontos
7: soma=soma+x(i)^e;
8: } fim do para i
9: a(l,c)=soma
10: } fim do para l
11: f=f+1;
12: } fim do para c

Um possível algoritmo para montar o vetor é:

1: para l=1 até p+1 { //linhas

2: soma=0;
3: para i=0 até n { // n+1 pontos
4: soma=soma+(f(xi)*(x(i)^(l-1)));
5: } fim do para i
6: b(l)=soma
7: } fim do para l

Tendo montado o sistema, pode-se resolvê-lo por um dos métodos estudados

em capítulo anterior, como o Método de escalonamento de Gauss. Atenção que a
ordem do sistema é “p+1” (“p” é o grau do polinômio).
Para estudar mais aprofundadamente a aproximação polinomial de dados,
acesse:
http://vtp.ifsp.edu.br/nev/Aprox-poli/polaprox.php?

*************************************************************************************************
EXERCÍCIOS

7.1) Calcular, em papel, um polinômio de ajuste de grau 2 para os dados a seguir (os
mesmos do exercício 6.1).
 69

Obs: o Javascript considera 00 = 1.

7.2) Calcule o exercício anterior usando o algoritmo passo-a-passo para calcular a

matriz e o vetor do sistema.

7.3) Duplique o programa da INTERPOLAÇÃO POLINOMIAL e adapte-o para que

encontre a função aproximadora polinomial pelo MMQ, para quaisquer conjuntos de
dados de entrada e grau do polinômio.

*************************************************************************************************
 70

7.2 APROXIMAÇÃO POR FUNÇÕES ESPECIAIS

A aproximação de dados por funções especiais como as exponenciais é feita

a partir de uma linearização dos dados (tratamento para que os dados se tornem
uma reta) e depois, a partir dessa reta, aplicam-se processos de ajuste linear (como
explicado anteriormente) para encontrar a função linear e sua conseqüente função
especial.

7.2.1 APROXIMAÇÃO POR FUNÇÃO EXPONENCIAL

Imagine que você queira aproximar um conjunto de dados (x,y) usando uma
função exponencial:

y = a*ebx

Para linearizar este tipo de função, o que se faz é aplicar o logaritmo em

ambos os lados:

ln(y) = ln(a*ebx) = ln(a)+ln(ebx) = ln(a)+bx

Se fizermos uma mudança de variáveis como abaixo, chegamos uma função

z que é linear:

z = ln(y)
a0 = ln(a)
a1 = b

z = a0 + a1x

Assim, calculam-se os pontos (z,x) e se faz um ajuste linear para encontrar a0

e a1. Lembrando que, no caso, o MMQ linear é aplicado da seguinte maneira:

(n + 1) n
  n z 
 0 i  a0   0 i 
x
 n n  = n
2 a 
  xi 0 i   1  0 zi *xi 
x
 0

Depois se encontram “a” e “b” a partir deles e, consequentemente, a função

exponencial que melhor se ajusta aos dados.
Lira e Fernandes (????) apresentam um exemplo, em que querem aproximar
o conjunto de dados abaixo por uma função exponencial:

O primeiro passo é substituir cada y pelo z=ln(y), resultando:

z
 71

Aplicando o MMQ linear para o conjunto de dados (z,x):

(n + 1) n
  n z 
 0 i  a0   0 i 
x 8 0,3  a0   8,04 
 n n
2 a
 = n 
→ 0,3 3,59  a  = − 8,65
  xi 0 xi   1  0 zi *xi    1   
 0
→ a0 = 1,09859; a1 = -2,50020

ln(a) = a0 → a = ea0 → a = e1,09859 = 3,000

b = a1 = -2,50020
y = a*ebx → y = 3,000*e-2,50020*x

Veja o resultado graficamente a seguir. Note que a função z (linearização)

não tem significado de aproximação, sendo apenas auxiliar.

Neste método, os valores de f(x) dos pontos de entrada não podem ser
menores ou iguais a zero porque não existe o logaritmo natural neste caso.
Para estudar mais aprofundadamente a aproximação exponencial de dados,
acesse:
http://vtp.ifsp.edu.br/nev/Aprox-exp/exaprox.php?

*************************************************************************************************
 72

EXERCÍCIOS

7.4) Calcular, em papel, uma função exponencial de ajuste para os dados a seguir:

0,5

7.5) Duplique o programa do AJUSTE POLINOMIAL e adapte-o para que encontre a

função aproximadora exponencial pelo MMQ, para quaisquer conjuntos de dados de
entrada. Veja que o grau do polinômio agora deve ser fixado em 1 (linear) e o que
muda é a transformação de f(x) em ln(f(x)) antes de montar a matriz e o vetor do
sistema. Do resultado da resolução do sistema, a = e a0; b=a1 e y = a*ebx. Coloque
ainda uma verificação para os valores de f(x) dos pontos de entrada, que não podem
ser menores ou iguais a zero porque não existe o logaritmo natural neste caso.

Use os seguintes algoritmos (em Javascript):

//guardar f[xp] original para depois plotar os pontos

fxptemp=[]; //criar o veto
for (i=0;i<=(np-1);i++){
fxptemp[i]=fxp[i];
}
//transformar y (fxp[]) em z=ln(y)
for (i=0;i<=(np-1);i++){
fxp[i]=Math.log(fxp[i]);
}

(...)

//acertar o resultado
x[1]=Math.pow(Math.E,x[1]);

//imprimir o exponencial aproximador

res='p(x) = '+x[1]+'*e^('+x[2]+'*x)';
document.getElementById('resultado').innerHTML = res;

//montagem da função
f=x[1]+'*Math.pow(Math.E,('+x[2]+'*x))';

*************************************************************************************************

7.2.2 APROXIMAÇÃO POR UMA FUNÇÃO POTENCIAL

Imagine que você queira aproximar um conjunto de dados (x,y) usando uma
função potência:

y = a*xb
Da mesma forma anteriormente explicada, aplica-se o logaritmo em ambos os
lados:
 73

ln(y) = ln(a*xb) = ln(a)+ln(xb) = ln(a)+b*ln(x)

Se fizermos uma mudança de variáveis como abaixo, chegamos uma função

z que é linear:

z = ln(y)
k = ln(x)
a0 = ln(a)
a1 = b

z = a0 + a1k

Assim, calculam-se os pontos (z,k) e se faz um ajuste linear para encontrar a0

e a1. Neste caso, o MMQ linear é aplicado da seguinte maneira:
 n
  n 
(n + 1) k i  a0    z i 
 n n
0
  =  n 0 
 k 2   a1   z i *k i 
 
0
i 0 ki  
0


Depois se encontram “a” e “b” a partir deles e, consequentemente, a função

exponencial que melhor se ajusta aos dados. Então:
a = ea0; b=a1 e y = a*xb.

Seja um exemplo de encontrar uma função aproximadora potencial para os

seguintes dados:
0,1

Aplicando o MMQ linear para o conjunto de dados (z,k):

→ a0 = 2,19063; a1 = 0,81298
ln(a) = a0 → a = e → a = ea0 2,19063
= 8,941
b = a1 = 0,81298
y = a*xb → y = 8,941*x0,81298
 74

Veja o resultado graficamente a seguir.

50
45 46
40
35
33
30
25
20 21
17
15
11 12
10
5 6
4
2
0
0 0,5 1 1,5 2 2,5 3 3,5 4 4,5

dados y

Neste método, os valores de x e f(x) dos pontos de entrada não podem ser
menores ou iguais a zero porque não existe o logaritmo natural neste caso.
Conforme Quadros e Bortoli (2009), existem outras formas de ajuste, como
por exemplo, funções hiperbólicas ou ainda mais complexas. Na prática, os casos
apresentados são os mais frequentes.
Para estudar mais aprofundadamente a aproximação potencial de dados,
acesse:
http://vtp.ifsp.edu.br/nev/Aprox-pot/potaprox.php?

*************************************************************************************************

EXERCÍCIOS

7.6) Calcular, em papel, uma função POTENCIAL de ajuste para os dados a seguir (
os mesmos do exercício 7.4):
0,5

7.7) Duplique o programa do AJUSTE EXPONENCIAL e adapte-o para que encontre

a função aproximadora potencial pelo MMQ, para quaisquer conjuntos de dados de
entrada. Coloque ainda uma verificação para os valores de x e f(x) dos pontos de
entrada, que não podem ser menores ou iguais a zero porque não existe o logaritmo
natural neste caso.

*************************************************************************************************
 75

8 INTEGRAÇÃO NUMÉRICA DE FUNÇÕES

A integração de funções é amplamente utilizada na Engenharia Elétrica. Um

exemplo dado por Ávila (2019) é que a energia () é a integral da potência no
tempo, ou seja, a área sob a curva a seguir:

Fonte: Ávila (2019).

Sendo assim, o que se segue são 2 das formulações numéricas existentes

para o cálculo APROXIMADO de integrais definidas (num intervalo a,b) como a
mostrada anteriormente, da forma genérica:

A função integrando f(x) deve ser obviamente conhecida ou seus valores em

alguns pontos.

8.1 FÓRMULA DOS TRAPÉZIOS

A integral de uma função f no intervalo [a,b] pode ser aproximada pela área
de um trapézio, conforme a figura a seguir:

Figura: Área sob f(x) aproximada por um trapézio. Fonte: Quadros e Bortoli (2009).
 76

Considerando o cálculo da área do trapézio mostrado na figura anterior, pode-

se calcular a integral aproximada como:
Base maior B = f(a)
Base menor b = f(b)
Altura = b-a
Área do trapézio = (B+b)*(b-a)/2

Note que a função f(x) e suas derivadas à primeira e à segunda,

, devem ser contínuas no intervalo [a,b] para que este processo seja
válido.
Para reduzir o erro, que fica claro na figura anterior, já que a integral de uma
função é a área abaixo de sua curva, pode-se dividir a área em “n” trapézios com
altura igual (processo chamado de REGRA DOS TRAPÉZIOS REPETIDA). Fazendo
isso, cada trapézio seria:
Base maior B = f(xi-1)
Base menor b = f(xi)
Altura h = (b-a)/n

Então cada integral parcial, entre 2 pontos, fica:

Somando todos os intervalos, se forem constantes:

Em que:
n é o número de intervalos que se quer usar (quanto mais, melhor)
h = (b-a)/n
f(x0) = f(a)
f(xn) = f(b)
xi = xi-1 + h (i=1 a n-1)

Veja que, se a função f(x) estiver disponível apenas em alguns pontos, na

forma de uma tabela de valores x,f(x), podem-se usar exatamente esses intervalos
para aplicar a regra dos trapézios. Neste caso, se os intervalos de x entre os pontos
forem diferentes, deve-se resolver cada intervalo, ao invés de resolver pela equação
anterior de soma de n intervalos iguais.
Quadros e Bortoli (2009) apresentam um exemplo: na tabela a seguir, é
fornecida a velocidade (km/h) de um cavalo em função do tempo, de zero a 0,4
horas (ou seja, 24 minutos), num intervalo constante (h=0,1). Deseja-se determinar a
distância percorrida pelo cavalo em todo esse intervalo.
 77

Neste caso, sabemos que a distância percorrida é dada por:

Como temos 4 intervalos (número de pontos - 1), de acordo com a tabela

fornecida, podemos usar exatamente n=4. Se quiséssemos usar mais intervalos
para melhorar a aproximação da integral, poderíamos encontrar uma função v(t)
interpoladora. Temos:
h = (0,40-0,00)/4 = 0,1 (neste caso de intervalo constante)

= 3,26 km
Um algoritmo possível para o cálculo de integral de uma função, pela Regra
dos Trapézios é, tendo f(x), n (número de intervalos, constantes) e os extremos a e b
da integral:

1: inte=0;
2: h=(b-a)/n;
3: x(0)=a;
4: para i=1 até n {
5: x(i)=x(i-1)+h
6: inte=inte+((h/2)*(f(x(i-1))+f(x(i)))
7: } fim do para i

No caso de numa tabela de n+1 pontos (xi,f(xi)) com intervalos iguais ou

diferentes (não importa):

1: inte=0;
2: para i=1 até n {
3: h(i)=x(i)-x(i-1);
4: inte=inte+((h(i)/2)*(f(x(i-1))+f(x(i)))
5: } fim do para i

Para estudar mais aprofundadamente a integração numérica via Regra dos

Trapézios, acesse:
http://vtp.ifsp.edu.br/nev/Integral-trap-func/inttrapf.php?
http://vtp.ifsp.edu.br/nev/Integral-trap-tab/inttraptab.php?

*************************************************************************************************

EXERCÍCIOS

8.1) Calcule a integral a seguir, pela Regra dos Trapézios, com 10 intervalos
constantes.
 78

8.2) Dada a tabela de pontos a seguir, calcule a integral de f(x) pela Regra dos
Trapézios, de 0 a 3,8.

x 0 0,75 1,5 2,05 2,6 3,2 3,8

f(x) 0 0,69 0,92 1,10 1,28 1,41 1,57

8.3) Usando o conhecimento adquirido nos programas anteriores, em Javascript, crie

um programa para calcular a integral de uma função, pela Regra dos Trapézios, em
que os dados de entrada sejam uma tabela com k pares de valores (x,f(x)), sendo o
número de intervalos automaticamente n=k-1. Os intervalos podem ser diferentes.

8.4) Usando o conhecimento adquirido nos programas anteriores, em Javascript, crie

um programa para calcular a integral de uma função analítica num intervalo qualquer
a,b, pela Regra dos Trapézios, sendo possível variar o número “n” de intervalos
constantes.

*************************************************************************************************

8.2 FÓRMULA DE SIMPSON

A regra de Simpson tem a mesma base da regra dos trapézios, sendo que
naquela usa-se uma aproximação linear dentro do intervalo e nesta usa-se um
polinômio de grau 2, o que confere melhor aproximação em relação à solução exata.
Veja:

Figura: Comparação entre métodos de integração numérica. Fonte: adaptado de

http://slideplayer.com.br/slide/334139/.

O polinômio de grau 2 que aproxima a função original f(x) pode ser obtido,
segundo Ruggiero (2006), por interpolação polinomial de grau 2 com funções de
Lagrange. A partir daí, Quadros e Bortoli (2009) apresentam o cálculo aproximado
da integral de f(x), com “2n” intervalos constantes de amplitude “h” como:
 79

h  f ( x0 ) + 4 f ( x1 ) + f ( x3 ) + f ( x5 ) + ... + f ( x2 n−1 ) 
S ( f , h) =  
3 + 2 f ( x2 ) + f ( x4 ) + f ( x6 ) + ... + f ( x2 n−2 ) + f ( x2 n )

Portanto, se quisermos integrar uma função f(x) de a até b, usando intervalos

constantes de amplitude “h”:

2n é o número de intervalos que se quer usar (quanto mais, melhor)

h = (b-a)/2n
f(x0) = f(a)
f(x2n) = f(b)
xi = xi-1 + h (i=1 a 2n)

Obviamente e segundo Ruggiero (1996), “2n” tem que ser par, ou seja, o
número de intervalos tem que ser par. No caso de uma tabela de “np” pontos, “np”
tem que se ímpar, uma vez que np=2n+1.

É possível o cálculo a partir de uma tabela de valores com intervalos

diferentes, mas, a cada 3 pontos, os 2 intervalos têm que obrigatoriamente ser
iguais. Ruggiero (1996) mostra a expressão genérica para o cálculo a cada 3 pontos
(2 intervalos):

Asano e Colli (2009) apresentam um exemplo: a tabela a seguir contém

pontos de uma função a ser integrada, com intervalos constantes.

Por comparação, Asano e Colli (2009) mostram a solução pela Regra dos
Trapézios como:

= 0,785

No caso da Regra de Simpson, temos 10 intervalos, de acordo com a tabela

fornecida, sendo n=5. Note que aqui, o número de intervalos é igual a “2n”. Temos:
 80

h = (1,00-0,00)/10 = 0,1 (intervalos constantes)

Resolvendo por partes, conforme Asano e Colli (2009):

= 0,785398

Um algoritmo possível para o cálculo de integral de uma função, pela Fórmula

de Simpson é, tendo 2n intervalos constantes e os extremos a e b da integral:

1: verificar se 2n é par; senão, parar.

2: h=(b-a)/2n;
3: x(0)=a;
4: para i=1 até (2n) {
5: x(i)=x(i-1)+h
6: } fim do para i
7: inte=0;
8: para k=1 até n {
9: inte=inte+((h/3)*(f(x(2k-2))+4f(x(2k-1)+f(x(2k)))
10: } fim do para k

No caso de intervalos diferentes (numa tabela de (2n+1) pontos (0 a 2n)),

pode-se usar o algoritmo a seguir. Lembre-se que, a cada 3 pontos, os intervalos
têm que obrigatoriamente serem iguais.

1: verificar se 2n+1 é ímpar; senão, parar.

2: inte=0;
3: para k=1 até n {
4: verificar se x(2k)-x(2k-1) = x(2k-1)-x(2k-2); senão, parar.
5: h(k)=(x(2k)-x(2k-2))/2;
6: inte=inte+((h(k)/3)*(f(x(2k-2))+4f(x(2k-1)+f(x(2k)))
7: } fim do para k

Para estudar mais aprofundadamente a integração numérica via Regra de

Simpson, acesse:
http://vtp.ifsp.edu.br/nev/Integral-simp-func/intsimpf.php?
http://vtp.ifsp.edu.br/nev/Integral-simp-tab/intsimptab.php?

*************************************************************************************************

EXERCÍCIOS

8.5) Calcule a integral a seguir (a mesma do exercício 8.1), pela Regra de Simpson,
com 10 intervalos constantes.
 81

8.6) Dada a tabela de pontos a seguir (a mesma do exercício 8.2), calcule a integral
de f(x) pela Fórmula de Simpson de 0 a 3,8.

x 0 0,75 1,5 2,05 2,6 3,2 3,8

f(x) 0 0,69 0,92 1,10 1,28 1,41 1,57

8.7) Usando o conhecimento adquirido nos programas anteriores, em Javascript, crie

um programa para calcular a integral de uma função, pela Fórmula de Simpson, em
que os dados de entrada sejam uma tabela com k pares de valores (x,f(x)), sendo k
obrigatoriamente um número ímpar maior ou igual a 3 para o método funcionar. Os
intervalos podem ser diferentes, mas, a cada 3 pontos, têm que obrigatoriamente ser
iguais.

8.8) Usando o conhecimento adquirido nos programas anteriores, em Javascript, crie

um programa para calcular a integral de uma função analítica num intervalo qualquer
a,b, pela Fórmula de Simpson, sendo possível variar o número “2n” de intervalos
(número par) e os mesmos são constantes.

FUNÇÃO PARA VERIFICAR SE UM NÚMERO “m” É ÍMPAR:

if (m%2!=0) { //a função "m%2" retorna o valor do resto da divisão por dois
alert('Erro: Neste método, o número de intervalos tem que ser par');
return; //pára o programa
}

*************************************************************************************************
 82

9 DERIVAÇÃO NUMÉRICA DE FUNÇÕES

O objetivo do cálculo de derivação numérica de funções é, além de aplicações

diretas na Engenharia, também usar este processo nos métodos para resolução de
equações diferenciais, que serão apresentados em capítulo posterior.
As derivadas de funções com apenas uma variável são chamadas
DERIVADAS TOTAIS, representadas pela letra d. Existem ainda as derivadas
parciais, que derivam uma função com duas ou mais variáveis em relação a apenas
uma dessas variáveis, deixando as outras como se fossem constantes. As derivadas
parciais são representadas pela letra  . Veja:

df 2
( x ) = 2 x → DERIVADA TOTAL
dx
f
(2 xy 2 ) = 2 y 2 → DERIVADA PARCIAL (somente em x)
x
f
(2 xy 2 ) = 4 xy → DERIVADA PARCIAL (somente em y)
y

Temos ainda as derivações de ordem superior, ou seja, vai se derivando

sucessivamente a função.
Uma aplicação direta na área de Engenharia Elétrica é dada, por exemplo, em
Ávila (2019), sendo o vetor densidade de corrente elétrica (J) que pode ser
equacionado como a proporcionalidade da condutividade elétrica (σ) do
meio condutor e a variação da tensão elétrica (dV/dt), desta forma:

A derivada em um ponto x0 de uma função y=f(x) representa a taxa de

variação instantânea de y em relação a x neste ponto x0 e pode ser denotada
como f’(x0). Graficamente, a derivada é interpretada como o coeficiente angular da
reta tangente ao gráfico de f(x) em um ponto x0.

Figura: Função f(x) e reta tangente a ela. Fonte:

http://www.if.ufrj.br/~tkodama/Fisica_I/expansaotaylor.pdf.

Conforme Aguiar, Siple e Moro (2012), uma das formas de apresentação de

uma derivada é:
 83

y f ( x) − f ( x0 )
f ' ( x) = lim , ou seja, f ' ( x0 ) = lim
x →0 x ( x− x0 )→0 ( x − x0 )

Pode-se escrever, portanto:

(válida num ponto x próximo de x0)

Considere a expressão a seguir, conhecida como expansão em série de

Taylor da função f(x) em torno de x = x0.

Comparando-a com a expressão imediatamente anterior, percebe-se o que se

está cometendo de erro de aproximação, parcelas que dependem das derivadas de
ordem superior de f(x0).
Chamando (x-x0) de “h”, ou seja, uma variação em torno de x, são obtidas 3
possibilidades para o cálculo numérico aproximado do valor da derivada da função
num ponto xi (chamado Método das Diferenças Finitas):

→ DIFERENÇA ASCENDENTE ou avançada

→ DIFERENÇA DESCENDENTE ou atrasada

→ DIFERENÇA CENTRAL ou centrada (MAIS EXATA)

Segundo Quadros e Bortoli (2009), para as diferenças ascendente e

descendente, o erro é da ordem de h (em %). Para a diferença central, os autores
comentam que o erro é da ordem de h2 (em %). Considere que o erro é
normalmente menor que 1, então h > h2.
Sendo assim, o que se faz é, dada uma função f(x) e a necessidade de
encontrar f’(x) num ponto x, criar uma tabela com 3 pontos, sendo o ponto central
igual (x,f(x)), o ponto à esquerda igual a (x-h,f(x-h)) e o ponto à direita igual a
(x+h,f(x+h)), escolhendo um h pequeno (quanto menor, melhor). A seguir, aplicam-
se as fórmulas anteriormente explicitadas.
Quadros e Bortoli (2009) apresentam um exemplo: calcular f′(1,4) usando
diferenças finitas, conforme os dados da tabela:
 84

2*0,1

Obviamente, é mais vantajoso usar a fórmula de diferenças centrais. A partir

das diferenças centrais, Quadros e Bortoli (2009) apresentam as expressões
numéricas para o cálculo de derivadas de ordem superior:

Segundo Quadros e Bortoli (2009), para as expressões anteriores, de

derivada de ordem 2 a 4, o erro é da ordem de h2.
Para estudar mais aprofundadamente a derivação numérica, acesse:
http://vtp.ifsp.edu.br/nev/Derivada-func/derf.php?
http://vtp.ifsp.edu.br/nev/Derivada-tab/dertab.php?

*************************************************************************************************

EXERCÍCIOS

9.1) Calcule, numericamente, por diferenças finitas, as derivadas da função f(x) = e2x
nos pontos ( x ) e com os intervalos (h) a seguir. Comparar com a solução analítica.
a) x =1,1 e h = 0,1; usar diferenças ascendentes
b) x =1,1 e h = 0,01; usar diferenças ascendentes
c) x =1,2 e h = 0,1; usar diferenças descendentes
d) x =1,2 e h = 0,01; usar diferenças descendentes
e) x =1,3 e h = 0,1; usar diferenças centrais
f) x =1,3 e h = 0,01; usar diferenças centrais
g) x =1,4 e h = 0,1; usar diferenças centrais
h) x =1,4 e h = 0,01; usar diferenças centrais
 85

9.2) Novamente com relação à função f(x) = e2x, calcule sua derivada à segunda no
ponto x =1,5, com h = 0,02, usando a expressão proposta anteriormente. Comparar
com a solução analítica.

9.3) Dada a tabela de x,f(x) a seguir, calcule, numericamente, por diferenças finitas,
as derivadas da função nos pontos dados, conforme os itens a seguir.

a) x =1,8; usar diferenças ascendentes

b) x =1,9; usar diferenças descendentes
c) x =2,0; usar diferenças centrais
d) x =2,1; usar diferenças centrais
e) x =2,2; usar diferenças descendentes

9.4) Dada a tabela de x,f(x) a seguir, calcule, numericamente, por diferenças finitas,
a derivada à segunda da função no ponto x =1,3.

9.5) Calcule, numericamente, por diferenças finitas, as derivadas parciais da função

f(x,y) = 2xy2 nos pontos ( x , y ) e com os intervalos (h) a seguir. Comparar com a
solução analítica.
f
a) em (2,3) e h = 0,01; usar diferenças ascendentes
x
f
b) em (2,3) e h = 0,01; usar diferenças descendentes
x
f
c) em (2,3) e h = 0,01; usar diferenças centrais
x
f
e) em (2,3) e h = 0,01; usar diferenças ascendentes
y
f
f) em (2,3) e h = 0,01; usar diferenças descendentes
y
f
g) em (2,3) e h = 0,01; usar diferenças centrais
y

Obs: para a derivação parcial, o h é aplicado somente na variável derivada. Por

f
exemplo, na proposição a), em (2,3) = (f(2,01;3)-f(2,3))/0,01.
x
 86

9.6) Crie um algoritmo para resolver, a partir de uma dada função f(x) e um intervalo
h, a derivada, por diferença central, de f(x) em um ponto específico xb.

9.7) Usando o conhecimento adquirido nos programas anteriores, em Javascript, crie

um programa para calcular, numericamente, por diferenças finitas, as derivadas à
primeira e à segunda (por diferenças CENTRAIS) de uma função analítica f(x)
qualquer, sendo que o usuário deve entrar com o x onde quer as derivadas e com o
intervalo h. O resultado deve ficar como o abaixo:

*************************************************************************************************
 87

10 SOLUÇÃO DE EQUAÇÕES DIFERENCIAIS

Uma equação diferencial é uma equação que envolve derivadas de funções,

portanto se propõe a encontrar a função f(x) que a satisfaz. Veja o exemplo da
equação diferencial abaixo, que contém a função f(x) e sua derivada f’(x):

2*f(x) – x*f’(x) = 0 → EQUAÇÃO DIFERENCIAL

A resolução da equação diferencial acima leva à função f(x) = x 2 como

possível solução. Ruggiero (1996) explica que uma equação diferencial possui
uma família de soluções possíveis, e não apenas uma.
As equações diferenciais ORDINÁRIAS são aquelas que só têm UMA variável
independente, x. Note que y é dependente de x, ou seja, y(x). São exemplos,
conforme Ruggiero (1996):

Se houver mais de uma variável independente, tem-se uma equação

diferencial PARCIAL. Ruggiero (1996) exemplifica:

Conforme Ruggiero (1996), a ordem de uma equação diferencial é a mais alta

ordem de derivação que aparece na equação. Assim, os exemplos anteriores são
equações diferenciais de 1ª, 1ª, 2ª e 2ª ordem, respectivamente.
Existe um número muito restrito de equações diferenciais cujas soluções
podem ser expressas sob a forma analítica simples. Desta forma, os métodos
numéricos são muito importantes na solução aproximada de equações diferenciais.

10.1 SOLUÇÃO DE EQUAÇÕES DIFERENCIAS ORDINÁRIAS (EDOs)

No caso das equações diferenciais ordinárias, uma das possíveis soluções

depende do conhecimento prévio da função ou suas derivadas em determinados
pontos. Sob outras condições, existem outras soluções. São os chamados
problemas de valor inicial (PVIs) e os problemas de valor de contorno (PVCs).
Se, dado um problema com EDOs de ordem m, a função e suas derivadas até
a ordem m-1 são conhecidas em um mesmo ponto (chamado inicial), então temos
um PVI. Veja 2 exemplos, conforme Ruggiero (1996):

No caso a), a EDO tem ordem 1, então deve ser conhecido somente o valor
da função em um ponto, no exemplo, 0. No caso b), como a EDO tem ordem 3, têm
 88

que ser conhecidos o valor da função em um ponto (y(0)) e os valores das derivadas
neste mesmo ponto (no exemplo, 0), até a ordem 2.
Se, dado um problema com EDOs de ordem m (obrigatoriamente m2), “m”
condições de contorno são especificadas nos pontos inicial e final do domínio (por
isso a palavra “contorno”), então temos um PVC.
Um exemplo de EDO aplicada na Engenharia Elétrica é o abaixo, dado por
Ávila (2019), em que V é a fonte, R é a resistência, L é a indutância e I é a corrente.

Fonte: Ávila (2019).

Nesta disciplina, estudaremos como achar as soluções, y(x), NUMÉRICAS,

não analíticas, de PVIs de ordem 1 e PVCs de ordem 2 das formas genéricas
abaixo, conforme Ruggiero (1996):

y' = g(x, y)  y' '+P(x)y'+Q(x)y = w(x)

PVI  PVC 
 y(x0 ) = y0 y(x0 ) = y 0 , y(xn ) = y n

Veja exemplos:

(PVI) (PVC)

Nestes casos:

g(x,y) = xy P(x)=2; Q(x)=1; w(x) = x

x0 = 0 x0 = 0 e x1 = 1
y0 = 0,3 y0 = 0 e y1 = -1
Veja que g(x,y) e w(x) NÃO são as soluções, mas sim funções genéricas que
aparecem no PVI e no PVC, respectivamente.
Nos PVIs, há sempre solução única. Já nos PVCs, Ruggiero (1996) comenta
que pode haver mais de uma possível solução.
Os métodos de solução aproximada das equações diferenciais baseiam-se
nas expansões em séries de Taylor (explicadas na resolução numérica de
derivadas). Seguem três métodos possíveis.
 89

10.1.1 MÉTODO DE EULER PARA SOLUÇÃO DE PVIs DE ORDEM 1

O Método de Euler baseia-se em expansões em séries de Taylor de 1ª ordem

(menos precisas). Ao invés de se obter uma solução f(x) analítica, o que se faz é
calcular o valor numérico da função f(x) em um intervalo de pontos que satisfazem à
EDO e ao PVI.
Relembrando a expansão em série de Taylor:

Se considerarmos um intervalo pequeno x i+1-xi e lembrando que f’(x)=g(x,y)

(veja o esquema apresentado anteriormente do PVI de ordem 1):
y(xi+1) = y(xi)+h.g(xi,y(xi)) (Taylor de 1ª ordem: desconsiderados f” pra frente)

Em outra notação:
yi+1 = yi+h.g(xi,yi), i=0,1,…,n-1

Assim, o método de Euler é uma sucessão de “n” intervalos de x e, quanto

menor o intervalo h, melhor é a aproximação. Assim, note que, quanto menor o
intervalo, mais pontos de f(x) você terá e esses pontos terão melhor aproximação em
relação ao valor analítico. O número de intervalos será dado por:
n = (xn – x0) / h

Portanto, a resposta do problema serão alguns pontos (x,f(x)) ou (x,y) da

função que resolve a equação diferencial. Pelo PVI de Euler, fica:

xi yi
x0 (dado) y0 (dado)
x1 = x0 + h y1 = y0+h.g(x0,y0)
x2 = x1 + h y2 = y1+h.g(x1,y1)
... ...
... ...
xn = xn-1 + h yn = yn-1+h.g(xn-1,yn-1)

*Se necessário obter uma função explícita, pode-se fazer uma interpolação usando
os pontos, conforme estudado em capítulo anterior.

EXEMPLO: Resolver o PVI no domínio x0 = 0 a xn = 1,0, com h

= 0,1.

Obs: quando se diz resolver o PVI quer dizer que se quer a função y(x) tendo sua
derivada, y’(x), e o valor em um ponto (y(x0)). Como explicado, numericamente, não
se encontra a função analítica, mas vários pares de pontos (x,y(x)), caracterizando-
a. Se necessário obter uma função explícita, pode-se fazer uma interpolação usando
os pontos, conforme estudado em capítulo anterior.

SOLUÇÃO:

g(xi,yi) = yi-xi (a partir da EDO dada no enunciado)

x0 = 0 (dado no enunciado)
 90

y0 = 2 (dado no enunciado)
xn = 1 (dado no enunciado)
h = 0,1 (dado no enunciado; quanto menor, mais preciso o resultado)
n = (1 – 0) / 0,1 = 10
fórmula de recorrência: yi+1 = yi+h.g(xi,yi) = yi+0,1.(yi-xi)

(i=0) → y1 = y0+0,1.(y0-x0) → y1 = 2+0,1.(2-0) → y1 = 2,2

(i=1) → y2 = y1+0,1.(y1-x1) → y2 = 2,2+0,1.(2,2-0,1) → y2 = 2,41
(i=2) → y3 = y2+0,1.(y2-x2) → y3 = 2,41+0,1.(2,41-0,2) → y3 = 2,631
(i=3) → y4 = y3+0,1.(y3-x3) → y4 = 2,631+0,1.(2,631-0,3) → y4 = 2,8641
(...)
(i=9) → y10 = y9+0,1.(y9-x9)

Neste exemplo, didático, se sabe que a função é a que

satisfaz ao PVI. As tabelas a seguir mostram os cálculos considerando intervalos
menores e a comparação com a solução exata.
 91

*************************************************************************************************
 92

EXERCÍCIOS

10.1) Resolva, por Euler, o seguinte PVI, com h = 0,1, no domínio 0 a 1.

10.2) Crie um algoritmo para resolver, por Euler, a partir de um PVI genérico em que
o usuário entre com g(x,y), (x0,y0), xn e o intervalo h.

10.3) Excluído desta apostila.

10.4) EXTRA - Usando o conhecimento adquirido nos programas anteriores, em

Javascript, crie um programa para resolver, por Euler, PVIs de ordem 1 da forma:
y' = g(x, y)
PVI 
 y(x0 ) = y0

O usuário deve entrar com g(x,y), x0, y0, xn (definindo o domínio) e o intervalo
h desejado. O resultado deve ser a tabela resolvida (x,y(x)), como o exemplo abaixo.
 93

Para resolver avaliar funções de mais variáveis no Javascript, somente

acrescente-as. Veja um exemplo:

x = 10;
y = 20;
g='x*y';
vg(g,x,y); //sai v (ao invés de y, para não confundir com uma das variáveis)

function vg(g,x,y) {
v=eval(g)
}

Para colocar uma imagem (.jpg) na página HTML, como, por exemplo, a
imagem da equação mostrada,

<img src="imagem.jpg" align="left" border=1 height=250 width=250 hspace=10 vspace=10>

//O arquivo imagem.jpg deve estar na pasta do programa

height: altura da imagem, em pixels

width: largura da imagem, em pixels
hspace: especifica um espaço em branco a ser deixado entre as bordas esquerda e
direita da imagem, em pixels. Ou seja, os textos que forem escritos ao redor da
imagem não ficarão grudados nela.
vspace: especifica um espaço em branco a ser deixado entre a parte superior e
inferior da imagem

*************************************************************************************************
 94

10.1.2 MÉTODO DE RUNGE-KUTTA DE 2ª ORDEM (OU MÉTODO DE HEUN)

PARA O CÁLCULO DE PVIs DE ORDEM 1

Podem ser deduzidas fórmulas de Euler usando as expansões de Taylor de 2ª

ordem, 3ª e assim por diante. Porém, tais fórmulas necessitam do cálculo das
derivadas sucessivas de g(xi,yi). Buscando evitar isso, surgem as fórmulas de
Runge-Kutta. No caso de Runge-Kutta de 2ª ordem, depois dos tratamentos
matemáticos, o PVI geral fica:

h
yi+1 = yi + (k1 + k2 ), k1 = g ( xi , yi ) e k2 = g ( xi + h, yi + hk1 ), i = 0,1,...n − 1
2
Para efeito de comparação, vamos analisar um exemplo aplicado no mesmo
PVI resolvido pelo Método de Euler.

EXEMPLO: Resolver o PVI no domínio x0 = 0 a xn = 1,0.

SOLUÇÃO:
g(xi,yi) = yi-xi (a partir da EDO dada no enunciado)
x0 = 0
y0 = 2
xn = 1 (dado no enunciado)
h = 0,1 (definido aqui; quanto menor, mais preciso o resultado)
n = (1 – 0) / 0,1 = 10
fórmula de recorrência:
yi+1 = yi+(0,1/2).(k1+k2); k1 = yi-xi; k2 = (yi+0,1.k1)-(xi+0,1)

A tabela a seguir mostra a solução:

Para comparação da eficiência, Hauser (????) mostra um exemplo de

resolução de um PVIs pelos métodos de Euler e Runge-Kutta. Nas suas tabelas (a
seguir), só está mostrada a solução para x i com incrementos iguais a 0,1, sendo um
resumo no caso dos intervalos h menores que isso.
 95

Fonte: Hauser (????).

Fonte: Hauser (????).

*************************************************************************************************

EXERCÍCIOS

10.5) Resolva, por Runge-Kutta de 2ª ordem, o seguinte PVI, com h = 0,1, no

domínio 0 a 1 (o mesmo do exercício 10.1).
 96

10.6) Resolva, por Runge-Kutta de 2ª ordem, o seguinte PVI, com h = 0,1, no

domínio 2 a 3.

10.7) Resolva, por Runge-Kutta de 2ª ordem, o seguinte PVI, com h = 0,2, no

domínio 0 a 2.

10.8) Crie um algoritmo para resolver, por Runge-Kutta de 2ª ordem, a partir de um

PVI genérico em que o usuário entre com g(x,y), (x0,y0), xn e o intervalo h.

10.9) EXTRA - Duplique e adapte o programa do exercício 10.3 para resolver, por
Runge-Kutta de 2ª ordem, PVIs de ordem 1 da forma:
y' = g(x, y)
PVI 
 y(x0 ) = y0

*************************************************************************************************
 97

10.1.3 MÉTODO DAS DIFERENÇAS FINITAS PARA A RESOLUÇÃO DE PVCs DE

ORDEM 2

Relembrando, seja um PVC de ordem 2 generalizado pelo seguinte:

 y' '+P(x)y'+Q(x)y = w(x)

PVC 
y(x0 ) = y 0 , y(xn ) = y n

Conforme Ruggiero (1996), a idéia básica do Método das Diferenças Finitas é

transformar o problema de resolver uma equação diferencial num problema de
resolver um sistema de equações algébricas, usando para isto aproximações das
derivadas que aparecem na equação, por diferenças finitas.
Então, o problema passa a ser a resolução do seguinte sistema linear (de 1 a
n-1 porque y0 e yn são conhecidos):

y' '1 + P( x1 ) * y'1 +Q( x1 ) * y1 = w( x1 )

y' '2 + P( x2 ) * y'2 +Q( x2 ) * y2 = w( x2 )
(...)
y' 'n−1 + P( xn−1 ) * y'n−1 +Q( xn−1 ) * yn−1 = w( xn−1 )

Lembre-se que o que se quer é encontrar y 1 até yn-1.

O sistema é possível de ser resolvido porque podemos aproximar as
derivadas de y conhecendo-se y em alguns pontos. Relembrando, as aproximações
mais usadas para a primeira e segunda derivadas em xi são obtidas a partir da
diferença central. Relembrando o item sobre derivação numérica, na notação de
Ruggiero (1996):

Para cada linha:

y' '1 = ( y2 − 2 y1 + y0 ) / h2 = y0 / h2 − 2 y1 / h2 + y2 / h2
y' '2 = ( y3 − 2 y2 + y1 ) / h 2 = y1 / h2 − 2 y2 / h2 + y3 / h 2
(...)
y' 'n−1 = ( yn − 2 yn−1 + yn−2 ) / h2 = yn−2 / h2 − 2 yn−1 / h2 + yn / h2

y'1 = ( y2 − y0 ) / 2h = − y0 / 2h + y2 / 2h
y'2 = ( y3 − y1 ) / 2h = − y1 / 2h + y3 / 2h
(...)
y'n−1 = ( yn − yn−2 ) / 2h = − yn−2 / 2h + yn / 2h
 98

Para a primeira linha:

y0 / h 2 − 2 y1 / h 2 + y 2 / h 2 + P( x1 ) * (− y0 / 2h + y 2 / 2h) + Q( x1 ) * y1 = w( x1 )
Ou:
y0 / h − P( x1 ) * ( y0 / 2h) − 2 y1 / h 2 + Q( x1 ) * y1 + y2 / h 2 + P( x1 ) * ( y 2 / 2h) = w( x1 )
2

Ou:
y0 [1/ h2 − P( x1 ) / 2h] + y1[−2 / h2 + Q( x1 )] + y2 [1/ h2 + P( x1 ) / 2h] = w( x1 )
Como y0 é conhecido:
y1[−2 / h2 + Q( x1 )] + y2 [1/ h2 + P( x1 ) / 2h] = w( x1 ) − y0 [1/ h2 − P( x1 ) / 2h]

Para a linha 2:

y1 / h 2 − 2 y2 / h 2 + y3 / h 2 + P( x2 ) * (− y1 / 2h + y3 / 2h) + Q( x2 ) * y2 = w( x2 )
Ou:
y1 / h − P( x2 ) * ( y1 / 2h) − 2 y 2 / h 2 + Q( x2 ) * y2 + y3 / h 2 + P( x2 ) * ( y3 / 2h) = w( x2 )
2

Ou:
y1[1 / h 2 − P( x2 ) / 2h] + y 2 [−2 / h 2 + Q( x2 )] + y3 [1 / h 2 + P( x2 ) / 2h] = w( x2 )

Semelhantemente, para a linha n-2:

yn−3[1/ h2 − P( xn−2 ) / 2h] + yn−2 [−2 / h2 + Q( xn−2 )] + yn−1[1/ h2 + P( xn−2 ) / 2h] = w( xn−2 )

Semelhantemente, para a linha n-1:

yn−2 [1/ h2 − P( xn−1 ) / 2h] + yn−1[−2 / h2 + Q( xn−1 )] + yn [1/ h2 + P( xn−1 ) / 2h] = w( xn−1 )
Como yn é conhecido:
yn−2 [1/ h2 − P( xn−1 ) / 2h] + yn−1[−2 / h2 + Q( xn−1 )] = w( xn−1 ) − yn [1/ h2 + P( xn−1 ) / 2h]

Sendo assim, o problema se resume a resolver o seguinte sistema linear:

 d1 c1 0 0 0 0   y1   w( x1 ) − y0 [1 / h 2 − P ( x1 ) / 2h] 
a d2 c2 0 0 0  y   w ( x )

 2   2
  2 
0 a3 d3 c3 0 0   y3   w( x3 ) 
  
x  
= 
0 0 ... ... ... 0   ...   ... 
0 0 0 an − 2 d n−2 cn − 2   yn−2   w( xn−2 ) 
     
0 0 0 0 an−1 d n−1   yn−1   w( xn−1 ) − yn [1 / h 2 + P( xn−1 ) / 2h]
Em que:
di = −2 / h 2 + Q( xi ) 1  i  (n-1)
ci = 1/ h2 + P( xi ) / 2h 1  i  (n-2)
ai = 1/ h2 − P( xi ) / 2h 2  i  (n-1)
 99

Ruggiero (1996) apresenta um exemplo de resolver um PVC que segue a

generalização proposta:

Considerando a nomenclatura indicada, neste caso, temos:

P(x) = 2 (constante)
Q(x) = 1 (constante)
w(x) = x
x0 = 0; y0 = 0; xn = 1; yn = -1
número de intervalos (n), h = (xn-x0)/n e xi = ih.

No caso deste exemplo de fins didáticos, conhece-se a solução:

. Sendo assim, é possível verificar a eficácia do método. As tabelas
a seguir mostram a solução para comprimentos de intervalo h = 0,05 e 0,1. Ruggiero
(1996) observa que o erro é menor que h2 em todos os casos.

Seguindo os passos descritos, é possível generalizar a solução de qualquer

outro PVC.

*************************************************************************************************

EXERCÍCIOS
 100

10.10) Resolva, em papel, pelo Método das Diferenças Finitas, os PVCs a seguir.

10.11) Crie um algoritmo para resolver, pelo Método das Diferenças Finitas, a partir
de um PVC genérico em que o usuário entre com P(x), Q(x), w(x), x0, y0, xn, yn e o
intervalo h desejado.

10.12) EXTRA - Usando o conhecimento adquirido nos programas anteriores, em

Javascript, crie um programa para resolver, pelo Método das Diferenças Finitas, um
PVC generalizado:

 y' '+P(x)y'+Q(x)y = w(x)

PVC 
y(x0 ) = y 0 , y(xn ) = y n

O usuário deve entrar com P(x), Q(x), w(x), x0, y0, xn, yn e o intervalo h
desejado. O resultado deve ser a tabela resolvida (x,y(x)), como o exemplo a seguir.
 101

10.13) EXTRA - Crie um programa para calcular e plotar, pelo Método das
Diferenças Finitas, a curva de deslocamentos (v(x)) de uma viga biapoiada sujeita a
peso próprio, de material homogêneo e seção retangular. Considere módulo de
elasticidade E, seção transversal b x h, vão L e densidade  como dados de entrada.
Utilizar, para a plotagem, 50 intervalos. Lembre-se que o problema é regido pela
seguinte EDO:
d 2v
EI 2 = M ( x)
dx

*************************************************************************************************

10.2 SOBRE A SOLUÇÃO DE EQUAÇÕES DIFERENCIAS PARCIAIS

Os problemas envolvendo a resolução de equações diferenciais parciais são

bastante específicos na Engenharia. Somado a isso a complexidade dos métodos de
resolução, o estudante poderá ter contato com esse conteúdo em cursos de pós-
graduação. Quadros e Bortoli (2009) e Ávila (2019) apresentam alguns problemas
deste tipo e algumas soluções. Aqui, vejamos apenas alguns exemplos:

→ EDP para resolver a propagação de onda eletromagnética que parte de uma

estação rádio base e viaja até um aparelho de telefonia celular, sujeita por tanto a
variações do meio e do tempo.
 102

→ EDP para resolver a condução de calor em um sólido:

u(x,t) é a temperatura num ponto x de um sólido, no instante t;

 é a difusividade térmica do sólido

→ EDP para resolver o fluxo elétrico que passa através de uma superfície fechada:

E é o potencial elétrico;
 é a densidade da distribuição bidimensional da carga;
 é a constante dielétrica
 103

11 CONSIDERAÇÕES FINAIS

Ao estudante que seguirá a área de Métodos Numéricos, é importante estudar

ainda as estimativas dos erros cometidos nas operações demonstradas nesta
apostila, o que se pode fazer com detalhes, por exemplo, em Ruggiero (1996).
O Exame nacional de desempenho dos estudantes (ENADE) costuma cobrar
conteúdos de Cálculo Numérico. Nesse sentido, veja e resolva os exercícios a
seguir.

******************************************************************************************
 104

EXERCÍCIOS

11.1) ENADE 2014

 105

11.2) ENADE 2011

 106

12 REFERÊNCIAS BIBLIOGRÁFICAS

AGUIAR, Rogério de; SIPLE, Ivanete Zuchi; MORO, Graciela. Conceito de

derivada e diferencial: concepções e relações. SINCET: Porta Grossa-PR, 2012.
Disponível em:<
https://www.google.com.br/url?sa=t&rct=j&q=&esrc=s&source=web&cd=26&ved=0C
DkQFjAFOBQ&url=http%3A%2F%2Fwww.sinect.com.br%2F2012%2Fdown.php%3F
id%3D2898%26q%3D1&ei=iMlSVOuCC_i_sQTgzoKQBQ&usg=AFQjCNH045BQDw
YrJKZ5_9PKOlLLIUDa9Q&sig2=AHW902sUk68RKPtnV94ceA&bvm=bv.78597519,d
.eXY&cad=rja>. Acesso em 09/09/2014.

ASANO, Cláudio Hirofume; COLLI, Eduardo. Cálculo Numérico – Fundamentos e

Aplicações. IME, USP, 2009. Disponível em:<
http://www.ime.usp.br/~asano/LivroNumerico/LivroNumerico.pdf>. Acesso em
09/09/2014.

Ávila, Sérgio Luciano. Cálculo numérico aplicado à engenharia elétrica com

MATLAB. [recurso eletrônico] Florianópolis: Publicações do IFSC, 2019. Disponível
em:<
https://www.ifsc.edu.br/documents/30701/523474/livro_calculo_numerico_AVILA_fin
al.pdf/73592cec-4ae3-4f43-98ff-5da567c1a60e>. Acesso em 27/01/2023.

BONIATI, Bruno. Caderno didático Lazarus IDE. Paraná: UFSM, 2011. Disponível
em:<http://www.cafw.ufsm.br/~bruno/disciplinas/programacao_comercial1/material/c
aderno_didatico_lazarus.pdf>. Acesso em 09/09/2013.

CANTÃO, Luiza Amala Pinto. Cálculo Numérico e Computacional. Sorocaba,

????. Disponível em: <
http://www2.sorocaba.unesp.br/professor/luiza/CNC/apostila.pdf>. Acesso em:
outubro de 2014.

CASTILHO, José Eduardo. Cálculo Numérico. UFU. Uberlândia, 2001. Disponível

em: <http://www1.univap.br/spilling/CN/apostila4.pdf>. Acesso em: agosto de 2015.

CHERRI, Adriana. et al. Métodos Numéricos Computacionais. Bauru, ????.

Disponível em: <http://wwwp.fc.unesp.br/~adriana/Numerico/Introducao.pdf>. Acesso
em: outubro de 2014.

HAUSER, Eliete Biasotto. Cálculo Numérico. PUC-RS, ????. Disponível em: <
http://www.pucrs.br/famat/elieteb/calc_num/Apostila_Calc_Numerico_2008.pdf>.
Acesso em: março de 2015.

LIRA, William Wagner Matos; FERNANDES, Ricardo Albuquerque. Apostila de

Cálculo Numérico. ????. Disponível em:<
http://www1.univap.br/spilling/CN/apostila1.pdf>. Acesso em 09/09/2014.

MASSAGO, Sadao. Escalonamento. 2014. Disponível em:<

https://www.google.com.br/url?sa=t&rct=j&q=&esrc=s&source=web&cd=10&ved=0C
FYQFjAJ&url=http%3A%2F%2Fwww.dm.ufscar.br%2F~sadao%2Fdownload%2F%3
 107

Ffile%3Dstudent%2Fescalonamento.pdf&ei=EC9lVIkv4sixBOj3gNgF&usg=AFQjCNH
9aHhQhcm-W9-B2I6tdkKYt7FG6g&sig2=yXXQRP6B-
idK7yfqj7roqg&bvm=bv.79189006,bs.1,d.eXY&cad=rja>. Acesso em 13/11/2014.

MELO, Evandro de Castro. Free Pascal Lazarus. Minas Gerais: UFV, 2012.
Disponível em:< www.evandro.eng.br/Apostila-Lazarus.pdf>. Acesso em 09/09/2013.

NIRSCHL, G. C. Método dos Elementos Finitos e técnicas de enriquecimento da

aproximação aplicados à análise de tubos cilíndricos e cascas esféricas.
Dissertação (Mestrado) – Escola de Engenharia de São Carlos, Universidade de São
Paulo, São Carlos, 2005.

PROENÇA, S. P. B. Diferenças finitas na integração das equações de técnica

do meio contínuo. 174p. Dissertação (Mestrado) - Escola de Engenharia de São
Carlos, Universidade de São Paulo, São Carlos. 1986.

QUADROS, Régis S. de; BORTOLI, Álvaro L. de. Fundamentos de Cálculo

Numérico para Engenheiros. Porto Alegre, 2009. Disponível em: <
http://www.inf.ufrgs.br/~rlflupchinski/files/20112/NUMERICO/numerico-bortoli.pdf >.
Acesso em: outubro de 2014.

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.

SWOKOWSKI. Cálculo com Geometria Analítica. São Paulo. Makron Books, 1995.

VALLE, Marcos Eduardo. Classificação das Equações Diferenciais, Equações

Lineares de Primeira Ordem e Fatores Integrantes. Campinas, 2016. Disponível
em: < https://www.ime.unicamp.br/~valle/Teaching/2016/MA311/Aula1.pdf
>. Acesso em: agosto de 2020.
 108

APÊNDICE - INTRODUÇÃO À PROGRAMAÇÃO EM HTML/JAVASCRIPT

1 INTRODUÇÃO

Novamente, vale destacar que este apêndice foi criado para programadores
leigos e amadores, apenas para fins de aplicação na criação de programas úteis na
área da Engenharia Civil (campo de atuação do autor) e Engenharia Elétrica. Por
isso, pode conter muitas explicações e termos não exatamente corretos, mas que
são suficientes para o desenvolvimento inicial na área citada.
A linguagem HTML é a que já é executada em todos os navegadores de
internet (Internet Explorer, Chrome, Firefox, etc.). Portanto, todo computador já é
capaz de receber programação com esta linguagem.
Inicialmente, não é necessário nenhum programa especial, somente o
BLOCO DE NOTAS do Windows. Outro editor de notas que pode ser usado é o
NOTEPAD++, obtido gratuitamente na internet. Recomenda-se aqui usar o
NOTEPAD++ pela facilidade de entender os códigos, automaticamente coloridos e
organizados. Sendo assim, a partir deste ponto, quando houver referência ao
NOTEPAD++, sabe-se que pode ser usado o BLOCO DE NOTAS.
Para se fazer uma página de internet somente com textos, fotos, etc. somente
para o internauta ler, usa-se HTML. Porém, se for necessário colocar botões e
outros componentes, usa-se uma linguagem (chamada script) que forneça essas
possibilidades. Uma delas é o Javascript.
O site ou programa em HTML/Javascript é então criado no NOTEPAD++ e por
isso somente recebe código em texto, não tendo uma área gráfica para criar
graficamente os componentes (como acontece, por exemplo no LAZARUS). Assim
os componentes são criados também por meio de código de programação.

- Crie um arquivo em branco usando o NOTEPAD++ e salve-o como INDEX.HTML

(por enquanto, não altere este nome de arquivo). Atenção, você deve mudar a
extensão de “.txt” para “.html”. A extensão “.html” é a que vai permitir abri-lo pelo
navegador de internet. Depois que você fecha o arquivo e o reabre, pelo Windows
Explorer com dois cliques, ele já abre no navegador, como uma página de internet
(sem nenhum conteúdo). Para editar o arquivo, não o abra com 2 cliques, mas, com
o NOTEPAD++, pelo botão direito.

A estrutura de um arquivo index.html criado no NOTEPAD++ (tua futura

página inicial da internet) é:

<html>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <!-- PARA CORRETA ACENTUAÇÃO -->
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1" /> <!-- PARA CORRETA ACENTUAÇÃO -->
<title>título que aparece na aba da página</title>
Códigos, inclusive javascript (nesse caso, ele vem entre <script></script>)
</html>

Note que os comentários nos arquivos .html devem aparecer entre “ <!--
COMENTÁRIO -->”.Use “Ctrl+K” para colocar um texto selecionado comentário. Use
“Ctrl+Shift+K” para voltar, ou seja, retirar tirar o código de comentado. Os
comentários são textos livres onde você, programador, pode comentar partes do
código para você mesmo entender posteriormente ou para outro programador que
queira entender o teu código
 109

No teu caso, copie o seguinte:

<html>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <!-- PARA CORRETA ACENTUAÇÃO -->
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1" /> <!-- PARA CORRETA ACENTUAÇÃO -->
<title>PROGRAMAS GRUPO 1</title>
IFSP - ENGENHARIA ELÉTRICA
<br><br>
CÁLCULO NUMÉRICO - PROF. GUSTAVO
<br><br>
INTEGRANTES
<br>
Fulano
<br>
Ciclano
<br>
Beltrano
<br><br>
PROGRAMAS CRIADOS PELO GRUPO 1
<script>
alert("Página em construção");
</script>
</html>

Teste tua página (mesmo offline) abrindo o arquivo no computador (2 cliques

no arquivo index.html)! Deve aparecer o seguinte:
 110

2 SEPARANDO O CÓDIGO EM ARQUIVOS .JS

Você vai perceber que é muito mais organizado separar o código escrito em
javascript em arquivos menores, chamando as funções (function) dentro deles. Você
pode fazer isso salvando os arquivos com a extensão .js, na mesma pasta do
arquivo principal, o index.html.
Para mostrar ao arquivo principal que ele usa outros arquivos, você deve
declarar cada um deles da seguinte maneira (exemplo):

<script src='funcoes.js'></script>

No caso dos códigos em javascript num arquivo .js, você não deve colocar
dentro das tags <script>. Por exemplo, dentro de um arquivo .js, teríamos somente:

alert("Teste!");

Se for escrita no HTML, seria:

<script>
alert("Teste!");
</script>

As funções criadas no arquivo .js têm a seguinte estrutura (exemplo):

function nome_da_funcao() {
código em javasript
}

Para chamar a função, no arquivo html, use:

<script> nome_da_funcao ();</script>

3 CRIANDO O PROGRAMA DA ÁREA DO TRIÂNGULO

Na mesma pasta do index.html, que é a página inicial do teu site, crie,

segundo os passos abaixo, um programa que calcula a área de um triângulo, dada a
base e altura.
Crie os arquivos abaixo, dentro de uma subpasta chamada “AREA-
TRIANGULO”, tentando entender o que cada linha de código faz:
 111

ARQUIVO index.html (altere-o acrescentando o que está em destaque)

<html>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />

(...)

PROGRAMAS CRIADOS PELO GRUPO 1

<br>
<br>
<a href="AREA-TRIANGULO/atriang.html">ÁREA DE TRIÂNGULO</a>
</html>

ARQUIVO atriang.html

<html>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <!-- PARA CORRETA
ACENTUAÇÃO -->
<title>ÁREA DE TRIÂNGULO</title>
<script src='funcoes.js'></script> <!-- DECLARAÇÃO QUE ESTÁ USANDO O ARQUIVO funcoes.js, QUE TEM QUE ESTAR NA MESMA
PASTA DESTE ARQUIVO HTML -->

base:<br> <!-- PULA LINHA -->

<input type="number" id="base" value="30"> <!-- CAIXA DE TEXTO -->
<br>
altura:<br>
<input type="number" id="altura" value="40"> <!-- CAIXA DE TEXTO -->
<br><br>
<button onclick="farea()">ÁREA</button> <!-- BOTÃO QUE CHAMA A FUNÇÃO farea, QUE ESTÁ NO ARQUIVO funcoes.js-->
Área do triângulo = <ins id="darea"></ins> <!-- darea É UMA VARIÁVEL USADA PARA MOSTRAR O RESULTADO -->
</html>

ARQUIVO funcoes.js (arquivo somente com funções javascript, sem HTML)

function farea() { //esta função poderia estar no arquivo html, entre <script></script>
b=document.getElementById("base").value; //lê o número na caixa "base", no arquivo html, e grava em b
b=Number(b); //para garantir que é número
a document.getElementById("altura").value; //lê o número na caixa "altura", no arquivo html, e grava em a
a=Number(a); //para garantir que é número
area=b*a/2
document.getElementById("darea").innerHTML = area; //mostrando a área em "darea", no html
}

*******************************************************************************************
 112

- Execute o index.html, off-line, e teste o programa. Estude-o. A página deve

aparecer assim:

PÁGINA PRINCIPAL ACESSO PELO LINK

O aluno pode usar a página de internet www.w3schools.com como uma

excelente fonte pesquisa e aprendizado sobre HTML e Javascript.
Para publicação do site, você pode usar algum site de hospedagem que
aceite HTML/Javascript. É só mandar os arquivos e pastas exatamente como estão
aqui. Dois exemplos de sites de hospedagem gratuita são: GitHub e UOL.