Prévia do material em texto

12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 1/60
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
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 2/60
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 métodos iterativos, como
Gauss-Seidel. Veremos um exemplo disso no modulo de
Introdução
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 3/60
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.
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.
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.
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 4/60
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:
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:
Organizando as equações obtemos o seguinte sistema:
Substituindo e e colocando na forma matricial, teremos:
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
2P1 − P2 = P0
−P1 + 2P2 − P3 = 0
−P2 + 2P3 = P4
P0 = 1 P4 = 0
=
⎡⎢⎣ 2 −1 0
−1 2 −1
0 −1 2
⎤⎥⎦ ⎡⎢⎣P1
P2
P3
⎤⎥⎦ ⎡⎢⎣1
0
0
⎤⎥⎦
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 5/60
Como foi sugerido no problema, chamaremos de A a matriz:
E de p e b, respectivamente, os vetores:
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.
Em nosso problema fica assim:
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:
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:
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
⎡⎢⎣ 2 −1 0
−1 2 −1
0 −1 2
⎤⎥⎦e
⎡⎢⎣P1
P2
P3
⎤⎥⎦ ⎡⎢⎣1
0
0
⎤⎥⎦[A ∨ b] =
⎡⎢⎣ 2 −1 0 1
−1 2 −1 0
0 −1 2 0
⎤⎥⎦=
⎡⎢⎣ 2 −1 0 1
−1 2 −1 0
0 −1 2 0
⎤⎥⎦m = −1/2
Linha(2) = Linha(2) − m × Linha(1)
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 6/60
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:
Em que m = - 2/3, o que resulta em todos os elementos abaixo da
escada iguais a zero, conforme a imagem a seguir:
Linha(3) = Linha(3) − m × Linha(2)
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 7/60
3º passo
Vamos observar o sistema de equações após as modificações:
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:
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.
Algoritmo do método de eliminação
de Gauss
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

12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 8/60
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:
A matriz A transformou-se em uma matriztriangular 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:
Resolvendo-o:
Generalizando para um sistema triangular superior de ordem n:
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.
=
⎡⎢⎣2 −1 0
0 3/2 −1
0 0 4/3
⎤⎥⎦ ⎡⎢⎣P1
P2
P3
⎤⎥⎦ ⎡⎢⎣ 1
1/2
2/6
⎤⎥⎦=
⎡⎢⎣U0,0 U0,1 U0,2
0 U1,1 U1,2
0 0 U2,2
⎤⎥⎦ ⎡⎢⎣x0
x1
x2
⎤⎥⎦ ⎡⎢⎣c0
c1
c2
⎤⎥⎦1∘ − x2 =
c2
U2,2
, 2∘ − χ1 =
c1 − U1,2x2
U1,1
e3∘ − χ0 =
c0 − U0,1x1 − U0,2x2
U0,0
xi =
(ci − ∑n−1
j=i+1 Ui,jxj)
Ui,i
 para i = n − 1,n − 2, … , 1, 0
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 9/60
Escrever uma matriz é semelhante a escrever uma lista, mas usando o
comando np.array(lista). Vamos aplicar como exemplo o problema
anterior:
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:
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.
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.
Resumindo, para resolver o problema:
xi =
(ci − ∑n−1
j=i+1 Ui,jxj)
Ui,i
 para i = n − 1,n − 2, … , 1, 0
x[i] = (c[i] − U [i, i + 1 : [@x[i + 1 :])/U [i, i]
xi =
(ci − ∑n−1
j=i+1 Ui,jxj)
Ui,i
v ⊙ u = ∑n−1
i
viui
=
⎡⎢⎣2 −1 0
0 3/2 −1
0 0 4/3
⎤⎥⎦ ⎡⎢⎣P1
P2
P3
⎤⎥⎦ ⎡⎢⎣ 1
1/2
2/6
⎤⎥⎦
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 10/60
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:
Expondo na forma matricial:
Essa expressão escrita em Python ficaria da seguinte forma:
Python 
(k + 1, k + 2, … . n − 1)
Ak,k
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
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 11/60
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).
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:
Python 
Python 
=
⎡⎢⎣ 2 −1 0
−1 2 −1
0 −1 2
⎤⎥⎦ ⎡⎢⎣P1
P2
P3
⎤⎥⎦ ⎡⎢⎣1
0
0
⎤⎥⎦
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 12/60
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 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:
Atenção!
Observe que já foi colocada a matriz aumentada do sistema.
1º passo (k=0)
Começaremos na primeira linha e dividiremos toda a linha pelo
elemento da diagonal principal, , resultando na
seguinte matriz:
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.
[A ∨ b] =
⎡⎢⎣ 2 −1 0 1
−1 2 −1 0
0 −1 2 0
⎤⎥⎦A[k, k] = A[0, 0] = 2,
⎡⎢⎣ 1 −1/2 0 1/2
−1 2 −1 0
0 −1 2 0
⎤⎥⎦ m = A[i, k]/A[k, k]
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 13/60
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:
Resultando na seguinte matriz equivalente:
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:
Atenção!
Note que o vetor d = x, ou seja, a solução do sistema.
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 
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/2
0 3/2 −1/2 1/2
0 −1 2 0
⎤⎥⎦⎡⎢⎣1 0 0 3/4
0 1 0 1/2
0 0 1 1/4
⎤⎥⎦
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 14/60
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 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:
A ideia principal para resolver um sistema Ax=b usando a fatoração LU é
a seguinte:
Logo, teremos dois sistemas:
1) Sistema de uma matriz triangular superior, para o qual já temos o
algoritmo de solução (substituição retroativa):
2) Sistema de uma matriz triangularinferior, para o qual
apresentaremos o algoritmo de solução, que definiremos como
substituição sucessiva.
=
⎡⎢⎣A0,0 A0,1 A0,2
A1,0 A1,1 A1,2
A2,0 A2,1 A2,2
⎤⎥⎦ ⎡⎢⎣ 1 0 0
L1,0 1 0
L2,0 L2,1 1
⎤⎥⎦ ⎡⎢⎣U0,0 U0,1 U0,2
0 U1,1 U1,2
0 0 U2,2
⎤⎥⎦Ax = b → L Ux
c
= b
Ux = c
Lc = b
=
⎡⎢⎣L0.0 0 0
L1,0 L1.1 0
L2,0 L2,1 L2.2
⎤⎥⎦ ⎡⎢⎣c0
c1
c2
⎤⎥⎦ ⎡⎢⎣b0
b1
b2
⎤⎥⎦
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 15/60
Resolvendo-o:
Generalizando para um sistema triangular superior de ordem n:
Em Python, definiremos a seguinte função:
Python 
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 
1∘ − c0 =
b0
L0,0
, 2∘ − c1 =
b1 − L1,0c0
L1,1
e 3∘ − c2 =
b2 − L2,0c0 − L2,1c1
L2,2
ci =
(bi − ∑i−1
j=0 Li,jcj)
Li,i
 para i = 0, 1, 2 … ,n − 1
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 16/60
Como exemplo, resolveremos o nosso problema original:
Python 
=
⎡⎢⎣ 2 −1 0
−1 2 −1
0 −1 2
⎤⎥⎦ ⎡⎢⎣P1
P2
P3
⎤⎥⎦ ⎡⎢⎣1
0
0
⎤⎥⎦
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 17/60
Falta pouco para atingir seus objetivos.
Vamos praticar alguns conceitos?
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.
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 18/60
Parabéns! A alternativa E está correta.
No módulo numpy do Python, a escrita de uma matriz ou vetor é
dada np.array, como é vista em todos exemplos do módulo 1, a
dimensão ou a ordem é definida por número de linhas (l) e números
de colunas (c) e escrita por lxc. No array, cada linha é limitada por
colchetes ([ ]) e a quantidades de elementos dentro dos colchetes
define a quantidade de colunas, no caso do exercício, 2x3.
Questão 2
Na decomposição da matriz A= LU, as matrizes L e U são
respectivamente
Parabéns! A alternativa A está correta.
Por definição, na decomposição da matriz A = LU, as matrizes L e U
são respectivamente triangular inferior (do inglês L de low) e
triangular superior (do inglês U de up).
E uma matriz 2x3.
A triangular inferior e triangular superior.
B triangular superior e triangular inferior.
C diagonal e tridiagonal.
D pentagonal e identidade.
E diagonal e triangular inferior.
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 19/60
2 - Métodos iterativos para resolução de sistemas: Gauss-
Jacobi e Gauss-Seidel
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:
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:
=
⎡⎢⎣ 2 −1 0
−1 2 −1
0 −1 2
⎤⎥⎦ ⎡⎢⎣P1
P2
P3
⎤⎥⎦ ⎡⎢⎣1
0
0
⎤⎥⎦
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 20/60
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:
Chegamos a uma equação em que podemos usar a equação iterativa,
ou seja:
Colocaremos um chute inicial e realizaremos os cálculos para
.
Faremos para n=3:
Generalizando para k=n, teremos:
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:
Em que a0 é o termo inicial e q é a razão da PG, logo:
Ou seja, é a resposta da equação.
Quando isso acontece, dizemos que o processo iterativo convergiu.
5x + 1 = 0
x = −1/5
5x = 4x + x
4x + x + 1 = 0 → 4x = −x − 1 → x =
−x
4
−
1
4
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 → ∞
−x0
4n → 0
a0
1 − q ′
( 1
4
−
1
42
+
1
43
−
1
44
+ ⋯) =
1
4
1 + 1
4
=
1
5′
x = −1/5
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 21/60
Agora, vamos resolver o mesmo problema, mas mudaremos um pouco a
equação de iteração:
Da mesma maneira, fazendo a equação de iteração:
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.
Decomposição da matriz A
Para determinar equações de iteração, fizemos o seguinte algebrismo:
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:
Substituindo essa decomposição no sistema linear , teremos:
Multiplicando o vetor x, obteremos:
Vamos multiplicar a esquerda da equação pela inversa de M:
4x + x + 1 = 0 → x = −4x − 1
xk+1 = −4xk − 1 para k = 0, 1, … n
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
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 22/60
Substituindo N por M-A e depois realizando a multiplicação matricial,
obteremos:
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:
Então, a equação de iteração ficaria da seguinte maneira:
Em que:
O algoritmo ficaria assim:
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:
Nosso chute inicial será o vetor e escolheremos uma
decomposição.
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
=
⎡⎢⎣ 2 −1 0
−1 2 −1
0 −1 2
⎤⎥⎦ ⎡⎢⎣P1
P2
P3
⎤⎥⎦ ⎡⎢⎣10
0
⎤⎥⎦x0 = [0, 0, 0]T
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 23/60
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:
Isso facilita muito os cálculos. A seguir, vamos apresentar um programa
em Python, que realiza as etapas 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:
Atenção!
= −
Mpk = rk → pk = rk → pk = rk
⎡⎢⎣ 2 −1 0
−1 2 −1
0 −1 2
⎤⎥⎦ ⎡⎢⎣1 0 0
0 1 0
0 0 1
⎤⎥⎦ ⎡⎢⎣−1 1 0
1 −1 1
0 −1 −1
⎤⎥⎦⎡⎢⎣1 0 0
0 1 0
0 0 1
⎤⎥⎦
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.
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 24/60
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.
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:
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:
A seguir, teremos o seguinte programa em Python, resolvendo o nosso
problema inicial, lembrando que ao utilizar M como identidade, não
convergiu:
Python 
= −
⎡⎢⎣A0,0 A0,1 A0,2
A1,0 A1,1 A1,2
A2,0 A2,1 A2,2
⎤⎥⎦ ⎡⎢⎣A0,0 0 0
0 A1,1 0
0 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]
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 25/60
O resultado ao executar a função sol_Jacobi foi:
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:
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.
Resolvendo-o:
Generalizando para um sistema triangular superior de ordem n:
A seguir, teremos o programa em Python, resolvendo o nosso problema
inicial, lembrando que ao utilizar M como identidade, não convergiu:
Python 
r = [0.00000000e + 002. 77555756e − 16 − 2. 22044605e − 16]
p = [0.00000000e + 001.38777878e − 16 − 1.11022302e − 16]
x = [0.750.50.25]
––
––
= −
⎡⎢⎣A0,0 A0,1 A0,2
A1,0 A1,1 A1,2
A2,0 A2,1 A2,2
⎤⎥⎦ ⎡⎢⎣A0,0 0 0
A1,0 A1,1 0
A2,0 A2,1 A2,2
⎤⎥⎦ ⎡⎢⎣0 −A0,1 −A0,2
0 0 −A1,2
0 0 0
⎤⎥⎦Mp = r → =
⎡⎢⎣A0,0 0 0
A1,0 A1,1 0
A2,0 A2,1 A2,2
⎤⎥⎦ ⎡⎢⎣p0
p1
p2
⎤⎥⎦ ⎡⎢⎣r0
r1
r2
⎤⎥⎦1∘ − p0 =
r0
A0,0
, 2∘ − p1 =
r1 − A1,0p0
A1,1
e 3∘ − p2 =
r2 − A2,0p0 − A2,1p1
A2,2
pi =
(ri − ∑i−1
j=0 Ai,jpj)
Ai,i
 para i = 0, 1, 2 … ,n − 1
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 26/60
O resultado ao executar a função sol_GaussSeideil foi:
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á!
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]

12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 27/60
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
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 28/60
como chute inicial x0=[0,0,0,0].
Parabéns! A alternativa D está correta.
Utilizando a função sol_GaussSeidel em Python apresentada neste
módulo:
Python 
obtém-se:
k= 14
r= [ 3.16300790e-08 -2.47604603e-08 -1.23802311e-08
0.00000000e+00] p= [ 4.51858271e-09 -3.65988038e-09
-1.96541209e-09 -3.05372305e-09]
x= [ 1. -1. 1. -1.]
Questão 2
=
⎡⎢⎣ 7 1 −1 2
1 8 0 −2
−1 0 4 −1
2 −2 −1 6
⎤⎥⎦ ⎡⎢⎣x1
x2
x3
x4
⎤⎥⎦ ⎡⎢⎣ 3
−5
4
−3
⎤⎥⎦A [1,1,1,1] e k=10
B [-1,-1,-1,-1] e k=14
C [1,-1,1,-1] e k=10
D [1,-1,1,-1] e k=14
E [1,1,1,1] e k=14
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 29/60
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].
Parabéns! A alternativa E está correta.
Utilizando a função sol_jacobi em Python apresentado neste
módulo:
Python 
obtém-se:
k= 14
=
⎡⎢⎣ 4 −1 1
−1 4 −2
1 −2 4
⎤⎥⎦ ⎡⎢⎣x1
x2
x3
⎤⎥⎦ ⎡⎢⎣ 12
−1
5
⎤⎥⎦A [1,1,1] e k=49
B [-1,-1,-1] e k=61
C [3,1,1,] e k=49
D [3,1,1] e k=61
E [3,1,1] e k=49
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 30/60
r= [ 3.16300790e-08 -2.47604603e-08 -1.23802311e-08
0.00000000e+00] p= [ 4.51858271e-09 -3.65988038e-09
-1.96541209e-09 -3.05372305e-09]
x= [ 1. -1. 1. -1.]
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:
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 31/60
O engenheiro solicita ao topógrafo mensurar as alturas e fornece uma
tabela com os seguintes dados:
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.
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.
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:
Em que
x(m) 1 2 3 4 5 6 7
y(m) 1 3 2 4 2 5 4

φk(x)
 n 
ck(k = 0, 1, … ,N − 1)
(xi, yi)
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 32/60
é 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:
Em que . Então, podemos reescrever da forma matricial:
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:
p(x)
(xj, yj) j = 0, 1, ⋯ ,n − 1
φk(x)
ck
p(x)
yj = ∑ ckφk (xj)
p (xj) = yj
=
⎡⎢⎣ φ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)
⎤⎥⎦ ⎡⎢⎣ c0
c1
c2
⋮
cn−1
⎤⎥⎦ ⎡⎢⎣ y0
y1
y2
⋮
yn−1
⎤⎥⎦φk (xj)
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 33/60
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 
Cujo resultado é a imagem a seguir:
Logo, podemos escrever o polinômio interpolador como:
φk(x) = xk
p(x) = ∑ ckφk(x) = c0 + c1x + c2x
2 + c3x
3 + ⋯ + cn−1x
n−1
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 34/60
Lembre-se de que a entrada para o problema de interpolação são os
pontos para , dessa maneira:
Assim, o nosso problema se resume em encontrar os coeficientes , ou
seja, resolvendo o sistema linear:
Comentário
Observe que a matriz do sistema acima é bem conhecida na
Matemática, é a matriz de Vandermonde e o determinante dessa matriz
sempre é diferente de zero, isto é, o sistema possui uma única solução.
Vejamos como exemplo o problema do nosso engenheiro de obter a
elevação quando x=3,5, com as observações do topógrafo:
Realizando o seguinte programa em Python:
Python 
Ao executar o programa, teremos a seguinte saída:
(xj, yj) j = 0, 1, 2, ⋯ ,n − 1
p (xj) = yj = c0 + c1x
2
j + c3x
3
j + ⋯ + cn−1x
n−1
j
cj
=
⎡⎢⎣1 x0 x2
0 ⋯ xn−1
0
1 x1 x2
1 ⋯ xn−1
1
1 x2 x2
2 ⋯ xn−1
2
⋮ ⋮ ⋮ ⋱ ⋮
1 xn−1 x2
n−1 ⋯ xn−1
n−1
⎤⎥⎦ ⎡⎢⎣ c0
c1
c2
⋮
cn−1
⎤⎥⎦ ⎡⎢⎣ y0
y1
y2
⋮
yn−1
⎤⎥⎦x(m) 1 2 3 4 5 6 7
y(m) 1 3 2 4 2 5 4
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 35/60
>>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:
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.
Comentário
Pronto, poderíamos parar por aqui, pois o problema encontra-se
resolvido, mas computacionalmente, a solução encontra um problema: a
p(x) = c0 + c1x + c2x
2 + c3x
3 + ⋯ + cn−1x
n−1
 coef  =  np.  array ([c0, c1, … , cn−1])
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 36/60
solução do sistema linear pode apresentar dificuldades, logo, existem
outras técnicas nas quais não é necessário resolver um sistema linear.
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:
Em que definiremos como polinômios de Lagrange básicos e eles
têm a seguinte propriedade:
Dada por:
Expandindo a fórmula, o polinômio é escrito da seguinte maneira:
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:
p (xm) = ym m = 0, 1, …n
ln
ln (xm) = ym
ln(x) = ∑ ymLn,m(x)
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)
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 37/60
Temos os seguintes polinômios básicos:
Fazendo , teremos:
Desenvolvendo a expressão, chegaremos no seguinte resultado:
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 
l2(x) = ∑ ykL2,k(x)
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
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 38/60
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.
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 definidospor e dados pela seguinte
expressão:
l2(x) = 8 − 6x + x2
πi(x)
πi(x) = ∏ (x − xj)
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 39/60
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:
Para construir os gráficos, teremos o seguinte programa em Python:
Python 
Ao executar o script, teremos o seguinte resultado:
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)
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 40/60
Forma de Newton
A forma de Newton é basicamente uma forma de rescrever um
polinômio:
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:
Então, o método de Newton para interpolação é:
Dado pontos , encontrar:
Sendo que o problema busca determinar os coeficientes
 logicamente, respeitando a condição primordial da
interpolação:
p(x) = c0 + c1x + c2x
2 + c3x
3 + ⋯ + cn−1x
n−1
xj
nN
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
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 41/60
Vamos seguir os seguintes passos para determinar os coeficientes
:
1) Para os pontos :
2) Para :
3) Para (x_2,y_2):
Desenvolvendo:
4) Para o terceiro ponto :
Da mesma forma, obtemos:
Generalizando e definindo diferenças divididas:
Continuando e generalizando:
ai as 
(x0, y0)
nN (x0) = a0 = y0
(x1, y1)
nN (x1) = a0 + a1 (x1 − x0) = y1
a1 =
y1 − y0
x1 − x0
nN (x2) = a0 + a1 (x2 − x0) + a2 (x2 − x0) (x2 − x1) = y2
a2 =
y2−y1
x2−x1
− y1−y0
x1−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
f [x1,x0] =
y1 − y0
x1 − x0
f [x0,x1,x2] =
y2−y1
x2−x1
− y1−y0
x1−x0
x2 − x0
=
f [x2,x1] − f [x1,x0]
x2 − x0
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 42/60
Podemos visualizar esses valores em uma tabela das diferenças
divididas (DD):
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:
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
f [xk,xk−1, ⋯ ,x1,x0] =
f [xk,xk−1, ⋯ ,x2,x1] − f [xk−1, ⋯ ,x1,x0]
xk − x0
xk yk D2f 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
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 43/60
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
>>o valor da elevação para x=3,5 é igual a n_6(3.5)=
3.4052734374995026
E o seguinte gráfico:
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.
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
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 44/60
ocorre com o método de Newton.
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á!

12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 45/60
Falta pouco para atingir seus objetivos.
Vamos praticar alguns conceitos?
Questão 1
Um conjunto de pontos possui 6 coordenadas (x,y), logo, por
interpolação, o grau do polinômio interpolador é
Parabéns! A alternativa C está correta.
A 7.
B 6.
C 5.
D 4.
E 3.
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 46/60
Dado N+1 pontos o polinômio interpolador é de grau N, logo se
N+1=6 implica que N=5.
Questão 2
Em uma interpolação linear são necessários quantos pontos
(coordenadas)?
Parabéns! A alternativa D está correta.
Dados N+1 pontos, o polinômio interpolador é de grau N, logo, a
interpolação linear é uma reta de grau N=1, ou seja, são necessários
2 pontos.
A 5
B 4
C 3
D 2
E 1
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 47/60
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:
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.
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
x(m) 1 2 3 4 5 6 7
y(m) 1 3 2 4 2 5 4
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 48/60
métodos de processar esses dados, vamos abordar um exemplo
simples de dados numéricos tabelados:
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,
 .
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.
Na prática, é mais comum resolver a seguintefunçã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:
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 , em que:
x y
x0 y0
x1 y1
x2 y2
⋮ ⋮
xm ym
m + 1 (xi, yi)
ϕ(a, b) = ∑ |axi + b − yi|
ϕ a b
l1
ϕ(a, b) = ∑ (axi + b − yi)
2
l2
l1 l2
−p ou lp
∥v∥p = {∑ |vp
i
|}
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
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 49/60
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:
Implementando a solução em Python e visualizando o gráfico:
Python 
O gráfico obtido do ajuste é:
[ ] =
⎡⎢⎣x1 1
x2 1
x3 1
x4 1
x5 1
x6 1
x7 1
⎤⎥⎦ a
b
⎡⎢⎣y1
y2
y3
y4
y5
y6
y7
⎤⎥⎦ATAx = ATy
∥y − Ax∥2
2
Ax = b
[ ] =
⎡⎢⎣1 1
2 1
3 1
4 1
5 1
6 1
7 1
⎤⎥⎦ a
b
⎡⎢⎣1
3
2
4
2
5
4
⎤⎥⎦
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 50/60
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.
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 .
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.
Podemos determinar todas as incógnitas parâmetros exigindo que
nossa função de aproximação passe exatamente pelos pontos de
dados de entrada, isto é:
(xj, yj) j = 0, 1, ⋯ ,n − 1
f(x)
m < n
φk(x)
Ck
p(x)
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 51/60
Em que . Podemos reescrever da forma matricial:
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 
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.
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)
⎤⎥⎦ ⎡⎢⎣ c0
c1
c2
⋮
cn−1
⎤⎥⎦ ⎡⎢⎣ y0
y1
y2
⋮
yn−1
⎤⎥⎦φk (xj) = xk
j
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 52/60
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.
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 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:
Pelo MMQ, o problema reside em encontrar o mínimo da função:
f(x) = m1 log(x) + m2 cos(x) + m3e
x
f(x)
x (mês)  1 2 3 4 5 6 7
y (contágio)  1 3 2 4 2 5 4
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 53/60
Ou seja, fazendo:
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.
Primeiro, devemos notar que cada linha da matriz A tem esse formato:
Portanto, o sistema é:
Em Python:
Python 
ϕ (m1,m2,m3) = ∑ (yi − (m1 log (xi) + m2 cos (xi) + m3e
xi))2
∂ϕ
∂m1
= 0;
∂ϕ
∂m2
= 0;
∂ϕ
∂m3
= 0
ATAm = ATy
Ax = b
m1 log (xj) + m2 cos (xj) + m3e
xj = yj
=
⎡⎢⎣log(1) cos(1) e1
log(2) cos(2) e2
log(3) cos(3) e3
log(4) cos(4) e4
log(5) cos(5) e5
log(6) cos(6) e6
log(7) cos(7) e7
⎤⎥⎦ ⎡⎢⎣m1
m2
m3
⎤⎥⎦ ⎡⎢⎣1
3
2
4
2
5
4
⎤⎥⎦
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 54/60
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.
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.
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.
O formato da função é:
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:
Ax = b
f(x) = m0 (1 + em1x)
m0 e m1
m1
g(x) = a1c
d1
1 cd2
2 c
d3
3 … cdk
k
logb
logb(g(x)) = logb(a1) + d1 logb(c1) + d2 logb(c2) + d3 logb(c3) + ⋅ ⋅ ⋅ + dk logb(ck)
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 55/60
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.
Portanto, aplicando obteremos:
Fazendo , teremos:
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 
loge
log
log(f(x))
log(f(x)) = log (m0) + m1x
m′
0 = log (m0) e  log(f(x)) = y′
y′ = m0
′ + m1x
m0 m1
f(x)

12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 56/60
Funções polinomiais
Acompanhe agora um exemplo de exercício resolvido, utilizando
códigos em Python aplicados às funções polinomiais. Vamos lá!
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 57/60
Falta pouco para atingir seus objetivos.
Vamos praticar alguns conceitos?
Questão 1
O ajuste de um conjunto de dados com uma função
 é dita
Parabéns! A alternativa C está correta.
A função é um ajuste não linear, pois a matriz
de ajuste A depende dos parâmetros.
Questão 2
A equação é conhecida como
f(x) = m1 + em2x1
A linear.
B exponencial.
C não linear.
D quadrática.
E cúbica.
f(x) = m1 + em2x1
ATAx = ATy
A equação de ajuste.
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 58/60
Parabéns! A alternativa D está correta.
Quando realizamos os cálculos para achar o valor mínimo de
, por exemplo, chegamos nas
equações normais .
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.
Podcast
B equação de Gauss.
C equação literarizável.
D equação normal.
E jacobiana.
ϕ(a, b) = ∑ (axi + b − yi)
2
ATAx = ATy

12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 59/60
Ouça agora uma revisão dos principais conceitos e desafios abordados
neste material.
Explore +
Pesquise o site Matplotlib para explorar as diversas maneiras de fazer
gráficos, figuras em Python.
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.
Material para download
Clique no botão abaixo para fazer o download do
conteúdo completo em formato PDF.
12/03/24, 20:39 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 60/60
Download material
O que você achou do conteúdo?
Relatar problema
javascript:CriaPDF()