Sistemas de equações lineares e ajustes de curvas em Python

Prévia do material em texto

Sistemas de equações lineares e ajustes de curvas em
Python
Prof. Francisco Roberto da Rocha Gomes
Descrição
Sistemas de equações lineares e ajuste de curvas, utilizando exemplos na linguagem Python, e métodos
clássicos para solução de sistemas lineares na forma direta e iterativas e interpolação de Lagrange e
Newton.
Propósito
Solução de sistemas lineares e interpolação e ajuste de curvas é essencial para formação de um
profissional que trabalhará com modelagem matemática.
Preparação
Antes de iniciar o estudo deste conteúdo, pesquise e acesse as páginas indicadas para a execução dos
scripts:
a) Python: https://www.python.org/
b) Jupyter: https://jupyter.org/try
c) Google: https:/research.google.com/colaboratory/
Objetivos
Módulo 1
Métodos diretos para resolução de sistemas: Gauss-Jordan e
decomposição LU
Reconhecer os conceitos básicos de métodos diretos e iterativos.
Módulo 2
Métodos iterativos para resolução de sistemas: Gauss-Jacobi e
Gauss-Seidel
Aplicar os recursos do Python na solução de sistemas de equações lineares.
Módulo 3
Interpolação polinomial: Lagrange e Newton
Analisar os principais métodos de interpolação.
Módulo 4
Ajuste de funções: funções polinomiais e linearizáveis
Calcular extrapolações com ajuste de curvas.
O conteúdo a seguir, divididos em quatro módulos, é o mais importante no assunto de modelagem
matemática, pois, a partir de agora, todos os outros métodos utilizarão algum tipo de solução de
sistemas equações lineares, seja por meio de métodos diretos, como a eliminação de Gauss, seja por
Introdução
1 - Métodos diretos para resolução de sistemas: Gauss-
Jordan e decomposição LU
Ao �nal deste módulo, você será capaz de reconhecer os conceitos básicos de métodos
diretos e iterativos.
métodos iterativos, como Gauss-Seidel. Veremos um exemplo disso no modulo de interpolação e de
ajuste de curvas, em que utilizamos métodos de solução de sistemas lineares.
A interpolação, por muito tempo, foi a ferramenta mais utilizada, eram comuns publicações de
diversas tabelas de valores calculados de funções complexas. Para obter um valor que não estava
tabelado, usava-se interpolação. A teoria de interpolação é muito importante para entender outros
métodos de modelagem matemática, como a integração numérica.
Por fim, apresentaremos técnicas de ajuste de curvas, que nos permitem realizar extrapolações, a
partir de dados coletados em experimentos e observações. O ajuste de curvas tem uma ligação
estreita com estatística, tanto que as soluções são estimativas que dependem das observações e do
modelo matemático.
Soluções de sistemas lineares
Solução de sistemas lineares é umas das mais importantes nos métodos numéricos. Para exemplificar os
métodos, usaremos um problema, que será o nosso modelo para apresentar alguns métodos diretos de
resolução de sistemas.
Problema
Suponha que um objeto possa estar em qualquer lugar dos n+1 pontos uniformemente espaçados 
. Quando um objeto se encontra no lugar , ele tem a mesma probabilidade de se mover
para ou para , mas não pode ir diretamente para nenhum outro lugar.
Considere as probabilidades de que um objeto que parte do lugar chegue ao extremo esquerdo 
 antes de alcançar o extremo direito . Dado que o objeto pode mover-se até apenas a partir de 
ou de e o faz com a probabilidade 1/2 para cada um desses lugares:
Rotacione a tela. 
Seja o vetor , a matriz A e o vetor b, tal que Ap = b.
Considere os itens a seguir:
a) Resolva o sistema usando n = 4. 
b) Resolva o sistema usando n = 100. 
Solução do item a:
A chave desse problema é perceber que e que , no caso do item a, , então, fazendo i
= 1, 2 e 3, teremos as seguintes equações:
Rotacione a tela. 
x0, x1, … , xn Xi
Xi+1 Xi−1
{Pi}
n
i=0 Xi
x0 xn Xi Xi−1
Xi+1
2Pi = Pi−1 + Pi+1,  para i = 1, 2, 3, … , n − 1
p = [P1 P2 … . .Pn−1]
⊤
P0 = 1 Pn = 0, P4 = 0
2P1 = P0 + P2
2P2 = P1 + P3
2P3 = P2 + P4
Organizando as equações obtemos o seguinte sistema:
Rotacione a tela. 
Substituindo e e colocando na forma matricial, teremos:
Rotacione a tela. 
Como foi sugerido no problema, chamaremos de A a matriz:
Rotacione a tela. 
E de p e b, respectivamente, os vetores:
Rotacione a tela. 
2P1 − P2 = P0
−P1 + 2P2 − P3 = 0
−P2 + 2P3 = P4
P0 = 1 P4 = 0
=
⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦e⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦
Em nosso problema fica assim:
Rotacione a tela. 
Após criar a matriz aumentada, vamos realizar o escalonamento, que é fazer uma escada na matriz
aumentada e zerar os elementos que se encontram abaixo da escada, conforme a seguir:
Rotacione a tela. 
Para realizar os seguintes passos
1º passo
A primeira linha a ser modificada será a linha 2, então, para zerar o termo -1 devemos multiplicar a linha 1
por um fator m e subtrair na linha 2. No caso do nosso problema, , resultando na seguinte
operação:
Comentário
O principal método que vamos abordar e que será a semente para os outros é a eliminação de
Gauss. O princípio desse método é criar uma matriz que definimos como matriz aumentada do
sistema, [A|b], ou seja, acrescentar uma coluna na matriz A igual ao vetor b.
[A ∨ b] =
⎡⎢⎣ 2 −1 0 1−1 2 −1 00 −1 2 0⎤⎥⎦= ⎡⎢⎣ 2 −1 0 1−1 2 −1 00 −1 2 0⎤⎥⎦m = −1/2Linha(2) = Linha(2) − m × Linha(1)
Rotacione a tela. 
A linha 1 dessa operação é chamada de linha pivô. Não é necessário fazer essa operação na linha 3
utilizando a linha pivô 1, pois já existe um elemento zero. Podemos visualizar o resultado dessa operação na
imagem a seguir:
2º passo
Vamos modificar a terceira linha, e a segunda linha será a nossa linha pivô, logo, semelhante ao 1º passo:
Rotacione a tela. 
Em que m = - 2/3, o que resulta em todos os elementos abaixo da escada iguais a zero, conforme a imagem
a seguir:
3º passo
Vamos observar o sistema de equações após as modificações:
Linha(3) = Linha(3) − m × Linha
(2)
Rotacione a tela. 
Vamos resolver esse sistema usando um método elementar: substituição retroativa . Em nosso caso,
resolvemos a última linha, que é a terceira linha, depois substituímos o valor encontrado na linha anterior,
segunda linha, e por fim, substituímos o segundo valor na primeira linha.
Como mostrado nas equações a seguir:
Rotacione a tela. 
Solução do item b:
Para solucionar o item b, para n = 100, levaremos muito tempo fazendo à mão, logo, precisaremos realizar
um algoritmo do método abordado no item a.
Eliminação de Gauss
Veja agora os principais conceitos citados ao longo deste módulo.
2P1 − P2 = 1
3/2P2 − P3 = 1/2
4/3P3 = 2/6
4/3P3 = 2/6 ⇒ P3 = 1/4 = 0, 25
3/2P2 − 1/4 = 1/2 ⇒ P2 = 1/2 = 0, 5
2P1 − 1/2 = 1 ⇒ P1 = 3/4 = 0, 75

Algoritmo do método de eliminação de Gauss
Método da substituição retroativa
Para começarmos a descrever o algoritmo, iniciaremos pelo final, descreveremos o algoritmo da
substituição retroativa. Note que, após o processo de escalonamento, o sistema linear ficou com esta
aparência:
Rotacione a tela. 
A matriz A transformou-se em uma matriz triangular superior, a qual a batizaremos de U (do inglês up). De
um modo geral, um sistema triangular superior (Ux=c) de ordem 3x3 tem o seguinte formato:
Rotacione a tela. 
Resolvendo-o:
=
⎡⎢⎣2 −1 00 3/2 −10 0 4/3⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣ 11/22/6⎤⎥⎦=⎡⎢⎣U0,0 U0,1 U0,20 U1,1 U1,20 0 U2,2⎤⎥⎦ ⎡⎢⎣x0x1x2⎤⎥⎦⎡⎢⎣c0c1c2⎤⎥⎦c
Rotacione a tela. 
Generalizando para um sistema triangular superior de ordem n:
Rotacione a tela. 
Em Python, definiremos a seguinte função:
Python 
Vamos descrever essa função SubRet(U,c). O primeiro ponto são os parâmetros de entrada, a matriz U e
vetor c, do sistema triangular superior (Ux=c). No Python, para escrever uma matriz e um vetor, usamos o
módulo Numpy, iniciando com import numpy as np.
Escrever uma matriz é semelhante a escrever uma lista, mas usando o comando np.array(lista). Vamos
aplicar como exemplo o problema anterior:
1∘ − x2 =
c2
U2,2
, 2∘ − χ1 =
c1 − U1,2x2
U1,1
e3∘ − χ0 =
c0 − U0,1x1 − U0,2x2
U0,0
xi =
(ci − ∑n−1j=i+1 Ui,jxj)Ui,i
 para i = n − 1,n − 2, … , 1, 0
xi =
(ci − ∑n−1j=i+1 Ui,jxj)
Ui,i
 para i = n − 1,n − 2, … , 1, 0
def SubRet(U,c):
 n=c.size
 x=np.zeros(n)
 for i in reversed(range(n)):
 x[i] = (c[i] -U[i,i+1:]@x[i+1:])/U[i,i]
 return x
1
2
3
4
5
6
Rotacione a tela. 
Teremos U = np.array([[2.,-1.,0.],[0.,3/2,-1.],[0.,0.,4/3]]) e c=np.array([1.,1/2,2/6])
A segunda linha utiliza o comando n=c.size. Isso significa que n receberá o tamanho de c, no nosso
exemplo, n=3, que será a ordem da matriz, 3x3.
O terceiro comando, x=np.zeros(n), cria um vetor de tamanho n, caso 3, com todos os elementos iguais a
zero. Isso é feito para criar o espaço em que serão colocados os valores de x calculados.
A quarta linha é o comando for com a variável i iterando no vetor reversed(range(n)). O comando range cria
uma lista de números inteiros de 0 a n-1, o comando reversed inverte o início e o fim, ou seja, o vetor
começa em n-1 e vai até o 0, como se encontra na fórmula de x.
Por último, a quinta linha do programa, , que é tradução no
Python para a fórmula:
Rotacione a tela. 
Define-se produto escalar de dois vetores, v e u, como: , logo, em Python, v@u resulta
no somatório do produto de cada elemento do vetor v e u.
Na fórmula de x, temos um somatório que multiplica uma linha - i da matriz U, iniciando na coluna j=i+1
como parte do vetor x, que começa em i+1 até o final n-1.
x[i] = (c[i] − U [i, i + 1 : [@x[i + 1 :])/U [i, i]
xi =
(ci − ∑n−1j=i+1 Ui,jxj)
Ui,i
Atenção!
Devemos atentar para o comando @, que faz a multiplicação matricial, ou seja, se temos duas
matrizes A e B, o produto matricial de AB em Python é A@B. Da mesma maneira, quando
queremos realizar o produto escalar de dois vetores v e u.

v ⊙ u = ∑n−1i viui
Resumindo, para resolver o problema:
Rotacione a tela. 
Utilizaremos esta linha de código:
Python 
Como resultado do print(SubRet(U,c)), teremos [0.75 0.5 0.25].
Método de Eliminação de Gauss
Usando os passos já vistos, basicamente multiplicamos por um fator m uma linha k, pivô, e subtraímos das
linhas abaixo da linha pivô , zerando os elementos abaixo do elemento da
diagonal principal da matriz , ou seja, iniciamos com o sistema Ax=b e transformamos no sistema Ux=c
como na formulação a seguir:
=
⎡⎢⎣2 −1 00 3/2 −10 0 4/3⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣ 11/22/6⎤⎥⎦
(k + 1, k + 2, … . n − 1)
Ak,k
( ) ( ) (
import numpy as np
 
 U= np.array([[2.,-1.,0.],[0,3/2,-1],[0,0,4/3]])
 c=np.array([1.0,1/2,2/6])
 
 def SubRet(U,c):
 n=c.size
 x=np.zeros(n)
 for i inreversed(range(n)):
 x[i] = (c[i] -U[i,i+1:]@x[i+1:])/U[i,i]
 return x
 
 print(SubRet(U,c))
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Rotacione a tela. 
Expondo na forma matricial:
Rotacione a tela. 
Essa expressão escrita em Python ficaria da seguinte forma:
Python 
Com isso, podemos definir uma função que realiza a eliminação de Gauss:
Python 
A única diferença nesse algoritmo é o comando U=np.copy(A) e c=np.copy(b).
linh a(i) = linh a(i) − m × linh a(
 pivô ),  onde m =
Ai,k
Ak,k
linha(i) = linha(i) − m × linha(
 pivô ),  onde m =
Ai,k
Ak,k
for k in range(n-1):
 for i in range(k+1,n):
 m = A[i,k]/A[k,k]
 A[i,k:] -= m*A[k,k:]
 b[i] -= m*b[k]
def ElimGauss(A, b):
 U = np.copy(A)
 c = np.copy(b)
 n = c.size
 for j in range(n-1):
 for i in range(j+1,n):
1
2
3
4
5
1
2
3
4
5
6
Para manter o registro dos dados iniciais (A e b), definimos como cópia as matrizes U e b, as quais serão
transformadas e depois utilizaremos o método da substituição retroativa já estudado. O exemplo a seguir
resolve o nosso problema de motivação:
Rotacione a tela. 
Python 
Python 
Método de eliminação de Gauss-Jordan
O método de eliminação de Gauss-Jordan é semelhante ao método de Gauss. Vimos que em Gauss o
sistema original Ax=b é transformado em sistema equivalente Ux=c, em que U é uma matriz triangular
=
⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦import numpy as np A=np.array([[2.,-1.,0.],[-1.,2.,-1.],[0.,-1.,2.]]) b=np.array([1.,0,0]) def ElimGauss(A, b): U =np.copy(A) c = np.copy(b) n = c.size for j inrange(n-1): for i inrange(j+1,n): m = U[i,j]/U[j,j] U[i,j:] -= m*U[j,j:] c[i] -= m*c[j]
x= [0.75 0.5 0.25]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
superior, e usamos a solução de substituição retroativa.
O método de Gauss-Jordan usa os mesmos processos elementares de multiplicação das
linhas pivô e subtração das outras linhas da matriz original A.
A diferença é que, em Gauss-Jordan, fazemos isso em todas as linhas, as que estão abaixo (Gauss) e as que
estão acima, zerando todos os elementos, exceto a da diagonal principal, que será dividida pelo seu próprio
valor para torná-lo igual a 1, transformando-a em uma matriz equivalente, Rx=d. Essa matriz é definida como
a matriz reduzida de A e é igual à matriz identidade, I.
No fim desse método, o vetor d será a solução do sistema. Veremos os passos no sistema do problema
original:
Rotacione a tela. 
1º passo (k=0)
Começaremos na primeira linha e dividiremos toda a linha pelo elemento da diagonal principal, 
, resultando na seguinte matriz:
[A ∨ b] =
⎡⎢⎣ 2 −1 0 1−1 2 −1 00 −1 2 0⎤⎥⎦Atenção!Observe que já foi colocada a matriz aumentada do sistema.A[k, k] = A[0, 0] = 2, ⎡⎢⎣ 1 −1/2 0 1/2−1 2 −1 00 −1 2 0 ⎤⎥⎦
Rotacione a tela. 
Em seguida, vamos subtrair todas as linhas que estão abaixo e acima, mas como é a primeira linha, não
temos acima, logo,
Para 2ª linha e 3ª linha, o fator de multiplicação é , em que i varia de 0 a n-1, com
exceção de k.
Para 2ª linha, , como , então, .
Para 3ª linha, em nosso problema não é necessário, pois ele já é igual a zero. Semelhante à eliminação de
Gauss, faremos:
Rotacione a tela. 
Resultando na seguinte matriz equivalente:
Rotacione a tela. 
2º passo (k=1)
Vamos repetir todo o processo do passo 1.
3º passo (k=3)
Vamos repetir todo o processo do passo 1.
O resultado final é o sistema equivalente, Rx=d:
Rotacione a tela. 
m = A[i, k]/A[k, k]
m = A[1, 0]/A[0, 0] A[0, 0] = 1 m = A[1, 0] = −1
linha(i) = linha(i) − m × linha(k)
⎡⎢⎣1 −1/2 0 1/20 3/2 −1/2 1/20 −1 2 0 ⎤⎥⎦⎡⎢⎣1 0 0 3/40 1 0 1/20 0 1 1/4⎤⎥⎦

A implementação em Python é igual ao algoritmo da eliminação de Gauss, com duas diferenças: devemos
dividir os elementos da diagonal principal por eles mesmos, e a condicional de não realizar a operação
elementar de multiplicar a linha pivô pelo fator m e subtrair na linha pivô, o que fizemos com o comando (if i
!= k);, lembre-se de que != significa diferente em Phyton.
Veja o programa:
Python 
Decomposição LU
A decomposição ou fatoração LU consiste em decompor a matriz A em dois fatores de matrizes, uma
matriz triangular inferior, definida de L (do inglês, low), e o outro fator em uma matriz superior U, com a qual
Atenção!
Note que o vetor d = x, ou seja, a solução do sistema.

import numpy as np
 
 A=np.array([[2.,-1.,0.],[-1.,2.,-1.],[0.,-1.,2.]])
 b=np.array([1.,0,0])
 def GaussJordan(A, b):
 R = np.copy(A)
 d = np.copy(b)
 n = d.size
 for k in range(n):
 d[k]/=R[k,k]
 R[k,:]/=R[k,k] 
 for i in range(n):
 ifi!=k:
 m = R[i,k]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
já trabalhamos. É fácil demonstrar que os elementos da matriz inferior, L, são os multiplicadores m,
utilizados em cada iteração do método da eliminação de Gauss (STRANG, 2005), ou seja, para uma matriz
de ordem 3, teremos:
Rotacione a tela. 
A ideia principal para resolver um sistema Ax=b usando a fatoração LU é a seguinte:
Rotacione a tela. 
Logo, teremos dois sistemas:
1) Sistema de uma matriz triangular superior, para o qual já temos o algoritmo de solução (substituição
retroativa):
Rotacione a tela. 
2) Sistema de uma matriz triangular inferior, para o qual apresentaremos o algoritmo de solução, que
definiremos como substituiçãosucessiva.
=
⎡⎢⎣A0,0 A0,1 A0,2A1,0 A1,1 A1,2A2,0 A2,1 A2,2⎤⎥⎦⎡⎢⎣ 1 0 0L1,0 1 0L2,0 L2,1 1⎤⎥⎦ ⎡⎢⎣U0,0 U0,1 U0,20 U1,1 U1,20 0 U2,2⎤⎥⎦Ax = b → L Uxc = bUx = c
Rotacione a tela. 
Resolvendo-o:
Rotacione a tela. 
Generalizando para um sistema triangular superior de ordem n:
Rotacione a tela. 
Em Python, definiremos a seguinte função:
Python 
Lc = b
=
⎡⎢⎣L0.0 0 0L1,0 L1.1 0L2,0 L2,1 L2.2⎤⎥⎦ ⎡⎢⎣c0c1c2⎤⎥⎦ ⎡⎢⎣b0b1b2⎤⎥⎦1∘ − c0 = b0L0,0 , 2∘ − c1 =b1 − L1,0c0L1,1 e 3∘ − c2 =b2 − L2,0c0 − L2,1c1L2,2ci = (bi − ∑i−1j=0 Li,jcj)Li,i  para i= 0, 1, 2 … ,n − 1
def SubSuc(L,b):
 n=b.size
 c=np.zeros(n)
 for i inrange(n):
 c[i] = (bs[i] -L[i,:i]@c[:i])/L[i,i]
1
2
3
4
5
Para finalizar o algoritmo da decomposição LU, lembre-se de que é o mesmo da eliminação de Gauss, mas a
diferença é que iremos salvar os valores de m:
Python 
E a solução por decomposição LU é dada por:
Python 
Como exemplo, resolveremos o nosso problema original:
=
⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦return cdef Dec_LU(A): n = A.shape[0] U = np.copy(A) L = np.identity(n) for j in range(n-1): for i in range(j+1,n): m = U[i,j]/U[j,j] U[i,j:] -= m*U[j,j:] L[i,j] = m return L, Udef solucao_LU(A,b): L,U = Dec_LU(A) c = SubSuc(L,b) x = SubRet(U,c) return x61234567891012345
Rotacione a tela. 
Python 
Vem que eu te explico!
Os vídeos a seguir abordam os assuntos mais relevantes do conteúdo que você acabou de estudar.
Módulo 1 - Vem que eu te explico!
Métodos diretos para resolução de sistemas: Gauss-Jordan e decomposição LU-I
Módulo 1 - Vem que eu te explico!
Métodos diretos para resolução de sistemas: Gauss-Jordan e decomposição LU-II

import numpy as np
 
 A=np.array([[2.,-1.,0.],[-1.,2.,-1.],[0.,-1.,2.]])
 b=np.array([1.,0,0])
 
 def SubSuc(L,b):
 n=b.size
 c=np.zeros(n)
 for i in range(n):
 c[i] = (b[i] -L[i,:i]@c[:i])/L[i,i]
 return c
 
 def SubRet(U,c):
 n=c.size
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Vamos praticar alguns conceitos?
Falta pouco para atingir seus
objetivos.
Questão 1
O comando em Python: A=np.array([[1,2,3],[4,5,6]]), resulta em.
A um vetor de ordem 1 por 2.
B um vetor de ordem 2 por 1.
C uma matriz 3x3.
D uma matriz 3x2.
E uma matriz 2x3.
Responder
Questão 2
Na decomposição da matriz A= LU, as matrizes L e U são respectivamente
A triangular inferior e triangular superior.
B triangular superior e triangular inferior.
2 - Métodos iterativos para resolução de sistemas:
Gauss-Jacobi e Gauss-Seidel
C diagonal e tridiagonal.
D pentagonal e identidade.
E diagonal e triangular inferior.
Responder

Ao �nal deste módulo, você será capaz de aplicar os recursos do Python na solução de
sistemas de equações lineares.
Considerações iniciais
A solução de sistemas lineares pelos métodos iterativos ou indiretos é geralmente utilizada no ambiente
computacional para evitar locação de memória e reduzir o tempo de processamento, pois os métodos
iterativos não realizam transformação da matriz A, do sistema Ax = b; simplesmente utiliza os próprios
elementos de A para realizar os cálculos, com objetivo de determinar o valor de x.
Como motivação, vamos utilizar o mesmo problema do anterior, para resolvermos o seguinte sistema:
Rotacione a tela. 
Método iterativo
Vamos apresentar como é o processo iterativo, e, para isso, resolveremos uma equação linear do 1º grau
bem simples, utilizando a técnica dos métodos iterativos.
Vamos usar o seguinte exemplo:
Encontrar o valor de x na equação .
É fácil de verificar que resolve o problema, mas vamos solucionar de um modo diferente.
Primeiro, notamos e substituímos na equação:
Rotacione a tela. 
=
⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦5x + 1 = 0x = −1/55x = 4x + x4x + x + 1 = 0 → 4x = −x − 1 → x =−x4 − 14
Chegamos a uma equação em que podemos usar a equação iterativa, ou seja:
Rotacione a tela. 
Colocaremos um chute inicial e realizaremos os cálculos para .
Faremos para n=3:
Rotacione a tela. 
Generalizando para k=n, teremos:
Rotacione a tela. 
Entre parênteses, temos a soma de uma progressão geométrica (PG), cujo valor inicial é 1/4 e a razão é
também -1/4. Suponha que podemos computacionalmente realizar números grandes de n, a ponto de
considerá-lo infinito, ou seja , então, teremos a primeira parcela e a PG, sabemos que a
soma da progressão infinita é dada por:

x =
−x
4
−
1
4
→ xk+1 =
−xk
4
−
1
4
x0 k = 0, 1, 2, … … n
k = n → xn+1 =
−xn
4
−
1
4
=
−x0
4n
− ( 1
4
−
1
42
+
1
43
−
1
44
+ ⋅ ⋅ ⋅ +
(−1)n+1
4n
)
k = n → xn+1 =
−xn
4
−
1
4
=
−x0
4n
−
( 1
4
−
1
42
+
1
43
−
1
44
+ ⋯ +
(−1)n+1
4n
)
k → ∞ −x04n → 0
a0
1 − q ′
Rotacione a tela. 
Em que a0 é o termo inicial e q é a razão da PG, logo:
Rotacione a tela. 
Ou seja, é a resposta da equação.
Quando isso acontece, dizemos que o processo iterativo convergiu.
Agora, vamos resolver o mesmo problema, mas mudaremos um pouco a equação de iteração:
Rotacione a tela. 
Da mesma maneira, fazendo a equação de iteração:
Rotacione a tela. 
Teremos uma PG que não vai convergir e vai tender ao infinito. Nesse caso, observamos que a escolha da
equação de iteração é importante para obter o sucesso da resolução do problema, que é o objetivo deste
módulo: mostrar dois principais métodos iterativos para solução de sistema lineares – Jacobi e Gauss-
Seidel.
No entanto, antes vamos ver como usar uma equação linear para resolver um sistema de equações lineares
na forma matricial e apresentar um algoritmo genérico.
( 1
4
−
1
42
+
1
43
−
1
44
+ ⋯) =
1
4
1 + 14
=
1
5′
x = −1/5
4x + x + 1 = 0 → x = −4x − 1
xk+1 = −4xk − 1 para k = 0, 1, … n
Decomposição da matriz A
Para determinar equações de iteração, fizemos o seguinte algebrismo:
Rotacione a tela. 
Faremos a mesma coisa a matriz A, ou seja, vamos decompô-la em uma subtração de duas matrizes, que
chamaremos de M e N, ou seja:
Rotacione a tela. 
Substituindo essa decomposição no sistema linear , teremos:
Rotacione a tela. 
Multiplicando o vetor x, obteremos:
Rotacione a tela. 
Vamos multiplicar a esquerda da equação pela inversa de M:
5x = 4x + x
A = M − N
Ax = b
Ax = b → (M − N)x = b
Ax = b → (M − N)x = b
M −1Mx = M −1Nx + M −1b → x
= M −1Nx + M −1b
Rotacione a tela. 
Substituindo N por M-A e depois realizando a multiplicação matricial, obteremos:
Rotacione a tela. 
Para finalizar, faremos algumas definições:
A primeira é o vetor resíduo r, que será dado pela equação b-Ax.
A segunda é o vetor passo p, que será dado pela segunda parcela da equação final anterior. Ou seja:
Rotacione a tela. 
Então, a equação de iteração ficaria da seguinte maneira:
Rotacione a tela. 
Em que:
Rotacione a tela. 
O algoritmo ficaria assim:
x = M −1Nx + M −1b → x = M −1(M − A)x + M −1b → x = (I − M −1A)x + M −1b
x = x − M −1Ax + M −1b → x = x + M −1(b − Ax)
r = b − Ax e p = M −1(b − Ax) → p = M −1r → Mp = r logo 
x = x + M −1(b − Ax) → x = x + p
xk+1 = xk + pk
Mpk = rk e rk = b − Axk
1. Determinar um chute inicial x=x0:;
2. Decompor a matriz A = M-N:;
3. Calcular o vetor resíduo r = b -Ax:;
4. Resolver o sistema linear Mp =r e determinar o passo p;
5. Fazer a iteração x=x+p;
6. Verificar um critério de parada, caso não atenda repetir os passos 3, 4 e 5.
Para entender melhor, vamos usar o algoritmo com o problema anterior:
Rotacione a tela. 
Nosso chute inicial será o vetor e escolheremos uma decomposição.
Como temos que resolver um sistema linear na quarta etapa no algoritmo, ou seja, resolver Mp=r,
escolheremos uma matriz M que seja fácil de resolver pelo método direto.
Um sistema muito fácil seria se M fosse igual à matriz identidade, ou seja, elementos iguais a 1 na diagonal
principal e zero em todos os elementos, como mostrado a seguir:
Rotacione a tela. 
Isso facilita muito os cálculos. A seguir, vamos apresentar um programa em Python, que realiza as etapas
=
⎡⎢⎣ 2 −1 0−12 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦x0 = [0, 0, 0]T= −Mpk = rk → pk = rk → pk = rk⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣1 0 00 1 00 0 1⎤⎥⎦ ⎡⎢⎣−1 1 01 −1 10 −1 −1⎤⎥⎦⎡⎢⎣1 0 00 1 00 0 1⎤⎥⎦
do algoritmo, utilizando a matriz M como matriz identidade. Nesse programa, vamos realizar somente três
iterações para observar o comportamento.
Python 
Ao executar o programa, a saída será a seguinte:
Rotacione a tela. 
r = [1.0.0. ]
k = 0
xk = [1.0.0. ]
r = [ ]
k = 1
xk = [0.1.0. ]
r = [2. −2.1. ]
k = 2
xk = [2. −1.1. ]
−1.1. 0.
Atenção!

import numpy as np
 A=np.array([[2.,-1.,0.],[-1.,2.,-1.],[0.,-1.,2.]])
 b=np.array([1.,0,0])
 def sol_Identidade(A,b,x0,kmax):
 #M= identidade
 for k in range(kmax):
 r = b - A@x0
 print('r=',r)
 p = r
 if np.linalg.norm(p) < 1e-2 + 1e-2*np.linalg.norm(x0):
 break
 x0 += p
 print('k=',k)
 print('x_k=',x0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Vamos ver como fica com os dois métodos de Jacobi e Gauss-Seidel.
Método de Jacobi
O método de Jacobi é um caso particular do método da decomposição de matrizes, em que a escolha da
matriz M é feita com a diagonal principal de A, ou seja:
Rotacione a tela. 
Observe que essa escolha também é fácil de resolver o sistema linear Mp=r, pois basta dividir cada
elemento de r[i] pelo emento da matriz diagonal, A[i,i], ou seja:
Rotacione a tela. 
A seguir, teremos o seguinte programa em Python, resolvendo o nosso problema inicial, lembrando que ao
utilizar M como identidade, não convergiu:
Python 
Observe que a resposta se distancia da solução, que sabemos é [0.75 0.5 0.25], ou seja, não vai
convergir. Portanto, a escolha de M como a matriz identidade, embora muito fácil, não é adequada
para esse problema.
=
−
⎡⎢⎣A0,0 A0,1 A0,2A1,0 A1,1 A1,2A2,0 A2,1 A2,2⎤⎥⎦⎡⎢⎣A0,0 0 00 A1,1 00 0 A2,2⎤⎥⎦ ⎡⎢⎣ 0 −A0,1 −A0,2−A1,0 0 −A1,2−A2,0 −A2,1 0 ⎤⎥⎦pk[i] = rk[i]A[i, i]
O resultado ao executar a função sol_Jacobi foi:
Rotacione a tela. 
Valor de x convergiu na primeira iteração.
Método de Gauss-Seidel
O método Gauss-Seidel também é um caso particular do método da decomposição de matrizes, visto
anteriormente, em que a escolha da matriz M é feita com os elementos da triangular inferior de A, ou seja:
r = [0.00000000e + 002. 77555756e − 16 − 2. 22044605e − 16]
p = [0.00000000e + 001.38777878e − 16 − 1.11022302e − 16]
x = [0.750.50.25]
––
––
import numpy as np
 A=np.array([[2.,-1.,0.],[-1.,2.,-1.],[0.,-1.,2.]])
 b=np.array([1.,0,0])
 def sol_Jacobi(A,b,x0,kmax=100):
 #M= diagonal de A
 d =np.diag(A)
 for k in range(kmax):
 r = b - A@x0
 print('r=',r)
 p = r/d #p =r[i]/A[i,i]
 if np.linalg.norm(p) <1e-2 + 1e-2*np.linalg.norm(x0):
 break
 x0 += p
 print('k=',k)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Rotacione a tela. 
Observe que essa escolha também é fácil para resolver o sistema linear Mp=r, pois basta usar o método
substituição sucessiva visto no módulo 1, em decomposição LU.
Rotacione a tela. 
Resolvendo-o:
Rotacione a tela. 
Generalizando para um sistema triangular superior de ordem n:
=
−
⎡⎢⎣A0,0 A0,1 A0,2A1,0 A1,1 A1,2A2,0 A2,1 A2,2⎤⎥⎦⎡⎢⎣A0,0 0 0A1,0 A1,1 0A2,0 A2,1 A2,2⎤⎥⎦ ⎡⎢⎣0 −A0,1 −A0,20 0 −A1,20 0 0 ⎤⎥⎦Mp = r →= ⎡⎢⎣A0,0 0 0A1,0 A1,1 0A2,0 A2,1 A2,2⎤⎥⎦⎡⎢⎣p0p1p2⎤⎥⎦ ⎡⎢⎣r0r1r2⎤⎥⎦1∘ − p0 = r0A0,0 , 2∘ − p1 =r1 − A1,0p0A1,1 e 3∘ − p2 =r2 − A2,0p0 − A2,1p1A2,2
Rotacione a tela. 
A seguir, teremos o programa em Python, resolvendo o nosso problema inicial, lembrando que ao utilizar M
como identidade, não convergiu:
Python 
O resultado ao executar a função sol_GaussSeideil foi:
Rotacione a tela. 
pi =
(ri − ∑i−1j=0 Ai,jpj)
Ai,i
 para i
= 0, 1, 2 … ,n − 1
k = 25
r = [1.49011612e − 087.45058060e − 090.00000000e + 00]
p = [7.4505806e − 097.4505806e − 093.7252903e − 09]
x = [0.749999990.499999990.25]
k = 26
r = [7.4505806e − 093.7252903e − 090.0000000e + 00]
p = [3.72529030e − 093.72529030e − 091.86264515e − 09]
x = [0.750.50.25]
import numpy as np
 
 A=np.array([[2.,-1.,0.],[-1.,2.,-1.],[0.,-1.,2.]])
 b=np.array([1.,0,0])
 
 def SubSuc(L,b):
 n=b.size
 c=np.zeros(n)
 for i in range(n):
 c[i] = (bs[i] -L[i,:i]@c[:i])/L[i,i]
 return c
 
 def sol_Gaussseideil(A,b,x0,kmax=100):
 #M= tridiagonal de A
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Valor de x convergiu na vigésima sexta iteração.
Resolução de Sistemas
Acompanhe agora um exemplo de exercício resolvido, utilizando códigos em Python aplicados às
resoluções de sistemas pelo método de Gauss-Jacobi. Vamos lá!
Vem que eu te explico!
Os vídeos a seguir abordam os assuntos mais relevantes do conteúdo que você acabou de estudar.
Módulo 2 - Vem que eu te explico!
Métodos Iterativos
Módulo 2 - Vem que eu te explico!


Método de Jacobi

Falta pouco para atingir seus
objetivos.
Vamos praticar alguns conceitos?
Questão 1
Usando os métodos iterativos Gauss-Seidel, resolva o sistema linear a seguir e encontre o número de
iterações utilizadas, use como chute inicial x0=[0,0,0,0]. 
=
⎡⎢⎣ 7 1 −1 21 8 0 −2−1 0 4 −12 −2 −1 6 ⎤⎥⎦ ⎡⎢⎣x1x2x3x4⎤⎥⎦ ⎡⎢⎣ 3−54−3⎤⎥⎦A [1,1,1,1] e k=10B [-1,-1,-1,-1] e k=14C [1,-1,1,-1] e k=10D [1,-1,1,-1] e k=14E [1,1,1,1] e k=14
Responder
Questão 2
Usando o método iterativo Jacobi, resolva o sistema linear a seguir e encontre o número de iterações
utilizadas, use como chute inicial x_0=[0,0,0].
=
⎡⎢⎣ 4 −1 1−1 4 −21 −2 4 ⎤⎥⎦ ⎡⎢⎣x1x2x3⎤⎥⎦ ⎡⎢⎣ 12−15 ⎤⎥⎦A [1,1,1] e k=49B [-1,-1,-1] e k=61C [3,1,1,] e k=49D [3,1,1] e k=61E [3,1,1] e k=49
Responder

3 - Interpolação polinomial: Lagrange e Newton
Ao �nal deste módulo, você será capaz de analisar os principais métodos de interpolação.
Considerações iniciais
Um engenheiro recebeu um projeto de instalação de uma rede elétrica em uma rodovia na região norte do
país, e será necessário instalar postes e calcular quantos metros de fios serão utilizados, mas para isso
precisaremos de um levantamento altimétrico do perfil da rodovia.
Um levantamento altimétrico consiste em obter as alturas ao longo de um eixo, no nosso caso, no eixo
principal da rodovia, como ilustra a imagem a seguir:
O engenheiro solicita ao topógrafo mensurar as alturas e fornece uma tabela com os seguintes dados:
Rotacione a tela. 
Vamos ver formas de interpolação polinomiais que ajudarão o engenheiro.
Funções de aproximação
Basicamente, o objetivo do nosso problema é apresentar como aproximar uma função f(x), sendo dado n+1
pontos, (xi,yi), em que i=0,1,2,...n. Pode haver várias razões pelas quais isso precisa ser feito:
Talvez calcular f(x) seja um procedimento complicado, que não pode ser repetido em muitos pontos,
por exemplo, funções integrais ou funções diferenciais.
Talvez f(x) só possa ser medido experimentalmente, que é semelhante ao nosso problema.
Em qualquer caso, o que desejamos obter é o valor de f(x) para algum valor qualquer de x geral, mas só
conhecemos alguns valores selecionados.
x(m) 1 2 3 4 5 6 7
y(m) 1 3 2 4 2 5 4
Comentário
Com esses dados, o engenheiro quer saber qual será a altura (y) quando a distância (x) for igual a
3,5 metros. No entanto, o topógrafo não mensurou essa distância, então, uma solução é fazer uma
interpolação para obter o desejado.


Normalmente, é escolhida uma base de n funções e combina-se linearmente com um conjunto de 
parâmetros indeterminados usado para produzir a seguinte forma linear:
Rotacione a tela. 
Em que
é denotado por função de aproximação.
Existem duas classes de funções de aproximações, que apresentamos a seguir: 
• Interpolação. 
• Ajuste de curvas.
Neste módulo, veremos a interpolação e no módulo seguinte, o ajuste de curvas.
Interpolação
A interpolação surge quando temos como entrada uma tabela de pontos de dados, para 
, que assumimos representar exatamente a função f(x).
Vamos considerar as funções básicas como dadas e tentar determinar os n parâmetros . Temos n
incógnitas e n pontos de dados,então, podemos determinar todas as incógnitas, exigindo que nossa função
de aproximação passe exatamente pelos pontos de dados de entrada, ou seja:
Rotacione a tela. 
Em que . Então, podemos reescrever da forma matricial:
φk(x)  n 
ck(k = 0, 1, … ,N − 1)
(xi, yi)
p(x)
(xj, yj)
j = 0, 1, ⋯ ,n − 1
φk(x) ck
p(x)
yj = ∑ ckφk (xj)
p (xj) = yj
Rotacione a tela. 
Agora, temos o seguinte problema: a escolha de . E seguiremos com a escolha da função
interpoladora.
Base Monomial
A primeira opção é escolher como base do subespaço vetorial de funções os monômios:
Rotacione a tela. 
A seguir, apresentaremos um programa em Python que gera uma figura com um exemplo dessa base de
funções de monômios em um domínio dos conjuntos dos Reais entre -1 e 1.
Python 
=
⎡⎢⎣ φ0 (x0) φ1 (x0) φ2 (x0) … φn−1 (x0)φ0 (x1) φ1 (x1) φ2 (x1) … φn−1 (x1)φ0 (x2) φ1 (x2) φ2 (x2) … φn−1 (x2)⋮ ⋮ ⋮ ⋱ ⋮φ0 (xn−1) φ1 (xn−1) φ2 (xn−1) … φn−1 (xn−1)⎤⎥⎦ ⎡⎢⎣ c0c1c2⋮cn−1⎤⎥⎦ ⎡⎢⎣ y0y1y2⋮yn−1⎤⎥⎦φk (xj)φk(x) = xk
import numpy as np
 import matplotlib.pyplot as plt
 x=np.arange(-1.0,1.1,0.1)
 n=6#grau do monomio n-1
 m =len(x)
 phik=np.zeros((m,n))
 tipos=["k-","b-","g-","r-","y-","m-"]
 legenda=[]
 for i in range(n):
1
2
3
4
5
6
7
8
9
Cujo resultado é a imagem a seguir:
Logo, podemos escrever o polinômio interpolador como:
Rotacione a tela. 
Lembre-se de que a entrada para o problema de interpolação são os pontos para 
, dessa maneira:
Rotacione a tela. 
Assim, o nosso problema se resume em encontrar os coeficientes , ou seja, resolvendo o sistema linear:
p(x) = ∑ ckφk(x) = c0 + c1x + c2
x2 + c3x
3 + ⋯ + cn−1x
n−1
(xj, yj)
j = 0, 1, 2, ⋯ ,n − 1
p (xj) = yj = c0 + c1x
2
j + c3x
3
j + ⋯
+ cn−1xn−1j
cj
 legenda.append('$\phi_{'+str(i)+"}$")
 plt.style.use("seaborn-poster")
 fig = plt.figure(figsize = (10,8))
 for k in range(n):
 phik[:,k] = x**k
10
11
12
13
14
Rotacione a tela. 
Vejamos como exemplo o problema do nosso engenheiro de obter a elevação quando x=3,5, com as
observações do topógrafo:
Rotacione a tela. 
=
⎡⎢⎣1 x0 x20 ⋯ xn−101 x1 x21 ⋯ xn−111 x2 x22 ⋯ xn−12⋮ ⋮ ⋮ ⋱ ⋮1 xn−1 x2n−1 ⋯ xn−1n−1⎤⎥⎦⎡⎢⎣ c0c1c2⋮cn−1⎤⎥⎦ ⎡⎢⎣ y0y1y2⋮yn−1⎤⎥⎦ComentárioObserve que a matriz do sistema acima é bem conhecida na Matemática, é a matriz deVandermonde e o determinante dessa matriz sempre é diferente de zero, isto é, o sistema possuiuma única solução.
x(m) 1 2 3 4 5 6 7
y(m) 1 3 2 4 2 5 4
Realizando o seguinte programa em Python:
Python 
Ao executar o programa, teremos a seguinte saída:
>>coeficientes de p é [-1.15000000e+02 2.65150000e+02 -2.22933333e+02 9.12708333e+01
-1.94791667e+01 2.07916667e+00 -8.75000000e-02]
>>o valor da elevação para x=3,5 é igual a p(3.5)= 3.405273437500057
E o gráfico do polinômio interpolador é:
Vamos destacar algumas linhas do programa.
Logo no início, encontramos a linha import numpy.polynomial.polynomial as poly, a qual informa que
usaremos os métodos do numpy, que trabalha com polinômios, e vamos “apelidá-lo” de poly.
Basicamente, se queremos trabalhar com um polinômio:
import numpy as np
 import numpy.polynomial.polynomial as poly
 import matplotlib.pyplot as plt
 
 def SubRet(U,c):
 n=c.size
 x=np.zeros(n)
 for i in reversed(range(n)):
 x[i] = (c[i] -U[i,i+1:]@x[i+1:])/U[i,i]
 return x
 
 def ElimGauss(A, b):
 U = np.copy(A)
 c = np.copy(b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Rotacione a tela. 
Basta obter um array dos coeficientes, e para trabalhar com o
polinômio, escrevemos a seguinte linha de comando p =poly.Polynomial(coef), como foi feito na
antepenúltima linha do script anterior. Depois, para determinar o valor de p(x) quando x=3,5, é só escrever
p(3.5), como foi colado no comando print na penúltima linha.
Outra linha que vamos destacar é a linha: A=np.vander(x, increasing=True). Esse comando cria uma matriz
de Vandermonde dado o array x, que é a entrada da função monômio (x,y) criada.
Método de Lagrange
A ideia principal da interpolação é descobrir um polinômio de grau n tal que , em que 
, e essa premissa será respeitada no método de Lagrange.
Para fazer distinção do método a ser empregado, vamos definir o polinômio obtido pelo método de
Lagrange por , em que N é o grau do polinômio.
O método de Lagrange consiste em obter o polinômio interpolador sem ser necessário resolver um sistema
linear. Seguindo a ideia principal , então, a fórmula de Lagrange é dada por:
p(x) = c0 + c1x + c2x
2 + c3x
3 + ⋯
+ cn−1x
n−1
 coef  =  np.  array ([c0, c1, … , cn−1])
Comentário
Pronto, poderíamos parar por aqui, pois o problema encontra-se resolvido, mas
computacionalmente, a solução encontra um problema: a solução do sistema linear pode
apresentar dificuldades, logo, existem outras técnicas nas quais não é necessário resolver um
sistema linear.

p (xm) = ym
m = 0, 1, …n
ln
ln (xm) = ym
ln(x) = ∑ ymLn,m(x)
Rotacione a tela. 
Em que definiremos como polinômios de Lagrange básicos e eles têm a seguinte propriedade:
Rotacione a tela. 
Dada por:
Rotacione a tela. 
Expandindo a fórmula, o polinômio é escrito da seguinte maneira:
Rotacione a tela. 
Vamos fazer o seguinte exemplo.
Dados os pontos (-1,15), (0,8) e (3,-1), calcule o polinômio interpolador pelo método de Lagrange:
Primeiramente, observe que possuímos três pontos, logo n=2, assim, o polinômio na forma de Lagrange é
dado por:
Ln,m
Ln,m = {
1  quando  x = xm
0  quando  x ≠ xm
Ln,m(x) =
Π (x − xk)
Π (xm − xk)
ln(x) = y0
(x − x1) (x − x2) ⋯ (x − xn)
(x0 − x1) (x0 − x2) ⋯ (x0 − xn)
+ y1
(x − x0) (x − x2) ⋯ (x − xn)
(x1 − x0) (x1 − x2) ⋯ (x1 − xn)
+ ⋯
+ ⋯ + yn
(x − x0) (x − x1) ⋯ (x − xn−1)
(xn − x0) (xn − x1) ⋯ (xn − xN−1)
l2(x) = ∑ ykL2,k(x)
( )
Rotacione a tela. 
Temos os seguintes polinômios básicos:
Rotacione a tela. 
Fazendo , teremos:
Rotacione a tela. 
Desenvolvendo a expressão, chegaremos no seguinte resultado:
Rotacione a tela. 
Apresentaremos a seguir um programa em Python, que nos retorna um vetor, l, em que os valores são os
coeficientes do polinômio de grau n, , e uma matriz, L, em que cada linha possui os valores dos
coeficientes dos polinômios básicos de Lagrange :
Python 
lm(x),m = 0, 1, 2.
L2,0(x) =
(x − x1) (x − x2)
(x0 − x1) (x0 − x2)
=
(x − 0)(x − 3)
(−1 − 0)(−1 − 3)
=
x2 − 3x
4
L2,1(x) =
(x − x0) (x − x2)
(x1 − x0) (x1 − x2)
=
(x + 1)(x − 3)
(0 + 1)(0 − 3)
=
x2 − 2x − 3
−3
L2,2(x) =
(x − x0) (x − x1)
(x2 − x0) (x2 − x1)
=
(x + 1)(x − 0)
(3 + 1)(3 − 0)
=
x2 + x
12
l2(x) = ∑ ykL2,k(x)
l2(x) = y0L0 + y1L1 + y2L2
⋯ = (15)
x2 − 3x
4
+ (8)
x2 − 2x − 3
−3
+ (−1)
x2 + x
12
l2(x) = 8 − 6x + x2
ln
Ln,m
Executando os seguintes comandos, utilizando os dados do exemplo, obtemos os resultados l_2 = [8. -6. 1.],
que são os coeficientes do polinômio obtido, .
Python 
Resultando na seguinte saída:
Terminal 
A seguir, apresentaremos o método de Newton para obter o mesmo resultado.
l2(x) = 8 − 6x + x2
import pandas as pd
 import numpy as np
 import numpy.polynomial.polynomial as poly
 def lagrange_ln(x,y):
 n=len(x) # grau do polinomio n-1
 l=np.zeros(n)
 L = np.zeros((n,n))
 for m in range(n):
 P=[1]
 for k in range(n):
 if k != m:
 P = poly.polymul(P,[ -x[k],1])/(x[m] -x[k])
 L[m,:] = P
 l += y[m]*P
x = [-1, 0, 3]
 y = [15, 8,-1]
 l,L=lagrange_ln(x,y)
 
 Tabela=pd.DataFrame(L)
 print('l_2 =',l)
l_2 = [ 8. -6. 1.]
 L=
 0 1 2
 0 -0.0 -0.750000 0.250000
 1 1.0 0.666667 -0.333333
 2 0.0 0.083333 0.083333
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
1
2
3
4
5
6
Método de Newton
Para entender o método de Newton, primeiramente, precisamos de algumas definições:
Polinômio nodal.
Forma de Newton.
Polinômios nodais
Os polinômios nodais são definidos por e dados pela seguinte expressão:
Rotacione a tela. 
Em que é fornecido um conjunto de pontos, que também são chamados de nós, .
Vamos ver um exemplo.Determine os polinômios nodais do seguinte conjunto de nós: -1.0, 0.5,0.0,0.5,1.0 e, com um programa em
Python, construa os respectivos gráficos.
Solução:
Como podemos ver temos 5 nós, logo, pela definição, teremos os seguintes polinômios nodais:
Rotacione a tela. 
Para construir os gráficos, teremos o seguinte programa em Python:

πi(x)
πi(x) = ∏ (x − xj)
n + 1 x0,x1,x2, … ,xn
π0 = 1
π1 = x − x0 = x − (−1) = x + 1
π2 = (x − x0) (x − x1) = (x + 1)(x + 0.5)
π3 = (x − x0) (x − x1) (x − x2) = (x + 1)(x + 0.5)(x − 0)
π4 = (x − x0) (x − x1) (x − x2) (x − x3) = (x + 1)(x + 0.5)(x − 0)(x − 0.5)
π5 = (x − x0) (x − x1) (x − x2) (x − x3) (x − x5)
= (x + 1)(x + 0.5)(x − 0)(x − 0.5)(x − 1)
Python 
Ao executar o script, teremos o seguinte resultado:
Forma de Newton
A forma de Newton é basicamente uma forma de rescrever um polinômio:
Rotacione a tela. 
Ou seja, essa forma é uma combinação linear dos polinômio nodais, em que são conhecidos os nós . Por
questões didáticas, chamaremos esse polinômio escrito na forma de Newton de , portanto, teremos a
seguinte expressão:
p(x) = c0 + c1x + c2x
2 + c3x
3 + ⋯
+ cn−1x
n−1
xj
nN
import numpy as np
 import numpy.polynomial.polynomial as poly
 import matplotlib.pyplot as plt
 x=np.arange(-1.0,1.01,0.01)
 x_no=[-1.,-0.5,0,0.5,1]
 n=len(x_no) #grau do monomio n-1
 #=======================================================
 #configuração dos gráficos
 #=======================================================
 tipos=["k-","b-","g-","r-","y-","m-"]
 legenda=[]
 for i in range(n+1):
 legenda.append('$\pi_{'+str(i)+'}$')
 plt.style.use("seaborn-poster")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Rotacione a tela. 
Então, o método de Newton para interpolação é:
Dado pontos , encontrar:
Rotacione a tela. 
Sendo que o problema busca determinar os coeficientes logicamente, respeitando a
condição primordial da interpolação:
Rotacione a tela. 
Vamos seguir os seguintes passos para determinar os coeficientes :
1) Para os pontos :
Rotacione a tela. 
2) Para :
nN(x) = ∑ aiπi(x)
N + 1 (x0, y0), (x1, y1), (xN , yN)
nN(x) = a0 + a1 (x − x0) + a2
(x − x0) (x − x1) + ⋯ + aN (x − x0)
(x − x1) ⋯ (x − xN−1)
a0, a1, a2, ⋯ , aNe
nN (xj) = yj
ai as 
(x0, y0)
nN (x0) = a0 = y0
(x1, y1)
nN (x1) = a0 + a1 (x1 − x0) = y1
Rotacione a tela. 
3) Para (x_2,y_2):
Rotacione a tela. 
Desenvolvendo:
Rotacione a tela. 
4) Para o terceiro ponto :
Rotacione a tela. 
Da mesma forma, obtemos:
Rotacione a tela. 
Generalizando e definindo diferenças divididas:
a1 =
y1 − y0
x1 − x0
nN (x2) = a0 + a1 (x2 − x0) + a2
(x2 − x0) (x2 − x1) = y2
a2 =
y2−y1
x2−x1
− y1−y0x1−x0
x2 − x0
(x3, y3)
nN (x2) = a0 + a1 (x3 − x0) + a2 (x3 − x0) (x3 − x1) + a3 (x3 − x0) (x3 − x1) (x3 − x2)
= y3
a3 =
y3−y2
x3−x2
−
y2−y1
x2−x1
x3−x1
−
y2−y1
x2−x1
−
y1−y0
x1−x0
x2−x0
x3 − x0
Rotacione a tela. 
Continuando e generalizando:
Rotacione a tela. 
Podemos visualizar esses valores em uma tabela das diferenças divididas (DD):
Rotacione a tela. 
Para exemplificar, vamos retornar ao problema do nosso engenheiro para obter a elevação quando x=3,5,
com as observações do topógrafo:
Rotacione a tela. 
f [x1,x0] =
y1 − y0
x1 − x0
f [x0,x1,x2] =
y2−y1
x2−x1
− y1−y0x1−x0
x2 − x0
=
f [x2,x1] − f [x1,x0]
x2 − x0
f [xk,xk−1, ⋯ ,x1,x0] =
f [xk,xk−1, ⋯ ,x2,x1] − f [xk−1, ⋯ ,x1,x0]
xk − x0
xk yk D
2f D3f D4f D5f
x0 y0 f [x1,x0] f [x2,x1,x0] f [x3,x2,x1,x0] f [x4,x3,x2,x1,x0]
x1 y1 f [x2,x1] f [x3,x2,x1] f [x4,x3,x2,x1] 0
x2 y2 f [x3,x2] f [x4,x3,x2] 0 0
x3 y3 f [x4,x3] 0 0 0
x4 y4 0 0 0 0
x(m) 1 2 3 4 5 6 7
y(m) 1 3 2 4 2 5 4
Em Python, vamos executar o seguinte algoritmo:
Python 
Ao executar o script, obteremos os seguintes resultados:
>>coeficientes de n na forma de newton é [ 1. 2. -1.5 1. -0.54166667 0.24166667 -0.0875 ] 
1 1.0 2.0 -1.5 1.000000 -0.541667 0.241667 -0.0875 
2 3.0 -1.0 1.5 -1.166667 0.666667 -0.283333 0.0000 
3 2.0 2.0 -2.0 1.500000 -0.750000 0.000000 0.0000 
4 4.0 -2.0 2.5 -1.500000 0.000000 0.000000 0.0000 
5 2.0 3.0 -2.0 0.000000 0.000000 0.000000 0.0000 
6 5.0 -1.0 0.0 0.000000 0.000000 0.000000 0.0000 
7 4.0 0.0 0.0 0.000000 0.000000 0.000000 0.0000 
import numpy as np
 import numpy.polynomial.polynomial as poly
 import matplotlib.pyplot as plt
 import pandas as pd
 
 def n_newton(x,y):
 """
 n e DD
 """
 N = len(y)
 DD = np.zeros([N, N])
 # A primeira coluna é y
 DD[:,0] = y
 for j in range(1,N):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>o valor da elevação para x=3,5 é igual a n_6(3.5)= 3.4052734374995026 
Rotacione a tela. 
E o seguinte gráfico:
Cada método tem um diferencial. Veja quais são eles:
Método com base monomial
Este método necessita de uma solução de sistemas lineares, o que não é adequado quando a
quantidade de pontos é grande.
Método de Lagrange
Este método não necessita resolver um sistema linear, no entanto, caso queira acrescentar um
ponto, devemos repetir todo o cálculo, o que não ocorre com o método de Newton.
Comentário
Observe que é o mesmo resultado da primeira solução e ao usarmos o método de Lagrange
também obteremos a mesma resposta, a diferença dos métodos está nas particularidades.

Método de Newton
Este método tem uma vantagem: a de acrescentar um ponto no conjunto dado e, assim, aproveitar
o resultado obtido.
Interpolação de Lagrange e Newton
Acompanhe um exemplo de exercício resolvido, utilizando códigos em Python aplicados às interpolações de
Lagrange e Newton. Vamos lá!
Vem que eu te explico!
Os vídeos a seguir abordam os assuntos mais relevantes do conteúdo que você acabou de estudar.
Módulo 3 - Vem que eu te explico!


Método de Lagrange
Módulo 3 - Vem que eu te explico!
Método de Newton

Falta pouco para atingir seus
Vamos praticar alguns conceitos?
objetivos.
Questão 1
Um conjunto de pontos possui 6 coordenadas (x,y), logo, por interpolação, o grau do polinômio
interpolador é
A 7.
B 6.
C 5.
D 4.
E 3.
Responder
Questão 2
Em uma interpolação linear são necessários quantos pontos (coordenadas)?
A 5
B 4
C 3
D 2
E 1
Responder

4 - Ajuste de funções: funções polinomiais e
linearizáveis
Ao �nal deste módulo, você será capaz de calcular extrapolações com ajuste de curvas.
Considerações iniciais
Durante uma pandemia de um vírus X, foi observado um número de pessoas contagiadas durante 7 meses,
como mostra o gráfico a seguir:
Ao observar a tabela a seguir com os valores:
Rotacione a tela. 
Vamos apresentar formas de ajustes de polinômios e de outros tipos de funções que nos ajudarão a
resolver esse problema.
Dados numéricos tabelados
Qualquer observação experimental, seja na engenharia ou em uma pesquisa social, produz uma massa de
dados. Existem diversos métodos de processar esses dados, vamos abordar um exemplo simples de dados
numéricos tabelados:
Rotacione a tela. 
O primeiro problema de ajuste de curva é determinar a reta que mais se ajusta aos pares ordenados 
.
Um exemplo seria determinar o menor erro total absoluto, ou seja, .
x(m) 1 2 3 4 5 6 7
y(m) 1 3 2 4 2 5 4
Comentário
Deseja-se estimar o número de contágio no oitavo mês e se há tendência de queda. A solução é
fazer um ajuste de curvas para obter o desejado.

x y
x0 y0
x1 y1
x2 y2
⋮ ⋮
xm ym
m + 1
(xi, yi)
ϕ(a, b) = ∑ |axi + b − yi|
Na prática, é mais comum resolver a seguinte função: . Esse problema é
conhecido como aproximação , ou método dos mínimos quadrados (MMQ), cuja solução é a mais usada,
pois encontra-se alinhada com a distribuição normal.
As normas e são formas específicas de medida de distâncias no espaço vetorial. Uma forma geral é
definindo a norma , dada por:
Para o vetor . Para determinar o mínimo, basta fazer a condição, vista em cálculo:
Rotacione a tela. 
Outra forma de resolver é a interpretação geométrica do problema, em que, por exemplo, para 7 pontos,
teremos 7 equações e poderemos escrever na forma matricial 
, emque:
Comentário
A função tem como variáveis e , e devemos assumir o menor valor possível. Essa solução é
conhecida como aproximação e pode ser resolvida com técnicas de programação linear.

ϕ a b
l1
ϕ(a, b) = ∑ (axi + b − yi)
2
l2
l1 l2
−p ou lp
∥v∥p = {∑ |vpi |}
1
p
1 < p < ∞
v = [v0, v1, v2, ⋯ , vn]
T
∂ϕ
∂a
= 0 e
∂ϕ
∂b
= 0
yi = axi + b para i = 1, 2, 3, 4, 5, 6e7
Ax = b
Rotacione a tela. 
Solução é dada pela equação normal: , que corresponde à solução de minimizar a norma de 
.
Vamos resolver o problema inicial e fazer o ajuste dos dados para uma reta, então, montando a matriz do
sistema , teremos:
Rotacione a tela. 
Implementando a solução em Python e visualizando o gráfico:
Python 
[ ] =
⎡⎢x1 1x2 1x3 1x4 1⎤⎥ ab ⎡⎢y1y2y3y4⎤⎥ATAx = ATy∥y − Ax∥22Ax = b [ ] =⎡⎢⎣1 12 13 14 15 16 17 1⎤⎥⎦ ab ⎡⎢⎣1324254⎤⎥⎦import numpy as np import matplotlib.pyplot as plt import numpy.polynomial.polynomial as poly #solução do sistema linear pelo método de Eliminação de Gauss def SubRet(U,c): n=c.size x=np.zeros(n) for i in reversed(range(n)): x[i] = (c[i] -U[i,i+1:]@x[i+1:])/U[i,i] return x def ElimGauss(A, b): U = np.copy(A)
 c = np.copy(b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
O gráfico obtido do ajuste é:
Observando no gráfico a pandemia do vírus X, há uma tendência de crescimento e para uma estimativa do
oitavo mês, basta colocar no scritp o comando np.plolyval(p,8) dessa maneira:
print('valor de contaminados no oitavo mês é',round(np.polyval(p,8))), ao executar 
>>valor de contaminados no oitavo mês é 5.
Rotacione a tela. 
A seguir, vamos apresentar o ajuste polinomiais.
Ajustes de funções polinomiais
O ajuste surge quando temos como entrada uma tabela de pontos de dados, para 
, que assumimos querer determinar uma função polinomial mais próxima dos
dados, considerando uma ordem do polinômio .
Vamos considerar as funções básicas como dadas e tentar determinar os n parâmetros .
Podemos determinar todas as incógnitas parâmetros exigindo que nossa função de aproximação 
(xj, yj)
j = 0, 1, ⋯ ,n − 1 f(x)
m < n
φk(x) Ck
Atenção!
Observe que temos m incógnitas e n pontos de dados, logo, possuímos um sistema sobre
determinação, ou seja, temos mais equações que incógnitas.

p(x)
passe exatamente pelos pontos de dados de entrada, isto é:
Rotacione a tela. 
Em que . Podemos reescrever da forma matricial:
Rotacione a tela. 
Semelhante à interpolação, escolheremos , com uma diferença que a matriz do sistema não
será quadrada, pois terá mais equações do que parâmetros.
No programa a seguir resolveremos o nosso problema da pandemia, com uma diferença, além de
apresentar a função Ajuste_poli(x,y,n), em que x e y são vetores de entrada dos dados observados e n a
ordem do polinômio que desejamos ajustar, exibiremos um gráfico com diferentes ordens de polinômios:
ordem impares, 1,3,5 e 7 da forma 2k-1.
Python 
yj = ∑ ckφk (xj)
p (xj) ≈ yj
=
⎡⎢⎣ φ0 (x0) φ1 (x0) φ2 (x0) ⋯ φm (x0)φ0 (x1) φ1 (x1) φ2 (x1) ⋯ φm (x1)φ0 (x2) φ1 (x2) φ2 (x2) ⋯ φm (x2)⋮ ⋮ ⋮ ⋱ ⋮φ0 (xn−1) φ1 (xn−1) φ2 (xn−1) ⋯ φm (xn−1)⎤⎥⎦ ⎡⎢⎣ c0c1c2⋮cn−1⎤⎥⎦ ⎡⎢⎣ y0y1y2⋮yn−1⎤⎥⎦φk (xj) = xkjimport numpy as np import matplotlib.pyplot as plt import numpy.polynomial.polynomial as poly #solução do sistema linear pelo método de Eliminação de Gauss def SubRet(U,c): n=c.size x=np.zeros(n) for i in reversed(range(n)): x[i] = (c[i] -U[i,i+1:]@x[i+1:])/U[i,i]
 return x
1
2
3
4
5
6
7
8
9
10
Observando o resultado a seguir, podemos pontuar algumas análises do gráfico:
Para os polinômios de ordem 1, já tínhamos feito, que é o ajuste linear e observamos a tendência do
aumento.
O polinômio de ordem 3 também demonstra a tendência de crescimento.
Para os polinômios de ordem 5 e 7, a pandemia acaba no oitavo mês.
Para resolver tal problema, é necessário ir para o campo da estatística, que nos fornecerá a resposta se o
modelo matemático adotado possui aderência com as observações.
A seguir, vamos exemplificar um modelo matemático que não é polinomial, no entanto, contínua linear.
Funções não polinomiais
Às vezes, na procura de uma modelagem matemática adequada para descrever algum fenômeno natural, as
Comentário
Esse é um dos problemas do ajuste de funções; como estamos fazendo uma extrapolação, os
resultados dependem do modelo matemático que estamos adotando.

 
 def ElimGauss(A, b):
 U = np.copy(A)
11
12
13
14
funções polinomiais não apresentam uma boa resposta.
Dentro da ciência, é comum os dados terem semelhanças com funções
trigonométricas, devido à periodicidade, ou com funções exponenciais e
logarítmicas, por causa do crescimento.
Vamos supor que um cientista quisesse combinar essas características em um único modelo matemático,
por exemplo, .
Então, queremos ajustar a função com os dados da pandemia dada no problema inicial:
Rotacione a tela. 
Pelo MMQ, o problema reside em encontrar o mínimo da função:
Rotacione a tela. 
Ou seja, fazendo:
Rotacione a tela. 
Resultando na equação normal: , que é um sistema linear.
A seguir, apresentaremos uma implementação em Python que resolve esse problema, mas antes vamos ver
como é o sistema , para entender como resolver a equação normal.
f(x) = m1 log(x) + m2 cos(x) + m3ex
f(x)
x (mês)  1 2 3 4 5 6 7
y (contágio)  1 3 2 4 2 5 4
ϕ (m1,m2,m3) = ∑
(yi − (m1 log (xi) + m2 cos (xi) + m3exi))
2
∂ϕ
∂m1
= 0;
∂ϕ
∂m2
= 0;
∂ϕ
∂m3
= 0
ATAm = ATy
Ax = b
Primeiro, devemos notar que cada linha da matriz A tem esse formato:
Rotacione a tela. 
Portanto, o sistema é:
Rotacione a tela. 
Em Python:
Python 
m1 log (xj) + m2 cos (xj) + m3exj
= yj
=
⎡⎢⎣log(1) cos(1) e1log(2) cos(2) e2log(3) cos(3) e3log(4) cos(4) e4log(5) cos(5) e5log(6) cos(6) e6log(7) cos(7) e7⎤⎥⎦⎡⎢⎣m1m2m3⎤⎥⎦⎡⎢⎣1324254⎤⎥⎦import numpy as np import matplotlib.pyplot as plt import numpy.polynomial.polynomial as poly #solução do sistema linear pelo método de Eliminação de Gauss def SubRet(U,c): n=c.size123456
Pelo gráfico gerado, observamos uma queda na pandemia:
Funções linearizáveis
Vamos trabalhar com outros tipos de modelos matemáticos, classificados de não lineares. Essa
classificação é obtida quando fazemos as derivadas parciais e montamos o sistema de equações ;
a matriz A contém os parâmetros ou os coeficientes que queremos determinar, tornando-o um sistema não
linear.
Vamos ver uma função geral não linear, classificada como ajuste não linear, que normalmente aparece nos
modelos matemáticos e mostraremos como linearizá-la.
Ax = b
Comentário
Um sistema não linear possui técnicas para ser resolvido e parte do princípio de linearizá-lo, mas o
que vamos apresentar aqui é um pouco diferente, pois não vamos trabalhar na linearização do
sistema, e sim na linearização da função.

 x=np.zeros(n)
 for i in reversed(range(n)):
 x[i] = (c[i] -U[i,i+1:]@x[i+1:])/U[i,i]
 return x
 
 def ElimGauss(A, b):
 U = np.copy(A)
7
8
9
10
11
12
13
O formato da função é:
Rotacione a tela. 
Em que são parâmetros que queremos determinar.
Observe que é difícil isolar o parâmetro , pois ele se encontra no expoente da função
neperiana.
Uma maneira possível de linearizar é usar as propriedades da função logaritmo, em que temos uma função 
 e aplicamos em ambos os lados:
Rotacione a tela. 
Portanto, aplicando obteremos:
f(x) = m0 (1 + em1x)
m0 e m1
m1
g(x) = a1c
d1
1 c
d2
2 c
d3
3 … c
dk
k logb
logb(g(x)) = logb(a1) + d1 logb(c1
) + d2 logb(c2) + d3 logb(c3) + ⋅ ⋅ ⋅ +
dk logb(ck)
Atenção!
No módulo numpy, a função log é de base e, ou seja, , embora o número neperiano e seja
omitido, a partir de agora, usaremos a função , como o numpy trabalha.

loge
log
log(f(x))
log(f(x)) = log (m0) + m1x
Rotacione a tela. 
Fazendo , teremos:
Rotacione a tela. 
Chegamos em uma função linear. Para exemplificar, vamos apresentar um programa em Python que
determina os parâmetros e da função não linear :
Python 
m′0 = log (m0) e  log(f(x)) = y
′
y′ = m0
′ + m1xm0 m1 f(x)

import numpy as np
 import matplotlib.pyplot as plt
 import numpy.polynomial.polynomial as poly
 #solução do sistema linear pelo método de Eliminação de Gauss
 def SubRet(U,c):
 n=c.size
 x=np.zeros(n)
 for i in reversed(range(n)):
 x[i] = (c[i] -U[i,i+1:]@x[i+1:])/U[i,i]
 return x
 def ElimGauss(A, b):
 U = np.copy(A)
 c = np.copy(b)
 n = c.size
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Funções polinomiais
Acompanhe agora um exemplo de exercício resolvido, utilizando códigos em Python aplicados às funções
polinomiais. Vamos lá!
Vem que eu te explico!
Os vídeos a seguir abordam os assuntos mais relevantes do conteúdo que você acabou de estudar.
Módulo 4 - Vem que eu te explico!
Ajuste de funções polinomiais
Módulo 4 - Vem que eu te explico!
Funções Linearizáveis


Vamos praticar alguns conceitos?
Falta pouco para atingir seus
objetivos.
Questão 1
O ajuste de um conjunto de dados com uma função é ditaf(x) = m1 + em2x1
A linear.
B exponencial.
C não linear.
D quadrática.
E cúbica.
Responder
Questão 2
A equação é conhecida comoATAx = ATy
A equação de ajuste.
B equação de Gauss.
Considerações �nais
Neste conteúdo, vimos métodos de solução de sistemas de equações lineares, que serão amplamente
utilizados em outros métodos de modelagem matemática, por exemplo, em interpolação e de ajuste de
curvas. Ao apresentar, utilizamos a biblioteca numpy, uma ferramenta importante para trabalhar com
matrizes e vetores, principalmente nas operações de multiplicação, soma e extração de matrizes
triangulares, utilizadas nos métodos iterativos.
Nos métodos de interpolação polinomial, tivemos a oportunidade de aplicar conceitos de polinômios e de
funções, utilizamos bibliotecas de construção de gráficos, para visualizar os dados e os resultados obtidos
por diferentes processos, tais como de Lagrange e Newton.
Por fim, apresentamos formas de estimar valores pelo método dos mínimos quadrados, que permite
extrapolar valores, e pelos métodos de solução de sistemas lineares, para obter o resultado esperado.
C equação literarizável.
D equação normal.
E jacobiana.
Responder

Podcast
Ouça agora uma revisão dos principais conceitos e desafios abordados neste material.
00:00 04:56
1x


Referências
BURDEN, R. L.; FAIRES, J. D. Análise Numérica. São Paulo: Pioneira Thompson Learning, 2003.
DIEGUEZ, J. P. P. Métodos de Cálculo Numérico. Rio de Janeiro: Ed Fundação Ricardo Franco, 2005.
INSTITUTO DE ENGENHEIROS ELETRICISTAS E ELETRÔNICOS. Standard for Floating-Point Arithmetic. 22
Jul. 2019. Consultado na internet em: 23 nov. 2021.
RUGGIERO, M. A. G.; LOPES, V. L. R. Cálculo Numérico: aspectos teóricos e computacionais. São Paulo:
Pearson Education, 1996.
STRANG, G. Álgebra Linear e aplicações. 4. ed. São Paulo: Cengage Learning, 2005.
Explore +
Pesquise o site Matplotlib para explorar as diversas maneiras de fazer gráficos, figuras em Python.
 Baixar conteúdo
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html
javascript:CriaPDF()