TEMA 2 - Sistemas de equações lineares e ajustes de curvas em Python (Modelagem Matemátic

Prévia do material em texto

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 1/72
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 2/72
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 3/72
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.
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 4/72
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
$$$\mathrm{x}_{0}, \mathrm{x}_{1}, \ldots, \mathrm{x}_{\mathrm{n}}$$$. Quando um objeto se encontra no
lugar $$$\mathrm{X}_{\mathrm{i}}$$$, ele tem a mesma probabilidade de se mover para
$$$\mathrm{X}_{\mathrm{i}+1}$$$ ou para $$$\mathrm{X}_{\mathrm{i}-1}$$$, mas não pode ir diretamente
para nenhum outro lugar.
Considere as probabilidades $$$\left\{P_{i}\right\}_{i=0}^{n}$$$ de que um objeto que parte do lugar
$$$\mathrm{X}_{\mathrm{i}}$$$ chegue ao extremo esquerdo $$$\mathrm{x}_{0}$$$ antes de alcançar o
extremo direito $$$\mathrm{x}_{n}$$$. Dado que o objeto pode mover-se até
$$$\mathrm{X}_{\mathrm{i}}$$$ apenas a partir de $$$\mathrm{X}_{\mathrm{i}-1}$$$ ou de
$$$\mathrm{X}_{\mathrm{i}+1}$$$ e o faz com a probabilidade 1/2 para cada um desses lugares:
$$2 P_{i}=P_{i-1}+P_{i+1}, \text { para } i=1,2,3, \ldots, \mathrm{n}-1$$
Rotacione a tela. 
Seja o vetor $$$\mathbf{p}=\left[\begin{array}{llll}P_{1} & P_{2} & \left.{\ldots . .} P_{n-
1}\right]^{\top}\end{array}\right.$$$, 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 $$$P_{0}=1$$$ e que $$$P_{n}=0,$$$, no caso do item a,
$$$P_{4}=0$$$, então, fazendo i = 1, 2 e 3, teremos as seguintes equações:
$$ \begin{aligned} &2 P_{1}=P_{0}+P_{2} \\ &2 P_{2}=P_{1}+P_{3} \\ &2 P_{3}=P_{2}+P_{4} \end{aligned}
$$
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 5/72
Rotacione a tela. 
Organizando as equações obtemos o seguinte sistema:
$$\begin{gathered} 2 P_{1}-P_{2}=P_{0} \\ -P_{1}+2 P_{2}-P_{3}=0 \\ -P_{2}+2 P_{3}=P_{4}
\end{gathered}$$
Rotacione a tela. 
Substituindo $$$P_{ 0}=1$$$ e $$$P_{4}=0$$$ e colocando na forma matricial, teremos:
$$\left[\begin{array}{ccc} 2 & -1 & 0 \\ -1 & 2 & -1 \\ 0 & -1 & 2 \end{array}\right]\left[\begin{array}{l} P_{1}
\\ P_{2} \\ P_{3} \end{array}\right]=\left[\begin{array}{l} 1 \\ 0 \\ 0 \end{array}\right]$$
Rotacione a tela. 
Como foi sugerido no problema, chamaremos de A a matriz:
$$\left[\begin{array}{ccc} 2 & -1 & 0 \\ -1 & 2 & -1 \\ 0 & -1 & 2 \end{array}\right]$$
Rotacione a tela. 
E de p e b, respectivamente, os vetores:
$$\left[\begin{array}{l} P_{1} \\ P_{2} \\ P_{3} \end{array}\right] \mathrm{e}\left[\begin{array}{l} 1 \\ 0 \\ 0
\end{array}\right]$$
Rotacione a tela. 
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.

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 6/72
Em nosso problema fica assim:
$$[A \vee b]=\left[\begin{array}{cccc} 2 & -1 & 0 & 1 \\ -1 & 2 & -1 & 0 \\ 0 & -1 & 2 & 0 \end{array}\right]$$
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:
$$=\left[\begin{array}{cccc} 2 & -1 & 0 & 1 \\ -1 & 2 & -1 & 0 \\ 0 & -1 & 2 & 0 \end{array}\right]$$
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, $$$m=-1 / 2$$$, resultando na seguinte
operação:
$$\operatorname{Linha}(2)=\operatorname{Linha}(2)-m \times \operatorname{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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 7/72
Vamos modificar a terceira linha, e a segunda linha será a nossa linha pivô, logo, semelhante ao 1º passo:
$$\operatorname{Linha}(3)=\operatorname{Linha}(3)-m \times \operatorname{Linha}(2)$$
Rotacione a tela. 
Em que m = - 2/3, o que resulta em todos os elementos abaixo da escada iguais a zero, conforme a imagema seguir:
3º passo
Vamos observar o sistema de equações após as modificações:
$$\begin{gathered}2 P_{1}-P_{2}=1 \\3 / 2 P_{2}-P_{3}=1 / 2 \\4 / 3 P_{3}=2 / 6\end{gathered}$$
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:
$$\begin{gathered}4 / 3 P_{3}=2 / 6 \Rightarrow P_{3}=1 / 4=0,25 \\3 / 2 P_{2}-1 / 4=1 / 2 \Rightarrow
P_{2}=1 / 2=0,5 \\2 P_{1}-1 / 2=1 \Rightarrow P_{1}=3 / 4=0,75\end{gathered}$$
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.
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 8/72
Eliminação de Gauss
Veja agora os principais conceitos citados ao longo deste módulo.
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:
$$\left[\begin{array}{ccc}2 & -1 & 0 \\0 & 3 / 2 & -1 \\0 & 0 & 4 / 3\end{array}\right]\left[\begin{array}
{l}P_{1} \\P_{2} \\P_{3}\end{array}\right]=\left[\begin{array}{c}1 \\1 / 2 \\2 / 6\end{array}\right]$$
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:

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 9/72
$$ \left[\begin{array}{ccc} U_{0,0} & U_{0,1} & U_{0,2} \\ 0 & U_{1,1} & U_{1,2} \\ 0 & 0 & U_{2,2}
\end{array}\right]\left[\begin{array}{l} x_{0} \\ x_{1} \\ x_{2} \end{array}\right]=\left[\begin{array}{l} c_{0} \\
c_{1} \\ c_{2} \end{array}\right] $$
Rotacione a tela. 
Resolvendo-o:
$$ 1^{\circ}-x_{2}=\frac{c_{2}}{U_{2,2}}, 2^{\circ}-\chi_{1}=\frac{c_{1}-U_{1,2} x_{2}}{U_{1,1}} \mathrm{e}
3^{\circ}-\chi_{0}=\frac{c_{0}-U_{0,1} x_{1}-U_{0,2} x_{2}}{U_{0,0}}$$
Rotacione a tela. 
Generalizando para um sistema triangular superior de ordem n:
$$ x_{i}=\frac{\left(c_{i}-\sum_{j=i+1}^{n-1} U_{i, j} x_{j}\right)}{U_{i, i}} \text { para } i=n-1, n-2, \ldots, 1,0 $$
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:
$$ x_{i}=\frac{\left(c_{i}-\sum_{j=i+1}^{n-1} U_{i, j} x_{j}\right)}{U_{i, i}} \text { para } i=n-1, n-2, \ldots, 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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 10/72
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,$$$x[i]=(c[i]-U[i, i+1:[@ x[i+1:]) / U[i, i]$$$, que é tradução no Python
para a fórmula:
$$x_{i}=\frac{\left(c_{i}-\sum_{j=i+1}^{n-1} U_{i, j} x_{j}\right)}{U_{i, i}}$$
Rotacione a tela. 
Define-se produto escalar de dois vetores, v e u, como: $$$v \odot u=\sum_{i}^{n-1} v_{i} u_{i}$$$, 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:
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.

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 11/72
$$ \left[\begin{array}{ccc} 2 & -1 & 0 \\ 0 & 3 / 2 & -1 \\ 0 & 0 & 4 / 3 \end{array}\right]\left[\begin{array}{l}
P_{1} \\ P_{2} \\ P_{3} \end{array}\right]=\left[\begin{array}{c} 1 \\ 1 / 2 \\ 2 / 6 \end{array}\right] $$
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ô $$$(\mathrm{k}+1, \mathrm{k}+2, \ldots . \mathrm{n}-1)$$$, zerando os
elementos abaixo do elemento da diagonal principal da matriz $$$\mathrm{A_{k,k}}$$$, ou seja, iniciamos
com o sistema Ax=b e transformamos no sistema Ux=c como na formulação a seguir:
$$\operatorname{linh} a(i)=\operatorname{linh} a(i)-m \times \operatorname{linh} a(\text { pivô }), \text {
onde } m=\frac{A_{i, k}}{A_{k, k}}$$
Rotacione a tela. 
Expondo na forma matricial:
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 12/72
$$\operatorname{linha}(i)=\operatorname{linha}(i)-m \times \operatorname{linha}(\text { pivô }), \text {
onde } m=\frac{A_{i, k}}{A_{k, k}}$$
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).
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:
$$ \left[\begin{array}{ccc} 2 & -1 & 0 \\ -1 & 2 & -1 \\ 0 & -1 & 2 \end{array}\right]\left[\begin{array}{l} P_{1}
\\ P_{2} \\ P_{3} \end{array}\right]=\left[\begin{array}{l} 1 \\ 0 \\ 0 \end{array}\right] $$
Rotacione a tela. 
Python 
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
06/06/2022 21:26 Sistemas de equaçõeslineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 13/72
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
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:
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 14/72
$$ [A \vee b]=\left[\begin{array}{cccc} 2 & -1 & 0 & 1 \\ -1 & 2 & -1 & 0 \\ 0 & -1 & 2 & 0 \end{array}\right]
$$
Rotacione a tela. 
1º passo (k=0)
Começaremos na primeira linha e dividiremos toda a linha pelo elemento da diagonal principal,
$$$\mathrm{A}[\mathrm{k}, \mathrm{k}]=\mathrm{A}[0,0]=2,$$$, resultando na seguinte matriz:
$$ \left[\begin{array}{cccc} 1 & -1 / 2 & 0 & 1 / 2 \\ -1 & 2 & -1 & 0 \\ 0 & -1 & 2 & 0 \end{array}\right] $$
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 é $$$\mathrm{m}=\mathrm{A}[\mathrm{i}, \mathrm{k}] /
\mathrm{A}[\mathrm{k}, \mathrm{k}]$$$, em que i varia de 0 a n-1, com exceção de k.
Para 2ª linha, $$$\mathrm{m}=\mathrm{A}[1,0] / \mathrm{A}[0,0]$$$, como $$$\mathrm{A}[0,0]=1$$$,
então, $$$\mathrm{m}=\mathrm{A}[1,0]=-1$$$.
Para 3ª linha, em nosso problema não é necessário, pois ele já é igual a zero. Semelhante à eliminação de
Gauss, faremos:
$$\operatorname{linha}(i)=\operatorname{linha}(i)-m \times \operatorname{linha}(k)$$
Rotacione a tela. 
Resultando na seguinte matriz equivalente:
Atenção!
Observe que já foi colocada a matriz aumentada do sistema.

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 15/72
$$\left[\begin{array}{cccc}1 & -1 / 2 & 0 & 1 / 2 \\0 & 3 / 2 & -1 / 2 & 1 / 2 \\0 & -1 & 2 &
0\end{array}\right]$$
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:
$$\left[\begin{array}{llll}1 & 0 & 0 & 3 / 4 \\0 & 1 & 0 & 1 / 2 \\0 & 0 & 1 & 1 / 4\end{array}\right]$$
Rotacione a tela. 
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 
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.]])
1
2
3
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 16/72
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:
$$ \left[\begin{array}{lll} A_{0,0} & A_{0,1} & A_{0,2} \\ A_{1,0} & A_{1,1} & A_{1,2} \\ A_{2,0} & A_{2,1} &
A_{2,2} \end{array}\right]=\left[\begin{array}{ccc} 1 & 0 & 0 \\ L_{1,0} & 1 & 0 \\ L_{2,0} & L_{2,1} & 1
\end{array}\right]\left[\begin{array}{ccc} U_{0,0} & U_{0,1} & U_{0,2} \\ 0 & U_{1,1} & U_{1,2} \\ 0 & 0 &
U_{2,2} \end{array}\right] $$
Rotacione a tela. 
A ideia principal para resolver um sistema Ax=b usando a fatoração LU é a seguinte:
$$A x=b \rightarrow L \underbrace{Ux}_{c}=b$$
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):
 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]
4
5
6
7
8
9
10
11
12
13
14
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 17/72
$$U x=c$$
Rotacione a tela. 
2) Sistema de uma matriz triangular inferior, para o qual apresentaremos o algoritmo de solução, que
definiremos como substituição sucessiva.
$$ \begin{gathered} L c=b \\ {\left[\begin{array}{ccc} L_{0.0} & 0 & 0 \\ L_{1,0} & L_{1.1} & 0 \\ L_{2,0} &
L_{2,1} & L_{2.2} \end{array}\right]\left[\begin{array}{l} c_{0} \\ c_{1} \\ c_{2}
\end{array}\right]=\left[\begin{array}{l} b_{0} \\ b_{1} \\ b_{2} \end{array}\right]} \end{gathered} $$
Rotacione a tela. 
Resolvendo-o:
$$1^{\circ}-c_{0}=\frac{b_{0}}{L_{0,0}}, 2^{\circ}-c_{1}=\frac{b_{1}-L_{1,0} c_{0}}{L_{1,1}} \quad \textrm{e}
\quad 3^{\circ}-c_{2}=\frac{b_{2}-L_{2,0} c_{0}-L_{2,1} c_{1}}{L_{2,2}}$$
Rotacione a tela. 
Generalizando para um sistema triangular superior de ordem n:
$$c_{i}=\frac{\left(b_{i}-\sum_{j=0}^{i-1} L_{i, j} c_{j}\right)}{L_{i, i}} \text { para } i=0,1,2 \ldots, n-1$$
Rotacione a tela. 
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
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]
 return c
1
2
3
4
5
6
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 18/72
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:
$$ \left[\begin{array}{ccc} 2 & -1 & 0 \\ -1 & 2 & -1 \\ 0 & -1 & 2 \end{array}\right]\left[\begin{array}{l} P_{1}
\\ P_{2} \\ P_{3} \end{array}\right]=\left[\begin{array}{l} 1 \\ 0 \\ 0 \end{array}\right] $$
Rotacione a tela. 
Python 
def 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, U
def solucao_LU(A,b):
 L,U = Dec_LU(A)
 c = SubSuc(L,b)
 x = SubRet(U,c)
 return x
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html#19/72
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 20/72

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.
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 21/72
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.
C diagonal e tridiagonal.
D pentagonal e identidade
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 22/72
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.
D pentagonal e identidade.
E diagonal e triangular inferior.
Responder

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 23/72
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:
$$\left[\begin{array}{ccc} 2 & -1 & 0 \\ -1 & 2 & -1 \\ 0 & -1 & 2 \end{array}\right]\left[\begin{array}{l} P_{1}
\\ P_{2} \\ P_{3} \end{array}\right]=\left[\begin{array}{l} 1 \\ 0 \\ 0 \end{array}\right] $$
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 $$$5 x+1=0$$$.
É fácil de verificar que $$$x=-1 / 5$$$ resolve o problema, mas vamos solucionar de um modo diferente.
Primeiro, notamos $$$5 x=4 x+x$$$ e substituímos na equação:
$$4 x+x+1=0 \rightarrow 4 x=-x-1 \rightarrow x=\frac{-x}{4}-\frac{1}{4}$$
Rotacione a tela. 
Chegamos a uma equação em que podemos usar a equação iterativa, ou seja:
$$x=\frac{-x}{4}-\frac{1}{4} \rightarrow x_{k+1}=\frac{-x_{k}}{4}-\frac{1}{4}$$
Rotacione a tela. 
Colocaremos um chute inicial $$$ x_{0} $$$ e realizaremos os cálculos para $$$\mathrm{k}=0,1,2, \ldots
\ldots \mathrm{n}$$$.
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 24/72
Faremos para n=3:
$$ \begin{gathered} k=\mathrm{n} \rightarrow x_{n+1}=\frac{-x_{\mathrm{n}}}{4}-\frac{1}{4}=\frac{-x_{0}}
{4^{\mathrm{n}}}-\left(\frac{1}{4}-\frac{1}{4^{2}}+\frac{1}{4^{3}}-\frac{1}{4^{4}}+ \cdot\cdot\cdot +
\frac{(-1)^{n+1}}{4^{n}}\right) \end{gathered} $$
Rotacione a tela. 
Generalizando para k=n, teremos:
$$k=n \rightarrow x_{n+1}=\frac{-x_{n}}{4}-\frac{1}{4}=\frac{-x_{0}}{4^{n}}-\left(\frac{1}{4}-\frac{1}
{4^{2}}+\frac{1}{4^{3}}-\frac{1}{4^{4}}+\cdots+\frac{(-1)^{n+1}}{4^{n}}\right) $$
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 $$$k \rightarrow \infty$$$, então, teremos a primeira parcela $$$\frac{-x_{0}}
{4^{n}} \rightarrow 0$$$ e a PG, sabemos que a soma da progressão infinita é dada por:
$$\frac{a_{0}}{1-q^{\prime}}$$
Rotacione a tela. 
Em que a0 é o termo inicial e q é a razão da PG, logo:
$$\left(\frac{1}{4}-\frac{1}{4^{2}}+\frac{1}{4^{3}}-\frac{1}{4^{4}}+\cdots\right)=\frac{\frac{1}{4}}
{1+\frac{1}{4}}=\frac{1}{5^{\prime}}$$
Rotacione a tela. 
Ou seja, $$$x=-1 / 5$$$ é 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:
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 25/72
$$ 4 x+x+1=0 \rightarrow x=-4 x-1 $$
Rotacione a tela. 
Da mesma maneira, fazendo a equação de iteração:
$$x_{k+1}=-4 x_{k}-1 \text { para } \mathrm{k}=0,1, \ldots \mathrm{n}$$
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.
Decomposição da matriz A
Para determinar equações de iteração, fizemos o seguinte algebrismo:
$$ 5 x=4 x+x $$
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:
$$A=M-N$$
Rotacione a tela. 
Substituindo essa decomposição no sistema linear $$$A x=b$$$, teremos:
$$A x=b \rightarrow(M-N) x=b$$
Rotacione a tela. 
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 26/72

Multiplicando o vetor x, obteremos:
$$ A x=b \rightarrow(M-N) x=b $$
Rotacione a tela. 
Vamos multiplicar a esquerda da equação pela inversa de M:
$$ M^{-1} M x=M^{-1} N x+M^{-1} b \rightarrow x=M^{-1} N x+M^{-1} b $$
Rotacione a tela. 
Substituindo N por M-A e depois realizando a multiplicação matricial, obteremos:
$$ \begin{gathered} x=M^{-1} N x+M^{-1} b \rightarrow x=M^{-1}(M-A) x+M^{-1} b \rightarrow x=\left(I-
M^{-1} A\right) x+M^{-1} b \\ x=x-M^{-1} A x+M^{-1} b \rightarrow x=x+M^{-1}(b-A x) \end{gathered} $$
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:
$$\begin{gathered}r=b-A x \text{ e } p=M^{-1}(b-A x) \rightarrow p=M^{-1} r \rightarrow M p=r \text{ logo }
\\x=x+M^{-1}(b-A x) \rightarrow x=x+p\end{gathered}$$
Rotacione a tela. 
Então, a equação de iteração ficaria da seguinte maneira:
$$ x_{k+1}=x_{k}+p_{k} $$
Rotacione a tela. 
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 27/72
Em que:
$$M p_{k}=r_{k} \quad \textrm{e} \quad r_{k}=b-A x_{k}$$
Rotacione a tela. 
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:
$$ \left[\begin{array}{ccc} 2 & -1 & 0 \\ -1 & 2 & -1 \\ 0 & -1 & 2 \end{array}\right]\left[\begin{array}{l} P_{1}
\\ P_{2} \\ P_{3} \end{array}\right]=\left[\begin{array}{l} 1 \\ 0 \\ 0 \end{array}\right] $$
Rotacione a tela. 
Nosso chute inicial será o vetor $$$x_{0}=[0,0,0]^{T}$$$ 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:
$$ \begin{gathered} {\left[\begin{array}{ccc} 2 & -1 & 0 \\ -1 & 2 & -1 \\ 0 & -1 & 2
\end{array}\right]=\left[\begin{array}{lll} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{array}\right]-
\left[\begin{array}{ccc} -1 & 1 & 0 \\ 1 & -1 & 1 \\ 0 & -1 & -1 \end{array}\right]} \\ M p_{k}=r_{k}
\rightarrow\left[\begin{array}{lll} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{array}\right] p_{k}=r_{k}
\rightarrow p_{k}=r_{k} \end{gathered} $$
Rotacione a tela 
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 28/72
Rotacione a tela. 
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:
$$ \begin{aligned} &\mathrm{r}=[1.0 .0 .]\\ &k=0\\ &x_{k}=[1.0 .0 .]\\ &\mathrm{r}=\left[\begin{array}{lll}
-1.1 . & 0 . \end{array}\right]\\ &k=1\\ &x_{k}=[0.1 .0 .]\\ &r=[2 .-2.1 .]\\ &k=2\\ &x_{k}=[2 .-1.1 .]
\end{aligned} $$
Rotacione a tela. 
Atenção!
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.

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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 29/72
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:
$$ \left[\begin{array}{lll} A_{0,0} & A_{0,1} & A_{0,2} \\ A_{1,0} & A_{1,1} & A_{1,2} \\ A_{2,0} & A_{2,1} &
A_{2,2} \end{array}\right]=\left[\begin{array}{ccc} A_{0,0} & 0 & 0 \\ 0 & A_{1,1} & 0 \\ 0 & 0 & A_{2,2}
\end{array}\right]-\left[\begin{array}{ccc} 0 & -A_{0,1} & -A_{0,2} \\ -A_{1,0} & 0 & -A_{1,2} \\ -A_{2,0} & -
A_{2,1} & 0 \end{array}\right] $$
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:
$$p_{k}[i]=\frac{r_{k}[i]}{A[i, i]}$$
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 
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)
1
2
3
4
5
6
7
8
9
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 30/72
O resultado ao executar a função sol_Jacobi foi:
$$ \begin{gathered} \mathrm{r}=\underline{\underline{[0.00000000 \mathrm{e}+00}} \mathbf{2 . 7 7 5 5
5 7 5 6 \mathrm { e } - 1 6 - 2 . 2 2 0 4 4 6 0 5 \mathrm { e } - 1 6 ]} \\
\mathrm{p}=\underline{\underline{[0.00000000 \mathrm{e}+00}} 1.38777878 \mathrm{e}-16-
1.11022302 \mathrm{e}-16] \\ \mathrm{x}=[0.750 .50 .25] \end{gathered} $$
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:
$$ \left[\begin{array}{lll} A_{0,0} & A_{0,1} & A_{0,2} \\ A_{1,0} & A_{1,1} & A_{1,2} \\ A_{2,0} & A_{2,1} &
A_{2,2} \end{array}\right]=\left[\begin{array}{ccc} A_{0,0} & 0 & 0 \\ A_{1,0} & A_{1,1} & 0 \\ A_{2,0} &
A_{2,1} & A_{2,2} \end{array}\right]-\left[\begin{array}{ccc} 0 & -A_{0,1} & -A_{0,2} \\ 0 & 0 & -A_{1,2} \\ 0 &
0 & 0 \end{array}\right] $$
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.
$$ M p=r \rightarrow\left[\begin{array}{ccc} A_{0,0} & 0 & 0 \\ A_{1,0} & A_{1,1} & 0 \\ A_{2,0} & A_{2,1} &
A_{2,2} \end{array}\right]\left[\begin{array}{l} p_{0} \\ p_{1} \\ p_{2} \end{array}\right]=\left[\begin{array}{l}
r_{0} \\ r_{1} \\ r_{2} \end{array}\right] $$
Rotacione a tela. 
 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)
10
11
12
13
14
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 31/72
Resolvendo-o:
$$ 1^{\circ}-p_{0}=\frac{r_{0}}{A_{0,0}}, 2^{\circ}-p_{1}=\frac{r_{1}-A_{1,0} p_{0}}{A_{1,1}} \quad \textrm{e}
\quad 3^{\circ}-p_{2}=\frac{r_{2}-A_{2,0} p_{0}-A_{2,1} p_{1}}{A_{2,2}} $$
Rotacione a tela. 
Generalizando para um sistema triangular superior de ordem n:
$$ p_{i}=\frac{\left(r_{i}-\sum_{j=0}^{i-1} A_{i, j} p_{j}\right)}{A_{i, i}} \text { para } i=0,1,2 \ldots, n-1 $$
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:
$$ \begin{gathered} k=25 \\ r=[1.49011612 \mathrm{e}-087.45058060 \mathrm{e}-090.00000000
\mathrm{e}+00] \\ p=[7.4505806 \mathrm{e}-097.4505806 \mathrm{e}-093.7252903 \mathrm{e}-09] \\
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 32/72
x=[0.749999990 .499999990 .25] \\ k=26 \\ r=[7.4505806 \mathrm{e}-093.7252903
\mathrm{e}-090.0000000 \mathrm{e}+00] \\ p=[3.72529030 \mathrm{e}-093.72529030
\mathrm{e}-091.86264515 \mathrm{e}-09] \\ x=[0.750 .50 .25] \end{gathered} $$
Rotacione a tela. 
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á!
Vemque eu te explico!
Os vídeos a seguir abordam os assuntos mais relevantes do conteúdo que você acabou de estudar.


06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 33/72
Módulo 2 - Vem que eu te explico!
Métodos Iterativos
Módulo 2 - Vem que eu te explico!
Método de Jacobi

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 34/72
Vamos praticar alguns conceitos?
Falta pouco para atingir seus
objetivos.
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]. 
$$ \left[\begin{array}{cccc}7 & 1 & -1 & 2 \\1 & 8 & 0 & -2 \\-1 & 0 & 4 & -1 \\2 & -2 & -1 &
6\end{array}\right]\left[\begin{array}{l}x_{1} \\x_{2} \\x_{3} \\x_{4}\end{array}\right]=\left[\begin{array}{c}3
\\-5 \\4 \\-3\end{array}\right] $$
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 35/72
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].
$$\left[\begin{array}{ccc}4 & -1 & 1 \\-1 & 4 & -2 \\1 & -2 & 4\end{array}\right]\left[\begin{array}{l}x_{1}
\\x_{2} \\x_{3}\end{array}\right]=\left[\begin{array}{c}12 \\-1 \\5\end{array}\right]$$
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
Responder

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 36/72
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:
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 37/72
$$\begin{array}{|c|c|c|c|c|c|c|c|}\hline \mathrm{x}(\mathrm{m}) & 1 & 2 & 3 & 4 & 5 & 6 & 7 \\\hline
\mathrm{y}(\mathrm{m}) & 1 & 3 & 2 & 4 & 2 & 5 & 4 \\\hline\end{array}$$
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.
Normalmente, é escolhida uma base de n funções $$$ \varphi_{k}(x) $$$ e combina-se linearmente com um
conjunto de $$$ \ n \ $$$ parâmetros indeterminados $$$ c_{k}(k=0,1, \ldots, N-1) $$$ usado para produzir a
seguinte forma linear:
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.


06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 38/72
$$(\mathrm{x_{i}},\mathrm{y_{i}})$$
Rotacione a tela. 
Em que $$p(x)$$ é 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, $$$\left(x_{j},
y_{j}\right)$$$ para $$$j=0,1, \cdots, n-1$$$, que assumimos representar exatamente a função f(x).
Vamos considerar as funções básicas $$$\varphi_{k}(x)$$$ como dadas e tentar determinar os n
parâmetros $$$c_{k}$$$. 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 $$$p(x)$$$ passe exatamente pelos pontos de
dados de entrada, ou seja:
$$y_{j}=\sum c_{k} \varphi_{k}\left(x_{j}\right)$$
Rotacione a tela. 
Em que $$$p\left(x_{j}\right)=y_{j}$$$. Então, podemos reescrever da forma matricial:
$$\left[\begin{array}{ccccc}\varphi_{0}\left(x_{0}\right) & \varphi_{1}\left(x_{0}\right) &
\varphi_{2}\left(x_{0}\right) & \ldots & \varphi_{n-1}\left(x_{0}\right) \\ \varphi_{0}\left(x_{1}\right) &
\varphi_{1}\left(x_{1}\right) & \varphi_{2}\left(x_{1}\right) & \ldots & \varphi_{n-1}\left(x_{1}\right)
\\\varphi_{0}\left(x_{2}\right) & \varphi_{1}\left(x_{2}\right) & \varphi_{2}\left(x_{2}\right) & \ldots &
\varphi_{n-1}\left(x_{2}\right) \\\vdots & \vdots & \vdots & \ddots & \vdots \\ \varphi_{0}\left(x_{n-
1}\right) & \varphi_{1}\left(x_{n-1}\right) & \varphi_{2}\left(x_{n-1}\right) & \ldots & \varphi_{n-1}\left(x_{n-
1}\right) \end{array}\right]\left[\begin{array}{c}c_{0} \\c_{1} \\c_{2} \\\vdots \\c_{n-
1}\end{array}\right]=\left[\begin{array}{c}y_{0} \\y_{1} \\y_{2} \\\vdots \\y_{n-1}\end{array}\right]$$
Rotacione a tela. 
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 39/72
Agora, temos o seguinte problema: a escolha de $$$\varphi_{k}\left(x_{j}\right)$$$. 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:
$$\varphi_{k}(x)=x^{k}$$
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 
Cujo resultado é a imagem a seguir:
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):
 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 40/72
Logo, podemos escrever o polinômio interpolador como:
$$p(x)=\sum c_{k} \varphi_{k}(x)=c_{0}+c_{1} x+c_{2} x^{2}+c_{3} x^{3}+\cdots+c_{n-1} x^{n-1}$$
Rotacione a tela. 
Lembre-se de que a entrada para o problema de interpolação são os pontos $$$\left(x_{j}, y_{j}\right)$$$
para $$$j=0,1,2, \cdots, n-1$$$, dessa maneira:
$$p\left(x_{j}\right)=y_{j}=c_{0}+c_{1} x_{j}^{2}+c_{3} x_{j}^{3}+\cdots+c_{n-1} x_{j}^{n-1}$$
Rotacione a tela. 
Assim, o nosso problema se resume em encontrar os coeficientes $$$c_{j}$$$, ou seja, resolvendo o
sistema linear:
$$\left[\begin{array}{ccccc}1 & x_{0} & x_{0}^{2} & \cdots & x_{0}^{n-1} \\ 1& x_{1} & x_{1}^{2} & \cdots &
x_{1}^{n-1} \\1 & x_{2} & x_{2}^{2} & \cdots & x_{2}^{n-1} \\\vdots & \vdots & \vdots & \ddots & \vdots \\1
& x_{n-1} & x_{n-1}^{2} & \cdots & x_{n-1}^{n-1}\end{array}\right]\left[\begin{array}{c}c_{0} \\c_{1} \\c_{2}
\\\vdots \\ c_{n-1}\end{array}\right]=\left[\begin{array}{c}y_{0} \\y_{1} \\y_{2} \\\vdots \\ y_{n-
1}\end{array}\right]$$
Rotacione a tela. 
Comentário

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 41/72
Vejamos como exemplo o problema do nosso engenheiro de obter a elevação quando x=3,5, com as
observações do topógrafo:
$$\begin{array}{|c|c|c|c|c|c|c|c|}\hline \mathrm{x}(\mathrm{m}) & 1 & 2 & 3 & 4 & 5 & 6 & 7 \\\hline
\mathrm{y}(\mathrm{m}) & 1 & 3 & 2 & 4 & 2 & 5 & 4 \\\hline\end{array}$$
Rotacione a tela. 
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]
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.
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 42/72
>>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:
$$p(x)=c_{0}+c_{1} x+c_{2} x^{2}+c_{3} x^{3}+\cdots+c_{n-1} x^{n-1}$$
Rotacione a tela. 
Basta obter um array dos coeficientes, $$$\text { coef }=\text { np. } \operatorname{array}\left(\left[c_{0},
c_{1}, \ldots, c_{n-1}\right]\right)$$$ 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 solução do sistema linear pode
apresentar dificuldades, logo, existem outras técnicas nas quais não é necessário resolver um
sistema linear.

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 43/72
Método de Lagrange
A ideia principal da interpolação é descobrir um polinômio de grau n tal que
$$$p\left(x_{m}\right)=y_{m}$$$, em que $$$m=0,1, \ldots n$$$, 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 $$$l_{n}$$$, 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 $$$l_{n}\left(x_{m}\right)=y_{m}$$$, então, a fórmula de Lagrange é dada
por:
$$l_{n}(x)=\sum y_{m} L_{n, m}(x)$$
Rotacione a tela. 
Em que definiremos $$$ L_{n, m} $$$ como polinômios de Lagrange básicos e eles têm a seguinte
propriedade:
$$L_{n, m}=\left\{\begin{array}{lll}1 & \text { quando } & x=x_{m} \\0 & \text { quando } & x \neq
x_{m}\end{array}\right.$$
Rotacione a tela. 
Dada por:
$$L_{n, m}(x)=\frac{\Pi\left(x-x_{k}\right)}{\Pi\left(x_{m}-x_{k}\right)}$$
Rotacione a tela. 
Expandindo a fórmula, o polinômio é escrito da seguinte maneira:
$$\begin{gathered}l_{n}(x)=y_{0} \frac{\left(x-x_{1}\right)\left(x-x_{2}\right) \cdots\left(x-x_{n}\right)}
{\left(x_{0}-x_{1}\right)\left(x_{0}-x_{2}\right) \cdots\left(x_{0}-x_{n}\right)}+y_{1} \frac{\left(x-
x_{0}\right)\left(x-x_{2}\right) \cdots\left(x-x_{n}\right)}{\left(x_{1}-x_{0}\right)\left(x_{1}-x_{2}\right)
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 44/72
\cdots\left(x_{1}-x_{n}\right)}+\cdots \\+\cdots+y_{n} \frac{\left(x-x_{0}\right)\left(x-x_{1}\right)
\cdots\left(x-x_{n-1}\right)}{\left(x_{n}-x_{0}\right)\left(x_{n}-x_{1}\right) \cdots\left(x_{n}-x_{N-
1}\right)}\end{gathered}$$
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:
$$l_{2}(x)=\sum y_{k} L_{2, k}(x)$$$$l_{m}(x), m=0,1,2 .$$
Rotacione a tela. 
Temos os seguintes polinômios básicos:
$$ \begin{gathered} L_{2,0}(x)=\frac{\left(x-x_{1}\right)\left(x-x_{2}\right)}{\left(x_{0}-
x_{1}\right)\left(x_{0}-x_{2}\right)}=\frac{(x-0)(x-3)}{(-1-0)(-1-3)}=\frac{x^{2}-3 x}{4} \\ L_{2,1}
(x)=\frac{\left(x-x_{0}\right)\left(x-x_{2}\right)}{\left(x_{1}-x_{0}\right)\left(x_{1}-x_{2}\right)}=\frac{(x+1)
(x-3)}{(0+1)(0-3)}=\frac{x^{2}-2 x-3}{-3} \\ L_{2,2}(x)=\frac{\left(x-x_{0}\right)\left(x-x_{1}\right)}
{\left(x_{2}-x_{0}\right)\left(x_{2}-x_{1}\right)}=\frac{(x+1)(x-0)}{(3+1)(3-0)}=\frac{x^{2}+x}{12}
\end{gathered} $$
Rotacione a tela. 
Fazendo $$$ l_{2}(x)=\sum y_{k} L_{2, k}(x) $$$, teremos:
$$l_{2}(x)=y_{0} L_{0}+y_{1} L_{1}+y_{2} L_{2}$$$$\cdots=(15) \frac{x^{2}-3 x}{4}+(8) \frac{x^{2}-2 x-3}
{-3}+(-1) \frac{x^{2}+x}{12}$$
Rotacione a tela. 
Desenvolvendo a expressão, chegaremos no seguinte resultado:
$$l_{2}(x)=8-6 x+x^{2}$$
Rotacione a tela. 
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 45/72
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, $$$l_{n}$$$, e uma matriz, L, em que cada linha possui os valores dos
coeficientes dos polinômios básicos de Lagrange $$$L_{n, m}$$$:
Python 
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, $$$ l_{2}(x)=8-6 x+x^{2} $$$.
Python 
Resultando na seguinte saída:
Terminal 
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.]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
1
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 46/72
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.
Formade Newton.
Polinômios nodais
Os polinômios nodais são definidos por $$$ \pi_{i}(x) $$$ e dados pela seguinte expressão:
$$\pi_{i}(x)=\prod\left(x-x_{j}\right)$$
Rotacione a tela. 
Em que é fornecido um conjunto de $$$ n+1 $$$ pontos, que também são chamados de nós, $$$ x_{0},
x_{1}, x_{2}, \ldots, x_{n} $$$.
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:
$$\begin{gathered}\pi_{0}=1 \\\pi_{1}=x-x_{0}=x-(-1)=x+1 \\ \pi_{2}=\left(x-x_{0}\right)\left(x-x_{1}\right)=
(x+1)(x+0.5) \\ \pi_{3}=\left(x-x_{0}\right)\left(x-x_{1}\right)\left(x-x_{2}\right)=(x+1)(x+0.5)(x-0)
\\\pi_{4}=\left(x-x_{0}\right)\left(x-x_{1}\right)\left(x-x_{2}\right)\left(x-x_{3}\right)=(x+1)(x+0.5)(x-0)(x-
0.5) \\\pi_{5}=\left(x-x_{0}\right)\left(x-x_{1}\right)\left(x-x_{2}\right)\left(x-x_{3}\right)\left(x-x_{5}\right)
\\=(x+1)(x+0.5)(x-0)(x-0.5)(x-1)\end{gathered}$$
 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
2
3
4
5
6
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 47/72
Rotacione a tela. 
Para construir os gráficos, teremos o seguinte programa em Python:
Python 
Ao executar o script, teremos o seguinte resultado:
Forma de Newton
A forma de Newton é basicamente uma forma de rescrever um polinômio:
$$p(x)=c_{0}+c_{1} x+c_{2} x^{2}+c_{3} x^{3}+\cdots+c_{n-1} x^{n-1}$$
Rotacione a tela. 
Ou seja, essa forma é uma combinação linear dos polinômio nodais, em que são conhecidos os nós $$$
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 48/72
x_{j} $$$. Por questões didáticas, chamaremos esse polinômio escrito na forma de Newton de $$$ n_{N}
$$$, portanto, teremos a seguinte expressão:
$$n_{N}(x)=\sum a_{i} \pi_{i}(x)$$
Rotacione a tela. 
Então, o método de Newton para interpolação é:
Dado $$$ N+1 $$$ pontos $$$ \left(x_{0}, y_{0}\right),\left(x_{1}, y_{1}\right),\left(x_{N}, y_{N}\right) $$$,
encontrar:
$$n_{N}(x)=a_{0}+a_{1}\left(x-x_{0}\right)+a_{2}\left(x-x_{0}\right)\left(x-x_{1}\right)+\cdots+a_{N}\left(x-
x_{0}\right)\left(x-x_{1}\right) \cdots\left(x-x_{N-1}\right)$$
Rotacione a tela. 
Sendo que o problema busca determinar os coeficientes $$$ a_{0}, a_{1}, a_{2}, \cdots, a_{N} \mathrm{e}
$$$ logicamente, respeitando a condição primordial da interpolação:
$$n_{N}\left(x_{j}\right)=y_{j}$$
Rotacione a tela. 
Vamos seguir os seguintes passos para determinar os coeficientes $$$ a_{i} \text { as } $$$:
1) Para os pontos $$$ \left(x_{0}, y_{0}\right) $$$:
$$n_{N}\left(x_{0}\right)=a_{0}=y_{0}$$
Rotacione a tela. 
2) Para $$$ \left(x_{1}, y_{1}\right) $$$:
$$n_{N}\left(x_{1}\right)=a_{0}+a_{1}\left(x_{1}-x_{0}\right)=y_{1}$$$$a_{1}=\frac{y_{1}-y_{0}}{x_{1}-
x_{0}}$$
Rotacione a tela. 
3) Para (x_2,y_2):
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 49/72
$$n_{N}\left(x_{2}\right)=a_{0}+a_{1}\left(x_{2}-x_{0}\right)+a_{2}\left(x_{2}-x_{0}\right)\left(x_{2}-
x_{1}\right)=y_{2}$$
Rotacione a tela. 
Desenvolvendo:
$$a_{2}=\frac{\frac{y_{2}-y_{1}}{x_{2}-x_{1}}-\frac{y_{1}-y_{0}}{x_{1}-x_{0}}}{x_{2}-x_{0}}$$
Rotacione a tela. 
4) Para o terceiro ponto $$$ \left(x_{3}, y_{3}\right) $$$:
$$\begin{aligned}&n_{N}\left(x_{2}\right)=a_{0}+a_{1}\left(x_{3}-x_{0}\right)+a_{2}\left(x_{3}-
x_{0}\right)\left(x_{3}-x_{1}\right)+a_{3}\left(x_{3}-x_{0}\right)\left(x_{3}-x_{1}\right)\left(x_{3}-x_{2}\right)
\\&=y_{3}\end{aligned}$$
Rotacione a tela. 
Da mesma forma, obtemos:
$$a_{3}=\frac{\frac{\frac{y_{3}-y_{2}}{x_{3}-x_{2}}-\frac{y_{2}-y_{1}}{x_{2}-x_{1}}}{x_{3}-x_{1}}-
\frac{\frac{y_{2}-y_{1}}{x_{2}-x_{1}}-\frac{y_{1}-y_{0}}{x_{1}-x_{0}}}{x_{2}-x_{0}}}{x_{3}-x_{0}}$$
Rotacione a tela. 
Generalizando e definindo diferenças divididas:
$$f\left[x_{1}, x_{0}\right]=\frac{y_{1}-y_{0}}{x_{1}-x_{0}}$$$$f\left[x_{0}, x_{1},
x_{2}\right]=\frac{\frac{y_{2}-y_{1}}{x_{2}-x_{1}}-\frac{y_{1}-y_{0}}{x_{1}-x_{0}}}{x_{2}-
x_{0}}=\frac{f\left[x_{2}, x_{1}\right]-f\left[x_{1}, x_{0}\right]}{x_{2}-x_{0}}$$
Rotacione a tela. 
Continuando e generalizando:
$$f\left[x_{k}, x_{k-1}, \cdots, x_{1}, x_{0}\right]=\frac{f\left[x_{k}, x_{k-1}, \cdots, x_{2}, x_{1}\right]-
f\left[x_{k-1}, \cdots, x_{1}, x_{0}\right]}{x_{k}-x_{0}}$$
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 50/72
Rotacione a tela. 
Podemos visualizar esses valores em uma tabela das diferenças divididas (DD):
$$\begin{array}{cccccc}x_{k} & y_{k} & D^{2} f & D^{3} f & D^{4} f & D^{5} f \\ x_{0} & y_{0} & f\left[x_{1},
x_{0}\right] & f\left[x_{2}, x_{1}, x_{0}\right] & f\left[x_{3}, x_{2}, x_{1}, x_{0}\right] & f\left[x_{4}, x_{3}, x_{2},
x_{1}, x_{0}\right] \\x_{1} & y_{1} & f\left[x_{2}, x_{1}\right] & f\left[x_{3}, x_{2}, x_{1}\right] & f\left[x_{4},
x_{3}, x_{2}, x_{1}\right] & 0 \\ x_{2} & y_{2} & f\left[x_{3}, x_{2}\right] & f\left[x_{4}, x_{3}, x_{2}\right] & 0 &
0 \\x_{3} & y_{3} & f\left[x_{4}, x_{3}\right] & 0 & 0 & 0 \\x_{4} & y_{4} & 0 & 0 & 0 & 0\end{array}$$
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:
$$\begin{array}{|c|c|c|c|c|c|c|c|}\hline x(m) & 1 & 2 & 3 & 4 & 5 & 6 & 7 \\\hline y(m) & 1 & 3 & 2 & 4 & 2 & 5
& 4 \\\hline\end{array}$$
Rotacione a tela. 
Em Python, vamos executar o seguinte algoritmo:
Python 
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 51/72
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 
>>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:
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.

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 52/72
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 sistemaslineares, 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.
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á!

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 53/72
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

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 54/72

Vamos praticar alguns conceitos?
Falta pouco para atingir seus
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.
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 55/72
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 56/72
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:
E 1
Responder

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 57/72
Ao observar a tabela a seguir com os valores:
$$\begin{array}{|c|c|c|c|c|c|c|c|} \hline \mathrm{x}(\mathrm{m}) & 1 & 2 & 3 & 4 & 5 & 6 & 7 \\ \hline
\mathrm{y}(\mathrm{m}) & 1 & 3 & 2 & 4 & 2 & 5 & 4 \\ \hline\end{array}$$
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:
$$\begin{array}{cc}x & y \\x_{0} & y_{0} \\x_{1} & y_{1} \\x_{2} & y_{2} \\\vdots & \vdots \\x_{m} &
y_{m}\end{array}$$
Rotacione a tela. 
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.

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 58/72
O primeiro problema de ajuste de curva é determinar a reta que mais se ajusta aos $$$ m+1 $$$ pares
ordenados $$$ \left(x_{i}, y_{i}\right) $$$.
Um exemplo seria determinar o menor erro total absoluto, ou seja, $$$ \phi(a, b)=\sum\left|a x_{i}+b-
y_{i}\right| $$$ .
Na prática, é mais comum resolver a seguinte função: $$$ \phi(a, b)=\sum\left(a x_{i}+b-y_{i}\right)^{2} $$$.
Esse problema é conhecido como aproximação $$$ l_{2} $$$, 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 $$$ l_{1} $$$ e $$$ l_{2} $$$ são formas específicas de medida de distâncias no espaço vetorial.
Uma forma geral é definindo a norma $$$ -p \text { ou } l_{p} $$$, dada por:
$$ \|v\|_{p}=\left\{\sum\left|v_{i}^{p}\right|\right\}^{\frac{1}{p}} 1<p<\infty $$
Para o vetor $$$ v=\left[v_{0}, v_{1}, v_{2}, \cdots, v_{n}\right]^{T} $$$. Para determinar o mínimo, basta fazer
a condição, vista em cálculo:
$$\frac{\partial \phi}{\partial a}=0 \quad \textrm{e} \quad \frac{\partial \phi}{\partial b}=0$$
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 $$$ y_{i}=a x_{i}+b \text { para } i=1,2,3,4,5,6 e 7 $$$ e poderemos escrever na forma
matricial $$$ Ax=b $$$, em que:
$$\left[\begin{array}{ll}x_{1} & 1 \\x_{2} & 1 \\x_{3} & 1 \\x_{4} & 1 \\ x_{5} & 1 \\x_{6} & 1 \\x_{7} &
1\end{array}\right]\left[\begin{array}{l}a \\b\end{array}\right]=\left[\begin{array}{l}y_{1} \\y_{2} \\y_{3}
Comentário
A função $$$ \phi $$$ tem como variáveis $$$ a $$$ e $$$ b $$$, e devemos assumir o menor
valor possível. Essa solução é conhecida como aproximação $$$ l_{1} $$$ e pode ser resolvida
com técnicas de programação linear.

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 59/72
\\y_{4} \\y_{5} \\y_{6} \\y_{7}\end{array}\right]$$
Rotacione a tela. 
Solução é dada pela equação normal: $$$ A^{T} A x=A^{T} y $$$, que corresponde à solução de minimizar a
norma de $$$ \|y-A x\|_{2}^{2} $$$.
Vamos resolver o problema inicial e fazer o ajuste dos dados para uma reta, então, montando a matriz do
sistema $$$ Ax=b $$$, teremos:
$$ \left[\begin{array}{ll} 1 & 1 \\ 2 & 1 \\ 3 & 1 \\ 4 & 1 \\ 5 & 1 \\ 6 & 1 \\ 7 & 1
\end{array}\right]\left[\begin{array}{l} a \\ b \end{array}\right]=\left[\begin{array}{l} 1 \\ 3 \\ 2 \\ 4 \\ 2 \\ 5
\\ 4 \end{array}\right] $$
Rotacione a tela. 
Implementando a solução em Python e visualizando o gráfico:
Python 
O gráfico obtido do ajuste é:
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 60/72
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, $$$ \left(x_{j}, y_{j}\right) $$$
para $$$ j=0,1, \cdots, n-1 $$$, que assumimos querer determinar uma função polinomial $$$ f(x) $$$ mais
próxima dos dados, considerando uma ordem do polinômio $$$ m<n $$$.
Vamos considerar as funções básicas $$$ \varphi_{k}(x) $$$ como dadas e tentar determinar os n
parâmetros $$$ C_{k} $$$.
Podemos determinar todas as incógnitas parâmetros exigindo que nossa função de aproximação $$$ p(x)
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.

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 61/72
$$$ passe exatamente pelos pontos de dados de entrada, isto é:
$$y_{j}=\sum c_{k} \varphi_{k}\left(x_{j}\right)$$
Rotacione a tela. 
Em que $$$ p\left(x_{j}\right) \approx y_{j} $$$. Podemos reescrever da forma matricial:
$$\left[\begin{array}{ccccc}\varphi_{0}\left(x_{0}\right)& \varphi_{1}\left(x_{0}\right) &
\varphi_{2}\left(x_{0}\right) & \cdots & \varphi_{m}\left(x_{0}\right) \\ \varphi_{0}\left(x_{1}\right) &
\varphi_{1}\left(x_{1}\right) & \varphi_{2}\left(x_{1}\right) & \cdots & \varphi_{m}\left(x_{1}\right) \\
\varphi_{0}\left(x_{2}\right) & \varphi_{1}\left(x_{2}\right) & \varphi_{2}\left(x_{2}\right) & \cdots &
\varphi_{m}\left(x_{2}\right) \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ \varphi_{0}\left(x_{n-1}\right)
& \varphi_{1}\left(x_{n-1}\right) & \varphi_{2}\left(x_{n-1}\right) & \cdots & \varphi_{m}\left(x_{n-1}\right)
\end{array}\right]\left[\begin{array}{c}c_{0} \\c_{1} \\c_{2} \\\vdots \\c_{n-
1}\end{array}\right]=\left[\begin{array}{c}y_{0} \\y_{1} \\y_{2} \\\vdots \\y_{n-1}\end{array}\right]$$
Rotacione a tela. 
Semelhante à interpolação, escolheremos $$$ \varphi_{k}\left(x_{j}\right)=x_{j}^{k} $$$, 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 
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
 
1
2
3
4
5
6
7
8
9
10
11
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 62/72
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
funções polinomiais não apresentam uma boa resposta.
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)
 c = np.copy(b)
12
13
14
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 63/72
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, $$$ f(x)=m_{1} \log (x)+m_{2} \cos (x)+m_{3} e^{x} $$$.
Então, queremos ajustar a função $$$ f(x) $$$ com os dados da pandemia dada no problema inicial:
$$\begin{array}{|c|c|c|c|c|c|c|c|} \hline \mathrm{x} \text { (mês) } & 1 & 2 & 3 & 4 & 5 & 6 & 7 \\ \hline
\mathrm{y} \text { (contágio) } & 1 & 3 & 2 & 4 & 2 & 5 & 4 \\ \hline\end{array}$$
Rotacione a tela. 
Pelo MMQ, o problema reside em encontrar o mínimo da função:
$$\phi\left(m_{1}, m_{2}, m_{3}\right)=\sum\left(y_{i}-\left(m_{1} \log \left(x_{i}\right)+m_{2} \cos
\left(x_{i}\right)+m_{3} e^{x_{i}}\right)\right)^{2}$$
Rotacione a tela. 
Ou seja, fazendo:
$$\frac{\partial \phi}{\partial m_{1}}=0 ; \frac{\partial \phi}{\partial m_{2}}=0 ; \frac{\partial \phi}{\partial
m_{3}}=0$$
Rotacione a tela. 
Resultando na equação normal: $$$ A^{T} A m=A^{T} y $$$, que é um sistema linear.
A seguir, apresentaremos uma implementação em Python que resolve esse problema, mas antes vamos ver
como é o sistema $$$ Ax=b $$$, para entender como resolver a equação normal.
Primeiro, devemos notar que cada linha da matriz A tem esse formato:
$$m_{1} \log \left(x_{j}\right)+m_{2} \cos \left(x_{j}\right)+m_{3} e^{x_{j}}=y_{j}$$
Rotacione a tela. 
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 64/72
Portanto, o sistema é:
$$\left[\begin{array}{lll}\log (1) & \cos (1) & e^{1} \\ \log (2) & \cos (2) & e^{2} \\\log (3) & \cos (3) & e^{3}
\\ \log (4) & \cos (4) & e^{4} \\\log (5) & \cos (5) & e^{5} \\ \log (6) & \cos (6) & e^{6} \\\log (7) & \cos (7)
& e^{7} \end{array}\right]\left[\begin{array}{l}m_{1} \\m_{2} \\m_{3} \end{array}\right]=\left[\begin{array}
{l}1 \\3 \\2 \\4 \\2 \\5 \\ 4\end{array}\right]$$
Rotacione a tela. 
Em Python:
Python 
Pelo gráfico gerado, observamos uma queda na pandemia:
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
06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 65/72
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 $$$ Ax=b
$$$; 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.
O formato da função é:
$$f(x)=m_{0}\left(1+e^{m_{1} x}\right)$$
Rotacione a tela. 
Em que $$$ m_{0} \text { e } m_{1} $$$ são parâmetros que queremos determinar.
Observe que é difícil isolar o parâmetro $$$ m_{1} $$$, 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
$$$ g(x)=a_{1} c_{1}^{d_{1}} c_{2}^{d_{2}} c_{3}^{d_{3}} \ldots c_{k}^{d_{k}} $$$ e aplicamos $$$ \log _{b} $$$
em ambos os lados:
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.

06/06/2022 21:26 Sistemas de equações lineares e ajustes de curvas em Python
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html# 66/72
$$\log _{b}(g(x))=\log _{b}(a_{1})+d_{1}\log _{b}(c_{1})+d_{2}\log _{b}(c_{2})+d_{3}\log _{b}(c3)+\cdot
\cdot \cdot+d_{k}\log _{b}(c_{k})$$
Rotacione a tela. 
Portanto, aplicando $$$ \log (f(x)) $$$ obteremos:
$$\log (f(x))=\log \left(m_{0}\right)+m_{1} x$$
Rotacione a tela. 
Fazendo $$$ m_{0}^{\prime}=\log \left(m_{0}\right) \text { e } \log (f(x))=y^{\prime} $$$, teremos:
$$y^{\prime}=m_{0}{ }^{\prime}+m_{1} x$$
Rotacione a tela. 
Chegamos em uma função linear. Para exemplificar, vamos apresentar um programa em Python que
determina os parâmetros $$$ m_{0} $$$ e $$$ m_{1} $$$ da função não linear $$$ f(x) $$$:
Python 
Atenção!
No módulo numpy, a função log é de base e, ou seja, $$$ \log_{e} $$$, embora o número neperiano
e seja omitido, a partir de agora, usaremos a função $$$ log $$$, como o numpy trabalha.

import numpy as np
 import matplotlib.pyplot