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

Prévia do material em texto

Sistemas de equações lineares e ajustes de curvas em Python
Prof. Francisco Roberto da Rocha Gomes
Descrição Sistemas de equações lineares e ajuste de curvas, utilizando exemplos
na linguagem Python, e métodos clássicos para solução de sistemas
lineares na forma direta e iterativas e interpolação de Lagrange e
Newton.
Propósito Solução de sistemas lineares e interpolação e ajuste de curvas é
essencial para formação de um profissional que trabalhará com
modelagem matemática.
Preparação Antes de iniciar o estudo deste conteúdo, pesquise e acesse as páginas
indicadas para a execução dos scripts:
a) Python: https://www.python.org/
b) Jupyter: https://jupyter.org/try
c) Google: https:/research.google.com/colaboratory/
Objetivos
Módulo 1
Métodos diretos para
resolução de sistemas:
Gauss-Jordan e
decomposição LU
Reconhecer os conceitos básicos de
métodos diretos e iterativos.
Módulo 2
Métodos iterativos para
resolução de sistemas:
Gauss-Jacobi e Gauss-Seidel
Aplicar os recursos do Python na solução de
sistemas de equações lineares.
Módulo 3
Interpolação polinomial:
Lagrange e Newton
Analisar os principais métodos de
interpolação.
Módulo 4
Ajuste de funções: funções
polinomiais e linearizáveis
Calcular extrapolações com ajuste de
curvas.
O conteúdo a seguir, divididos em quatro módulos, é o mais importante no
assunto de modelagem matemática, pois, a partir de agora, todos os outros
métodos utilizarão algum tipo de solução de sistemas equações lineares,
seja por meio de métodos diretos, como a eliminação de Gauss, seja por
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.
Introdução
1 - Métodos diretos para resolução de sistemas: Gauss-Jordan e
decomposição LU
Ao �nal deste módulo, você será capaz de reconhecer os conceitos básicos de métodos diretos e
iterativos.
Soluções de sistemas lineares
A interpolação, por muito tempo, foi a ferramenta mais utilizada, eram
comuns publicações de diversas tabelas de valores calculados de funções
complexas. Para obter um valor que não estava tabelado, usava-se
interpolação. A teoria de interpolação é muito importante para entender
outros métodos de modelagem matemática, como a integração numérica.
Por fim, apresentaremos técnicas de ajuste de curvas, que nos permitem
realizar extrapolações, a partir de dados coletados em experimentos e
observações. O ajuste de curvas tem uma ligação estreita com estatística,
tanto que as soluções são estimativas que dependem das observações e do
modelo matemático.
Solução de sistemas lineares é umas das mais importantes nos métodos
numéricos. Para exemplificar os métodos, usaremos um problema, que será o
nosso modelo para apresentar alguns métodos diretos de resolução de
sistemas.
Problema
Suponha que um objeto possa estar em qualquer lugar dos n+1 pontos
uniformemente espaçados . Quando um objeto se encontra no
lugar , ele tem a mesma probabilidade de se mover para ou para ,
mas não pode ir diretamente para nenhum outro lugar.
Considere as probabilidades de que um objeto que parte do lugar 
chegue ao extremo esquerdo antes de alcançar o extremo direito . Dado
que o objeto pode mover-se até apenas a partir de ou de e o faz
com a probabilidade 1/2 para cada um desses lugares:
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:
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
Substituindo e e colocando na forma matricial, teremos:
Como foi sugerido no problema, chamaremos de A a matriz:
E de p e b, respectivamente, os vetores:
2P1 − P2 = P0
−P1 + 2P2 − P3 = 0
−P2 + 2P3 = P4
P0 = 1 P4 = 0
=
⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦e⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦Comentário
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 elemento zero.
O principal método que vamos abordar e que será a
semente para os outros é a eliminação de Gauss. O
princípio desse método é criar uma matriz que
definimos como matriz aumentada do sistema, [A|b],
ou seja, acrescentar uma coluna na matriz A igual ao
vetor b.
[A ∨ b] =
⎡⎢⎣ 2 −1 0 1−1 2 −1 00 −1 2 0⎤⎥⎦= ⎡⎢⎣ 2 −1 0 1−1 2 −1 00 −1 2 0⎤⎥⎦m = −1/2Linha(2) = Linha(2) − m × Linha(1)
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)
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:
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
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
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:

=
⎡⎢⎣2 −1 00 3/2 −10 0 4/3⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣ 11/22/6⎤⎥⎦
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:
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.
=
⎡⎢⎣U0,0 U0,1 U0,20 U1,1 U1,20 0 U2,2⎤⎥⎦ ⎡⎢⎣x0x1x2⎤⎥⎦ ⎡⎢⎣c0c1c2⎤⎥⎦1∘ − x2 = c2U2,2 , 2∘ − χ1 = c1 − U1,2x2U1,1 e3∘ − χ0 = cxi = (ci − ∑n−1j=i+1 Ui,jxj)Ui,i  para i = n − 1,n − 2, …
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 oselementos 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:
xi =
(ci − ∑n−1j=i+1 Ui,jxj)
Ui,i
 para i = n − 1,n − 2, …
x[i] = (c[i] − U [i, i + 1 : [@x[i + 1 :])/U [i, i]
xi =
(ci − ∑n−1j=i+1 Ui,jxj)
Ui,i
Atenção!

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:
Utilizaremos esta linha de código:
Python 
Devemos atentar para o comando @, que faz a
multiplicação matricial, ou seja, se temos duas
matrizes A e B, o produto matricial de AB em Python
é A@B. Da mesma maneira, quando queremos
realizar o produto escalar de dois vetores v e u.
v ⊙ u = ∑n−1i viui
=
⎡⎢⎣2 −1 00 3/2 −10 0 4/3⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣ 11/22/6⎤⎥⎦
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 
Com isso, podemos definir uma função que realiza a eliminação de Gauss:
Python 
(k + 1, k + 2, … . n − 1)
Ak,k
linh a(i) = linh a(i) − m × linh a( pivô ),  onde m =
linha(i) = linha(i) − m × linha( pivô ),  onde m =
A
A
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 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦
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:
[A ∨ b] =
⎡⎢⎣ 2 −1 0 1−1 2 −1 00 −1 2 0⎤⎥⎦Atenção!Observe que já foi colocada a matriz aumentada dosistema.
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.
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.
A[k, k] = A[0, 0] = 2,
⎡⎢⎣ 1 −1/2 0 1/2−1 2 −1 00 −1 2 0 ⎤⎥⎦m = A[i, k]/A[k, k]m = A[1, 0]/A[0, 0] A[0, 0] = 1m = A[1, 0] = −1linha(i) = linha(i) − m × linha(k)⎡⎢⎣1 −1/2 0 1/20 3/2 −1/2 1/20 −1 2 0 ⎤⎥⎦
O resultado final é o sistema equivalente, Rx=d:
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 
⎡⎢⎣1 0 0 3/40 1 0 1/20 0 1 1/4⎤⎥⎦Atenção!Note que o vetor d = x, ou seja, a solução do sistema.
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 triangular inferior, para o qual apresentaremos o
algoritmo de solução, que definiremos como substituição sucessiva.
=
⎡⎢⎣A0,0 A0,1 A0,2A1,0 A1,1 A1,2A2,0 A2,1 A2,2⎤⎥⎦ ⎡⎢⎣ 1 0 0L1,0 1 0L2,0 L2,1 1⎤⎥⎦ ⎡⎢⎣U0,0 U0,10 U1,10 0Ax = b → L Uxc = bUx = c
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 
Lc = b
=
⎡⎢⎣L0.0 0 0L1,0 L1.1 0L2,0 L2,1 L2.2⎤⎥⎦ ⎡⎢⎣c0c1c2⎤⎥⎦ ⎡⎢⎣b0b1b2⎤⎥⎦1∘ − c0 = b0L0,0 , 2∘ − c1 = b1 − L1,0c0L1,1 e 3∘ − c2ci = (bi − ∑i−1j=0 Li,jcj)Li,i  para i = 0, 1, 2 … ,n − 1
E a solução por decomposição LU é dada por:
Python 
Como exemplo, resolveremos o nosso problema original:
Python 
=
⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦
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

Questão 1
O comando em Python: A=np.array([[1,2,3],[4,5,6]]), resulta em.

Vamos praticar
alguns conceitos?
Falta pouco
para atingir
seus
objetivos.
A um vetor de ordem 1 por 2.
B um vetor de ordem 2 por 1.
C uma matriz 3x3.
D uma matriz 3x2.
E uma matriz 2x3.
Questão 2
Na decomposição da matriz A= LU, as matrizes L e U são respectivamente
Responder
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.
Responder
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; simplesmenteutiliza 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:
=
⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦
Método iterativo
Vamos apresentar como é o processo iterativo, e, para isso, resolveremos uma
equação linear do 1º grau bem simples, utilizando a técnica dos métodos
iterativos.
Vamos usar o seguinte exemplo:
Encontrar o valor de x na equação .
É fácil de verificar que resolve o problema, mas vamos solucionar de
um modo diferente. Primeiro, notamos e substituímos na
equação:
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:
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
+
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.
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
k = n → xn+1 =
−xn
4
−
1
4
=
−x0
4n
− ( 1
4
−
1
42
+
k → ∞ −x04n → 0
a0
1 − q ′
( 1
4
−
1
42
+
1
43
−
1
44
+ ⋯) =
1
4
1 + 14
=
1
5′
x = −1/5
4x + x + 1 = 0 → x = −4x − 1
xk+1 = −4xk − 1 para k = 0, 1, … n
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:
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 −
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;
x = M −1Nx + M −1b → x = M −1(M − A)x + M −1
x = x − M −1Ax + M −1b → x = x
r = b − Ax e p = M −1(b − Ax) → p = M −1r → Mp
x = x + M −1(b − Ax) → x = x + p
xk+1 = xk + pk
Mpk = rk e rk = b − Axk
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.
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 
=
⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣P1P2P3⎤⎥⎦ ⎡⎢⎣100⎤⎥⎦x0 = [0, 0, 0]T= −Mpk = rk → pk = rk → pk = rk⎡⎢⎣ 2 −1 0−1 2 −10 −1 2 ⎤⎥⎦ ⎡⎢⎣1 0 00 1 00 0 1⎤⎥⎦ ⎡⎢⎣−1 1 01 −1 10 −1 −1⎤⎥⎦⎡⎢⎣1 0 00 1 00 0 1⎤⎥⎦
Ao executar o programa, a saída será a seguinte:
Vamos ver como fica com os dois métodos de Jacobi e Gauss-Seidel.
r = [1.0.0. ]
k = 0
xk = [1.0.0. ]
r = [ ]
k = 1
xk = [0.1.0. ]
r = [2. −2.1. ]
k = 2
xk = [2. −1.1. ]
−1.1. 0.
Atenção!
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.

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,2A1,0 A1,1 A1,2A2,0 A2,1 A2,2⎤⎥⎦ ⎡⎢⎣A0,0 0 00 A1,1 00 0 A2,2⎤⎥⎦ ⎡⎢⎣ 0−A1−A2pk[i] = rk[i]A[i, i]
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:
r = [0.00000000e + 002. 77555756e − 16 − 2. 220
p = [0.00000000e + 001.38777878e − 16 − 1.1102
x = [0.750.50.25]
––
––
= −
⎡⎢⎣A0,0 A0,1 A0,2A1,0 A1,1 A1,2A2,0 A2,1 A2,2⎤⎥⎦ ⎡⎢⎣A0,0 0 0A1,0 A1,1 0A2,0 A2,1 A2,2⎤⎥⎦ ⎡⎢⎣0 −00Mp = r → =⎡⎢⎣A0,0 0 0A1,0 A1,1 0A2,0 A2,1 A2,2⎤⎥⎦ ⎡⎢⎣p0p1p2⎤⎥⎦ ⎡⎢⎣r0r1r2⎤⎥⎦
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 
O resultado ao executar a função sol_GaussSeideil foi:
1∘ − p0 =
r0
A0,0
, 2∘ − p1 =
r1 − A1,0p0
A1,1
e 3∘ − p2
pi =
(ri − ∑i−1j=0 Ai,jpj)
Ai,i
 para i = 0, 1, 2 … ,n − 1
Valor de x convergiu na vigésima sexta iteração.
Resolução de Sistemas
Acompanhe agora um exemplo de exercício resolvido, utilizando códigos em
Python aplicados às resoluções de sistemas pelo método de Gauss-Jacobi.
Vamos lá!
Vem que eu te explico!
Os vídeos a seguir abordam os assuntos mais relevantes do
conteúdo que você acabou de estudar.
Módulo 2 - Vem que eu te explico!
Métodos Iterativos
k = 25
r = [1.49011612e − 087.45058060e − 090.00000000e
p = [7.4505806e − 097.4505806e − 093.7252903e −
x = [0.749999990.499999990.25]
k = 26
r = [7.4505806e − 093.7252903e − 090.0000000e +
p = [3.72529030e − 093.72529030e − 091.86264515e
x = [0.750.50.25]


Módulo 2 - Vem que eu te explico!
Método de Jacobi

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].
Questão 2
Vamos praticar
alguns conceitos?
=
⎡⎢⎣ 7 1 −1 21 8 0 −2−1 0 4 −12 −2 −1 6⎤⎥⎦ ⎡⎢⎣x1x2x3x4⎤⎥⎦ ⎡⎢⎣ 3−54−3⎤⎥⎦A [1,1,1,1] e k=10B [-1,-1,-1,-1] e k=14C [1,-1,1,-1] e k=10D [1,-1,1,-1] e k=14E [1,1,1,1] e k=14 Responder
Usando o método iterativo Jacobi, resolva o sistema linear a seguir e
encontre o número de iterações utilizadas, use como chute inicial x_0=[0,0,0].
=
⎡⎢⎣ 4 −1 1−1 4 −21 −2 4 ⎤⎥⎦ ⎡⎢⎣x1x2x3⎤⎥⎦ ⎡⎢⎣ 12−15 ⎤⎥⎦A [1,1,1] e k=49B [-1,-1,-1] e k=61C [3,1,1,] e k=49D [3,1,1] e k=61E [3,1,1] e k=49 Responder
3 - Interpolação polinomial: Lagrange e Newton
Ao �nal deste módulo, você será capaz de analisar os principais métodos de interpolação.
Considerações iniciais
Um engenheiro recebeu um projeto de instalação de uma rede elétrica em uma
rodovia na região norte do país, e será necessário instalar postes e calcular
quantos metros de fios serão utilizados, mas para isso precisaremos de um
levantamento altimétrico do perfil da rodovia.
Um levantamento altimétrico consiste em obter as alturas ao longo de um eixo,
no nosso caso, no eixo principal da rodovia, como ilustra a imagem a seguir:
O engenheiro solicita ao topógrafo mensurar as alturas e fornece uma tabela
com os seguintes dados:
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:
x(m) 1 2 3 4 5 6 7
y(m) 1 3 2 4 2 5 4
Comentário
Com esses dados, o engenheiro quer saber qual será
a altura (y) quando a distância (x) for igual a 3,5
metros. No entanto, o topógrafo não mensurou essa
distância, então, uma solução é fazer uma
interpolação para obter o desejado.

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
é 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).

φk(x)
 n 
ck(k = 0, 1, … ,N − 1)
(xi, yi)
p(x)
(xj, yj) j = 0, 1, ⋯ ,n − 1
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:
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 
φ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−φk (xj)φk(x) = xk
Cujo resultado é a imagem a seguir:
Logo, podemos escrever o polinômio interpolador como:
Lembre-se de que a entrada para o problema de interpolação são os pontos
 para , dessa maneira:
p(x) = ∑ ckφk(x) = c0 + c1x + c2x2 + c3x3 + ⋯ +
(xj, yj) j = 0, 1, 2, ⋯ ,n − 1
Assim, o nosso problema se resume em encontrar os coeficientes , ou seja,
resolvendo o sistema linear:
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 
p (xj) = yj = c0 + c1x2j + c3x
3
j + ⋯ + cn−1x
n−1
j
cj
=
⎡⎢⎣1 x0 x20 ⋯ xn−101 x1 x21 ⋯ xn−111 x2 x22 ⋯ xn−12⋮ ⋮ ⋮ ⋱ ⋮1 xn−1 x2n−1 ⋯ xn−1n−1⎤⎥⎦ ⎡⎢⎣ c0c1c2⋮cn−1⎤⎥⎦ ⎡⎢⎣ y0y1y2⋮yn−1⎤⎥⎦ComentárioObserve que a matriz do sistema acima é bemconhecida na Matemática, é a matriz deVandermonde e o determinante dessa matriz sempreé diferente de zero, isto é, o sistema possui umaúnica solução. x(m) 1 2 3 4 5 6 7y(m) 1 3 2 4 2 5 4
Ao executar o programa, teremos a seguinte saída:
>>coeficientes de p é [-1.15000000e+02 2.65150000e+02 -2.22933333e+02
9.12708333e+01 -1.94791667e+01 2.07916667e+00 -8.75000000e-02]
>>o valor da elevação para x=3,5 é igual a p(3.5)= 3.405273437500057
E o gráfico do polinômio interpolador é:
Vamos destacar algumas linhas do programa.
Logo no início, encontramos a linha import numpy.polynomial.polynomial as
poly, a qual informa que usaremos os métodos do numpy, que trabalha com
polinômios, e vamos “apelidá-lo” de poly.
Basicamente, se queremos trabalhar com um polinômio:
Basta obter um array dos coeficientes,
 e para trabalhar com o polinômio,
escrevemos a seguinte linha de comando p =poly.Polynomial(coef), como foi
feito na antepenúltima linha do script anterior. Depois, para determinar o valor de
p(x) quando x=3,5, é só escrever p(3.5), como foi colado no comando print na
penúltima linha.
Outra linha que vamos destacar é a linha: A=np.vander(x, increasing=True). Esse
comando cria uma matriz de Vandermonde dado o array x, que é a entrada da
função monômio (x,y) criada.
Método de Lagrange
A ideia principal da interpolação é descobrir um polinômio de grau n tal que
, em que , e essa premissa será respeitada no
método de Lagrange.
Para fazer distinção do método a ser empregado, vamos definir o polinômio
obtido pelo método de Lagrange por , em que N é o grau do polinômio.
p(x) = c0 + c1x + c2x2 + c3x3 + ⋯ + cn−1xn−1
 coef  =  np.  array ([c0, c1, … , cn−1])
Comentário
Pronto, poderíamos parar por aqui, pois o problema
encontra-se resolvido, mas computacionalmente, a
solução encontra um problema: a solução do sistema
linear pode apresentar dificuldades, logo, existem
outras técnicas nas quais não é necessário resolver
um sistema linear.

p (xm) = ym m = 0, 1, …n
ln
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:
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
(x1
+ ⋯ + yn
(x − x0) (x − x1) ⋯
(xn − x0) (xn − x1) ⋯
l2(x) = ∑ ykL2,k(x)
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 
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)
L2,1(x) =
(x − x0) (x − x2)
(x1 − x0) (x1 − x2)
=
(x + 1)(x − 3)
(0 + 1)(0 − 3)
=
L2,2(x) =
(x − x0) (x − x1)
(x2 − x0)(x2 − x1)
=
(x + 1)(x − 0)
(3 + 1)(3 − 0)
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 + x
2
ln
Ln,m
Executando os seguintes comandos, utilizando os dados do exemplo, obtemos
os resultados l_2 = [8. -6. 1.], que são os coeficientes do polinômio obtido,
.
Python 
Resultando na seguinte saída:
Terminal 
A seguir, apresentaremos o método de Newton para obter o mesmo resultado.
Método de Newton
l2(x) = 8 − 6x + x2
Para entender o método de Newton, primeiramente, precisamos de algumas
definições:
Polinômio nodal.
Forma de Newton.
Polinômios nodais
Os polinômios nodais são definidos por e dados pela seguinte expressão:
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:
πi(x)
πi(x) = ∏ (x − xj)
n + 1
x0,x1,x2, … ,xn
π0 = 1
π1 = x − x0 = x − (−1) = x +
π2 = (x − x0) (x − x1) = (x + 1)(x
π3 = (x − x0) (x − x1) (x − x2) = (x + 1)(x
π4 = (x − x0) (x − x1) (x − x2) (x − x3) = (x + 1)(x
π5 = (x − x0) (x − x1) (x − x2) (x − x3
= (x + 1)(x + 0.5)(x − 0)(x − 0.5)
Python 
Ao executar o script, teremos o seguinte resultado:
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:
Vamos seguir os seguintes passos para determinar os coeficientes :
1) Para os pontos :
2) Para :
p(x) = c0 + c1x + c2x2 + c3x3 + ⋯ + cn−1xn−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) + ⋯
a0, a1, a2, ⋯ , aNe
nN (xj) = yj
ai as 
(x0, y0)
nN (x0) = a0 = y0
(x1, y1)
nN (x1) = a0 + a1 (x1 − x0) = y1
a1 =
y1 − y0
x1 − x0
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:
nN (x2) = a0 + a1 (x2 − x0) + a2 (x2 − x0) (x2 − x1
a2 =
y2−y1
x2−x1
− y1−y0x1−x0
x2 − x0
(x3, y3)
nN (x2) = a0 + a1 (x3 − x0) + a2 (x3 − x0) (x3 − x1
= 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,x
x2 − x0
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 
f [xk,xk−1, ⋯ ,x1,x0] =
f [xk,xk−1, ⋯ ,x2,x1] − f
xk − x0
xk yk D
2f D3f D4f
x0 y0 f [x1,x0] f [x2,x1,x0] f [x3,x2,x1,x0]
x1 y1 f [x2,x1] f [x3,x2,x1] f [x4,x3,x2,x1]
x2 y2 f [x3,x2] f [x4,x3,x2] 0
x3 y3 f [x4,x3] 0 0
x4 y4 0 0 0
x(m) 1 2 3 4 5 6 7
y(m) 1 3 2 4 2 5 4
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
E o seguinte gráfico:
Cada método tem um diferencial. Veja quais são eles:
Método com
base
monomial
Este método
necessita de
uma solução
Método de
Lagrange
Este método
não necessita
resolver um
sistema linear,
Método de
Newton
Este método
tem uma
vantagem: a de
acrescentar um
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.

de sistemas
lineares, o que
não é
adequado
quando a
quantidade de
pontos é
grande.
no entanto,
caso queira
acrescentar um
ponto,
devemos
repetir todo o
cálculo, o que
não ocorre com
o método de
Newton.
ponto no
conjunto dado
e, assim,
aproveitar o
resultado
obtido.
Interpolação de Lagrange e Newton
Acompanhe um exemplo de exercício resolvido, utilizando códigos em Python
aplicados às interpolações de Lagrange e Newton. Vamos lá!
Vem que eu te explico!
Os vídeos a seguir abordam os assuntos mais relevantes do
conteúdo que você acabou de estudar.


Módulo 3 - Vem que eu te explico!
Método de Lagrange
Módulo 3 - Vem que eu te explico!
Método de Newton
Questão 1
Um conjunto de pontos possui 6 coordenadas (x,y), logo, por interpolação, o
grau do polinômio interpolador é

Vamos praticar
alguns conceitos?
Falta pouco
para atingir
seus
objetivos.
A 7.
B 6.
C 5.
D 4.
E 3.
Questão 2
Em uma interpolação linear são necessários quantos pontos (coordenadas)?
Responder
A 5
B 4
C 3
D 2
E 1
Responder
4 - Ajuste de funções: funções polinomiais e linearizáveis
Ao �nal deste módulo, você será capaz de calcular extrapolações com ajuste de curvas.
Considerações iniciais
Durante uma pandemia de um vírus X, foi observado um número de pessoas
contagiadas durante 7 meses, como mostra o gráfico a seguir:
Ao observar a tabela a seguir com os valores:
Vamos apresentar formas de ajustes de polinômios e de outros tipos de funções
que nos ajudarão a resolver esse problema.
x(m) 1 2 3 4 5 6 7
y(m) 1 3 2 4 2 5 4
Comentário
Deseja-se estimar o número de contágio no oitavo
mês e se há tendência de queda. A solução é fazer
um ajuste de curvas para obter o desejado.

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:
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,
 .
Na prática, é mais comum resolver a seguinte função:
. Esse problema é conhecido como aproximação
, ou método dos mínimos quadrados (MMQ), cuja solução é a mais usada, pois
encontra-se alinhada com a distribuição normal.
x y
x0 y0
x1 y1
x2 y2
⋮ ⋮
xm ym
m + 1 (xi, yi)
ϕ(a, b) = ∑ |axi + b − yi|
Comentário
A função tem como variáveis e , e devemos
assumir o menor valor possível. Essa solução é
conhecida como aproximação e pode ser resolvida
com técnicas de programação linear.

ϕ a b
l1
ϕ(a, b) = ∑ (axi + b − yi)
2
l2
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:
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:
l1 l2
−p ou lp
∥v∥p = {∑ |vpi |}
1
p
1 < p < ∞
v = [v0, v1, v2, ⋯ , vn]
T
∂ϕ
∂a
= 0 e
∂ϕ
∂b
= 0
yi = axi + b para i = 1, 2, 3, 4, 5, 6e7
Ax= b
[ ] =
⎡⎢⎣x1 1x2 1x3 1x4 1x5 1x6 1x7 1⎤⎥⎦ ab ⎡⎢⎣y1y2y3y4y5y6y7⎤⎥⎦ATAx = ATy∥y − Ax∥22Ax = b
Implementando a solução em Python e visualizando o gráfico:
Python 
O gráfico obtido do ajuste é:
[ ] =
⎡⎢⎣1 12 13 14 15 16 17 1⎤⎥⎦ ab ⎡⎢⎣1324254⎤⎥⎦
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 .
(xj, yj) j = 0, 1, ⋯ ,n − 1
f(x)
m < n
φk(x)
Ck
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
é:
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.
Atenção!
Observe que temos m incógnitas e n pontos de
dados, logo, possuímos um sistema sobre
determinação, ou seja, temos mais equações que
incógnitas.

p(x)
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)φk (xj) = xkj
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.
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
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.

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) + m3ex
f(x)
x (mês)  1 2 3 4 5 6 7
y (contágio)  1 3 2 4 2 5 4
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
∂ϕ
∂m1
= 0;
∂ϕ
∂m2
= 0;
∂ϕ
∂m3
= 0
ATAm = ATy
Ax = b
m1 log (xj) + m2 cos (xj) + m3e
xj = yj
=
⎡⎢⎣log(1) cos(1) e1log(2) cos(2) e2log(3) cos(3) e3log(4) cos(4) e4log(5) cos(5) e5log(6) cos(6) e6log(7) cos(7) e7⎤⎥⎦⎡⎢⎣m1m2m3⎤⎥⎦ ⎡⎢⎣1324254⎤⎥⎦
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.
Ax = b
Comentário
Um sistema não linear possui técnicas para ser
resolvido e parte do princípio de linearizá-lo, mas o
que vamos apresentar aqui é um pouco diferente,

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:
pois não vamos trabalhar na linearização do sistema,
e sim na linearização da função.
f(x) = m0 (1 + e
m1x)
m0 e m1
m1
g(x) = a1c
d1
1 c
d2
2 c
d3
3 … c
dk
k logb
logb(g(x)) = logb(a1) + d1 logb(c1) + d2 logb(c2) + d3
Atenção!

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 
No módulo numpy, a função log é de base e, ou seja,
, embora o número neperiano e seja omitido, a
partir de agora, usaremos a função , como o
numpy trabalha.
loge
log
log(f(x))
log(f(x)) = log (m0) + m1x
m′0 = log (m0) e  log(f(x)) = y
′
y′ = m0 ′ + m1x
m0 m1
f(x)
Funções polinomiais
Acompanhe agora um exemplo de exercício resolvido, utilizando códigos em
Python aplicados às funções polinomiais. Vamos lá!
Vem que eu te explico!
Os vídeos a seguir abordam os assuntos mais relevantes do
conteúdo que você acabou de estudar.
Módulo 4 - Vem que eu te explico!
Ajuste de funções polinomiais


Módulo 4 - Vem que eu te explico!
Funções Linearizáveis

Vamos praticar
alguns conceitos?
Falta pouco
para atingir
seus
objetivos.
Questão 1
O ajuste de um conjunto de dados com uma função é
dita
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.
Responder
ATAx = ATy
A equação de ajuste.
B equação de Gauss.
C equação literarizável.
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
D equação normal.
E jacobiana.
Responder

Ouça agora uma revisão dos principais conceitos e desafios abordados
neste material.
00:00 04:56
1x
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: PioneiraThompson
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.

https://stecine.azureedge.net/repositorio/00212ti/02797/index.html
https://stecine.azureedge.net/repositorio/00212ti/02797/index.html
Material para download
Clique no botão abaixo para fazer o download do conteúdo
completo em formato PDF.
Download material
O que você achou do conteúdo?
Relatar problema
javascript:CriaPDF()