Вы находитесь на странице: 1из 20

Escola Politécnica da Universidade de São Paulo

MAP-3121 – Métodos Numéricos e Aplicações

Relatório do Exercício Programa 1

João Pedro Cunha Machado da Silva – 9834991


Jonathan Vieira de Carvalho - 9835279

Docente: Professor Doutor Nelson Mugayar Kuhl


Turma 10

Maio de 2018
São Paulo
Sumário
1. Introdução ............................................................................................................................. 3
2. Metodologia .......................................................................................................................... 3
3. Resultados ........................................................................................................................... 10
4. Funções implementadas ..................................................................................................... 11
a. matriz_zeros .................................................................................................................... 11
b. matriz_identidade ........................................................................................................... 11
c. prodMatrix ...................................................................................................................... 11
d. transposeMatrix .............................................................................................................. 12
e. decompoe........................................................................................................................ 12
f. eliminacao_Gauss............................................................................................................ 13
g. localização ....................................................................................................................... 14
5. Testes complementares ...................................................................................................... 14
a. Teste 1 ............................................................................................................................. 14
b. Teste 2 ............................................................................................................................. 15
c. Teste 3 ............................................................................................................................. 16
6. Conclusão ............................................................................................................................ 20
1. Introdução
GPS é a sigla para Global Positioning System, que em português significa “Sistema
de Posicionamento Global”, e consiste numa tecnologia de localização por satélite. Este
é um sistema de navegação por satélite a partir de um dispositivo móvel, que envia
informações sobre a posição de algo em qualquer horário e em qualquer condição
climática. O sistema de GPS funciona graças a um conjunto de 24 satélites que
circundam a Terra, numa altitude de aproximadamente 20,200 km e a uma velocidade
de quase 11,500 Km/h. Em qualquer lugar do mundo, o aparelho receptor (o dispositivo
GPS) capta as informações de um grupo de quatro destes satélites e, através da troca
de alguns dados e algoritmos, consegue determinar para o utilizador a sua exata
localização no mapa. Hoje em dia, o GPS é usado nos mais diversos aspectos da vida
cotidiana das pessoas, seja como um direcionamento de navegação (na aviação,
marítima ou de automóveis) ou para encontrar uma localização específica no mapa. O
GPS tem a principal função de encontrar o caminho para um determinado local, saber
a velocidade e a direção do seu deslocamento. Atualmente, este sistema é muito
utilizado em automóveis, com um sistema de mapas que facilita bastante o
descobrimento de trajetos mais rápidos entre dois pontos, por exemplo.
Este trabalho tem como objetivo a construção de um código que a partir de uma
tabela contendo as distâncias de diversos satélites em relação a um ponto possa dar as
coordenadas do ponto no globo com o menor erro possível.

2. Metodologia
O primeiro passo da solução do problema foi criar um código que conseguisse obter
as informações necessárias a partir de um arquivo .txt, o qual contém na primeira linha
o número de satélites e nas linhas abaixo temos uma matriz n×4 contendo os valores
xi, yi, zi e wi em metros, onde i varia entre 1 a n (número de satélites). Wi corresponde
a c * ti, onde c é a velocidade da luz e ti é o lapso de tempo aparente. Dessa forma,
criou-se duas variáveis: uma para receber os valores do número de satélites e a outra
uma matriz nx4 que recebe os valores xi, yi, zi e wi. Como o texto é uma string, houve
uma mudança do tipo de variável de string para int ou string para float. Tal fato foi feito
para que pudesse usar os valores numéricos dos dados nas operações.

Para isso foi formulado o seguinte código:


Aqui n representa o número de satélites e matriz gps representa a Figura X

Os dados utilizados no exercício programa está mostrado a seguir:

• Número de satélites: 7
• Coordenadas dos pontos
x(m) y(m) z(m) w(m)
16.577.402 5.640.461 20.151.933 20432524
11.793.840 -10.611.621 21.372.809 21434024,4
20.141.014 -17.040.472 2.512.131 24556171
22.622.494 -4.288.365 13.137.556 21315100,2
12.867.750 15.820.033 16.952.443 21255217
-3.189.257 -17.447.568 20.051.401 24441547,2
-7.437.756 13.957.665 21.692.378 23768678,3

As coordenadas (x,y,z) do receptor devem satisfazer as seguintes relações:

Onde i varia entre 1 a n.

Esse conjunto de equações formam um sistema sobredeterminado de 4


incógnitas com n equações. Como as medidas estão sujeitas a erros, este sistema em
geral não tem solução. A maneira abordada para a solução desse sistema é trata-lo
como um problema de minímos quadrados, procurando minimizar a soma dos
quadrados dos resíduos ri, ou seja, achar x, y, z e w que minimizam a função
Esse problema não é linear. Dessa forma, para trabalharmos com sistemas
lineares subtraiu a linha ri pela linha rn (última linha). Isso permitiu obter a seguinte
relação:

2 ∗ (𝑥𝑛 − 𝑥𝑖) ∗ 𝑥 + 2 ∗ (𝑦𝑛 − 𝑦𝑖) ∗ 𝑦 + 2 ∗ (𝑧𝑛 − 𝑧𝑖) ∗ 𝑧 + 2 ∗ (𝑤𝑖 − 𝑤𝑛) ∗ 𝑤 =


𝑥𝑛2 − 𝑥𝑖 2 +𝑦𝑛2 − 𝑦𝑖 2 + 𝑧𝑛2 − 𝑧𝑖 2 + 𝑤𝑖 2 − 𝑤𝑛2

Se A denota a matriz do sistema linear, x o vetor incógnita (x, y ,z, w) e b o lado


direito do sistema linear, a solução de Ax = b no sentido de mínimos quadrados é a
solução do sistema normal

𝐴𝑇 ∗ 𝐴 ∗ 𝑥 = 𝐴𝑇 ∗ 𝑏

Tal solução será a aproximação inicial do problema em questão.

Primeiramente criou-se um vetor linha 1x4 que continha na primeira coluna o


valor de x da última linha n da matriz gps, na segunda coluna o valor da última linha e
assim por diante. Em seguida construiu-se as matrizes A e b.

A construção da matriz A foi feita da seguinte forma:

• Criou-se uma matriz de zeros de dimensão nx4 através da função matriz_zeros


• Criou-se um loop que percorresse as diversas linhas i da matriz gps, onde i
começa no valor 1 e para no valor igual a n (i não recebe o valor de n).
• Para a coluna do w não necessitou-se criar um loop adicional e pode-se escrever
em seguida do loop das linhas A [i-1] [3] = 2* (-rn[3]+gps[i-1][3]).
• Em seguida criou-se um loop que percorresse as colunas de 1 a 3 (x, y, z) da
matriz A. Neste loop j varia entre 1 a 4, sendo que j não adquire o valor igual a
4. A posição A da matriz ficou como: A[i-1][j-1]=2*(rn[j-1]-gps[i-1][j-1]).

A construção da matriz b foi feita da seguinte forma:

• Criou-se uma matriz de zeros de dimensão n-1x1 através da função matriz_zeros


• Criou-se um loop que percorresse as diversas linhas i da matriz gps, onde i
começa no valor 1 e para no valor igual a n (i não recebe o valor de n).
• Em seguida, criou-se uma variável soma para guardar a somatória de cada linha
• Criou-se um loop que percorresse as três primeiras colunas da matriz gps de tal
forma que soma=soma+(-gps[i-1][j-1]**2+rn[j-1]**2), onde j varia de 1 a 4 ( j não
adquire o valor igual a 4)
• Após o término desse loop soma=soma+(gps[i-1][3]**2-rn[3]**2), que
corresponde a coluna do w
• Em seguida, b[i-1][0]=soma

Após a criação das matrizes A e b, criou-se uma variável At através da função


transposeMatrix, a qual transpôs a matriz A.

Em seguida, criou-se a matriz G e F que correspondem, respectivamente, ao


produto das matrizes At com A e ao produto das matrizes At com b. Isso foi feito
através da função prodMatrix.

Construído essas matrizes G e F, utilizou-se as funções decompõe e


eliminação_Gauss para obter a aproximação inicial do problema.

O código é representado a seguir:

A aproximação final deve possuir a seguinte propriedade:

onde ∇g é o gradiente de g em relação a x, y, z e w.

Para resolver esse sistema, é necessário aplicar o método de Newton para


funções de várias variáveis.

O método de Newton para funções de várias variáveis consiste em resolver o


seguinte sistema:
onde f1(x),f2(x),...,fn(x) são as componentes de F(x).

Após o cálculo de c, tem-se que 𝑥 𝑘+1 = 𝑥 𝑘 + 𝑐 𝑘 , onde k representa o número da


interação e x é o seu vetor o qual deseja refinar a resposta.

Para o cálculo a aproximação final fez-se o seguinte procedimento:

• Criou-se uma variável x, que é uma matriz 4x1, que corresponde aos valores das
minhas aproximações. x[0][0] corresponde ao valor x, x[1][0] corresponde ao
valor de y, x[2][0] corresponde ao valor de z e x[3][0] corresponde ao valor de 2.
Inicialmente x recebeu os valores da aproximação inicial
• Criou-se uma variável cont começando com 1 que corresponderá ao número de
interações
• Criou-se uma matriz erro 1x4 contendo apenas o número um e uma variável
erro_max que recebe o valor máximo, em módulo, da matriz erro.
• Criou-se um loop com os seguintes critérios de parada:
o cont<=100
o erro_max>=10**-10
o Caso um desses critérios fosse quebrado, o processo interativo de
refinamento da solução encerrava-se
• Criou-se uma variável anterior que possui os mesmos valores da matriz x antes
do processo de refinamento
• Criou-se 4 variáveis f1, f2, f3 e f4 todas inicialmente iguais a zero para a
construção das matrizes J e F

• Em seguida, construiu-se um loop, com i de 1 até n+1 (i não adquire o valor


n+1),para que f1, f2, f3 e f4 assumissem seus reais valores de tal forma que
o ri=(x[0][0]-gps[i-1][0])**2+(x[1][0]-gps[i-1][1])**2+(x[2][0]-gps[i-1][2])**2-
(x[3][0]-gps[i-1][3])**2
o f1=f1+4*(x[0][0]-gps[i-1][0])*ri
o f2=f2+4*(x[1][0]-gps[i-1][1])*ri
o f3=f3+4*(x[2][0]-gps[i-1][2])*ri
o f4=f4+4*(-x[3][0]+gps[i-1][3])*ri
• Construção de F (matriz coluna de 4x1)
o F=[ [-f1], [-f2], [-f3], [-f4] ]
• Construção de J
o Criou-se uma variável J que recebia uma matriz 4x4 contendo apenas
zeros através da função matriz_zeros
o Primeira linha de J
▪ Criou-se 4 variáveis soma1, soma2, soma3 e soma4 todas
valendo zero
▪ Criou-se um loop para percorrer as diversas linhas da matriz gps
▪ ri=(x[0][0]-gps[i-1][0])**2+(x[1][0]-gps[i-1][1])**2+(x[2][0]-gps[i-
1][2])**2-(x[3][0]-gps[i-1][3])**2
▪ soma1=soma1+4*ri+2*(2*x[0][0]-2*gps[i-1][0])**2
▪ soma2=soma2+2*(2*x[1][0]-2*gps[i-1][1])*(2*x[0][0]-2*gps[i-1][0])
▪ soma3=soma3+2*(2*x[2][0]-2*gps[i-1][2])*(2*x[0][0]-2*gps[i-1][0])
▪ soma4=soma4+2*(-2*x[3][0]+2*gps[i-1][3])*(2*x[0][0]-2*gps[i-
1][0])
▪ Após o término do loop, J[0][0]=soma1, J[0][1]=soma2,
J[0][2]=soma3 e J[0][3]=soma4
o Segunda linha de J
▪ Criou-se 4 variáveis soma1, soma2, soma3 e soma4 todas
valendo zero
▪ Criou-se um loop para percorrer as diversas linhas da matriz gps
▪ ri=(x[0][0]-gps[i-1][0])**2+(x[1][0]-gps[i-1][1])**2+(x[2][0]-gps[i-
1][2])**2-(x[3][0]-gps[i-1][3])**2
▪ soma1=soma1+4*ri+2*(2*x[1][0]-2*gps[i-1][2])**2
▪ soma2=soma2+2*(2*x[1][0]-2*gps[i-1][1])*(2*x[0][0]-2*gps[i-1][0])
▪ soma3=soma3+2*(2*x[1][0]-2*gps[i-1][1])*(2*x[2][0]-2*gps[i-1][2])
▪ soma4=soma4+2*(-2*x[1][0]+2*gps[i-1][1])*(2*x[3][0]-2*gps[i-
1][3])
▪ Após o término do loop J[1][1]=soma1, J[1][0]=soma2,
J[1][2]=soma3 e J[1][3]=soma4
o Terceira linha de J
▪ Criou-se 4 variáveis soma1, soma2, soma3 e soma4 todas
valendo zero
▪ Criou-se um loop para percorrer as diversas linhas da matriz gps
▪ ri=(x[0][0]-gps[i-1][0])**2+(x[1][0]-gps[i-1][1])**2+(x[2][0]-gps[i-
1][2])**2-(x[3][0]-gps[i-1][3])**2
▪ soma1=soma1+4*ri+2*(2*x[2][0]-2*gps[i-1][2])**2
▪ soma2=soma2+2*(2*x[2][0]-2*gps[i-1][2])*(2*x[0][0]-2*gps[i-1][0])
▪ soma3=soma3+2*(2*x[2][0]-2*gps[i-1][2])*(2*x[1][0]-2*gps[i-1][1])
▪ soma4=soma4+2*(-2*x[2][0]+2*gps[i-1][2])*(2*x[3][0]-2*gps[i-
1][3])
▪ Após o término do loop J[2][2]=soma1, J[2][0]=soma2,
J[2][1]=soma3 e J[2][3]=soma4
o Quarta linha de J
▪ Criou-se 4 variáveis soma1, soma2, soma3 e soma4 todas
valendo zero
▪ Criou-se um loop para percorrer as diversas linhas da matriz gps
▪ ri=(x[0][0]-gps[i-1][0])**2+(x[1][0]-gps[i-1][1])**2+(x[2][0]-gps[i-
1][2])**2-(x[3][0]-gps[i-1][3])**2
▪ soma1=soma1+4*ri+2*(2*x[3][0]-2*gps[i-1][3])**2;
▪ soma2=soma2+2*(2*x[3][0]-2*gps[i-1][3])*(2*x[0][0]-2*gps[i-1][0])
▪ soma3=soma3+2*(2*x[3][0]-2*gps[i-1][3])*(2*x[1][0]-2*gps[i-1][1])
▪ soma4=soma4+2*(-2*x[3][0]+2*gps[i-1][3])*(2*x[2][0]-2*gps[i-
1][2])
▪ Após o término do loop J[3][3]=soma1, J[3][0]=soma2,
J[3][1]=soma3, J[3][2]=soma4
• Tendo J e F construídas fez-se A=J e b= F e usando as funções decompõe e
eliminação_Gauss obtivia-se as respostas do sistema Ax=b para aquela
interação, onde x no caso é a matriz c.
• A variável resp corresponde a solução da Figura X para cada variável.
• Em seguida, fazia-se um processo de obtenção do erro máximo utilizando as
matrizes x e anterior para verificar o critério de parada do erro.
• Criou-se uma variável interações para guardar o valor das interações feitas
Após realizado o processo de refinamento da solução, utilizou-se a função
localização para obter a latitude e longitude do ponto no globo e imprimiu-se os valores
da aproximação final e o número de interações feitas no método de Newton.

3. Resultados
As figuras abaixo mostram os resultados obtidos pelo exercício programa
durante a impressão:

Utilizando o aplicativo Google Maps para localizar o ponto no globo temos que a
localização dele é em Copenhagen.
4. Funções implementadas
a. matriz_zeros
Cria uma matriz contendo apenas zeros a partir de dois parâmetros de entrada: m
(número de linhas) e n (número de colunas).

b. matriz_identidade
Cria uma matriz identidade a partir de dois parâmetros de entrada: m (dimensão da
matriz)

c. prodMatrix
Retorna a matriz C, que é o produto de duas matrizes, a partir de dois parâmetros
de entrada: A (matriz a esquerda) e B (matriz a direita).
d. transposeMatrix
Retorna a matriz aux a partir de um parâmetro de entrada: A (matriz a ser transposta)

e. decompoe
A função decompõe retorna a decomposição LU da matriz de entrada A. A
construção da função seguiu as seguintes etapas:

• Criou-se uma variável Au, que possuirá os mesmos valores de A, e uma


variável p através da função matriz zeros que será um vetor coluna de zeros
de dimensões nx1, onde n é a dimensão de A.
• Em seguida criou-se um loop do seguinte modo

• No processo de troca de linhas, também-se trocou as linhas na mesma


ordem da matriz A.
• Em seguida, criou-se uma variável L que é uma matriz identidade de
dimensão nxn através da função matriz_identidade.
• Em seguida, criou-se uma matriz identidade P de dimensão n através da
função matriz_identidade e permutou suas linhas de acordo com o vetor
coluna p.
• Depois, criou-se dois loops: um para varrer as linhas e outro para varrer as
colunas da matriz Au.
o Nestes loops fazia-se as seguintes operações.
o mult=Au[j][i-1]/Au[i-1][i-1]
o L[j][i-1]=mult;
o Au[j][s-1]=Au[j][s-1]-mult*Au[i-1][s-1]
o i corresponde a coluna em questão, j corresponde a linha em questão
e s varia entre 1 a n+1

• Em seguida, uma variável U recebeu o valor de Au.


• A função retorna então a matriz L, U e P

f. eliminacao_Gauss
Por definição têm se que 𝑃 ∗ 𝐴 = 𝐿 ∗ 𝑈, usando essa definição no sistema 𝐴 ∗ 𝑥 = 𝑏
temos:

𝐴 ∗ 𝑥 = (𝐿 ∗ 𝑈) ∗ 𝑥 = 𝑃 ∗ 𝑏

𝐿∗𝑦 = 𝑃∗𝑏

𝑈∗𝑥 =𝑦

Dessa forma, o procedimento para achar a solução x consiste em achar primeiro o


vetor y, por meio da eliminação de Gauss, e em seguida aplicar a eliminação de Gauss
para achar o x. Portanto, primeiramente criou-se duas variáveis y e x, que são vetores
colunas de dimensão igual ao len(L*U) só de zeros através da função matriz_zeros. Em
seguida aplicou-se o seguinte agorítimo para achar os vetores y e x.
No caso para encontrar o y: a matriz b da Figura X é a matriz P*b e a matriz a da
Figura X é a L. No caso para encontrar o x: a matriz b da Figura X é a matriz y e a matriz
a é U.

g. localização
Essa função tem como objetivo calcular a latitude e longitude do ponto a partir
das coordenadas x, y e z de um sistema cartesiano. O sistema de coordenadas tem sua
origem O no centro da Terra, o eixo Oz positivo aponta na direção do Pólo Norte, o plano
Oxy é o plano do equador com o eixo Ox positivo cortando o meridiano de Greenwich e
o eixo Oy positivo corta o meridiano de longitude 90°E.

Primeiramente, calculou-se o raio local, uma vez que o formato do nosso planeta
é um geóide. O raio local é determinado por:

𝑟𝑎𝑖𝑜 𝑙𝑜𝑐𝑎𝑙 = √𝑥 2 + 𝑦 2 + 𝑧 2

A latitude pode ser determinada por:

𝑧
𝑙𝑎𝑡𝑖𝑡𝑢𝑑𝑒 (𝑔𝑟𝑎𝑢𝑠) = 90° − cos −1( )
𝑟𝑎𝑖𝑜 𝑙𝑜𝑐𝑎𝑙

Já a longitude por:

𝑦
𝑙𝑜𝑛𝑔𝑖𝑡𝑢𝑑𝑒 (𝑔𝑟𝑎𝑢𝑠) = tan−1 ( )
𝑥

5. Testes complementares
a. Teste 1
Esse teste consiste em determinar o ponto mínimo da função:

𝐹(𝑥, 𝑦) = (𝑥 − 2)2 + (𝑦 − 3)2

A condição que satisfaz isso é o ponto que o gradiente de F é nulo, ou seja,

𝜕𝐹 𝜕𝐹
=0𝑒 =0
𝜕𝑥 𝜕𝑦

O procedimento utilizado foi o método de Newton para várias variáveis. A matriz F é


uma matriz 2x1 de zeros, que foi feita através da função matriz_zeros, e a matriz J é
uma matriz 2x2 da forma:

2 0
𝐽= ( )
0 2

Utilizando as funções decompõe e eliminação de Gauss foi possível calcular o c da


interação k sendo que a resposta final era 𝑥 𝑘+1 = 𝑥 𝑘 + 𝑐 𝑘 . Notou-se que em menos de
5 interações o procedimento convergia a partir de um valor próximo da raiz e os
resultados foram que x=2 e y=3.

b. Teste 2
Dada a função 𝐹(𝑥1, 𝑥2, 𝑥3, 𝑥4) = (4𝑥1 − 𝑥2 + 𝑥3 − 𝑥1𝑥4, −𝑥1 + 3𝑥2 − 2𝑥3 − 𝑥2𝑥4,
𝑥1 − 2𝑥2 + 3𝑥3 − 𝑥3𝑥4, 𝑥12 + 𝑥22 + 𝑥32 − 1), determinar a raiz que se obtém pelo
método de Newton tomando x = (1,1,1,1) como valor inicial.

Para resolver esse problema fez-se o seguinte procedimento:

• Definiu x como um vetor linha de dimensão 1x4 como [1,1,1,1]


• Definiu um loop com 500 interações no total, uma vez que notou-se que a
resposta já convergia para x2,x3 e x4 e para x1 ela fica oscilando em um
intervalo devido a erros de arredondamento.
o Definiu-se 4 variáveis
▪ f1 = 4𝑥1 − 𝑥2 + 𝑥3 − 𝑥1𝑥4
▪ f2 = −𝑥1 + 3𝑥2 − 2𝑥3 − 𝑥2𝑥4,
▪ f3 = 𝑥1 − 2𝑥2 + 3𝑥3 − 𝑥3𝑥4
▪ f4 = 𝑥12 + 𝑥22 + 𝑥32 − 1
o Definiu F um vetor coluna de zeros, através da função matriz_zeros,
de dimensão 4x1 com os seguintes valores:
▪ F[0][0]=-f1
▪ F[1][0]=-f2
▪ F[2][0]=-f3
▪ F[3][0]=-f4
o Definiu J um matriz de zeros, através da função matriz_zeros, de
dimensão 4x4
o Em seguida criou-se as seguintes listas, que correspondem as
derivadas dentro de J:
▪ l1=[4-x[3], -1, 1, -x[0] ]
▪ l2=[-1, 3-x[3], -2, -x[1] ]
▪ l3=[1, -2, 3-x[3], -x[2] ]
▪ l4=[2*x[0], 2*x[1], 2*x[2], 0]
o Em seguida fez-se as seguintes operações
▪ J[0][0]=l1[0]
▪ J[0][1]=l1[1]
▪ J[0][2]=l1[2]
▪ J[0][3]=l1[3]
▪ J[1][0]=l2[0]
▪ J[1][1]=l2[1]
▪ J[1][2]=l2[2]
▪ J[1][3]=l2[3]
▪ J[2][0]=l3[0]
▪ J[2][1]=l3[1]
▪ J[2][2]=l3[2]
▪ J[2][3]=l3[3]
▪ J[3][0]=l4[0]
▪ J[3][1]=l4[1]
▪ J[3][2]=l4[2]
▪ J[3][3]=l4[3]
o Em seguida realizou-se a decomposição LU da matriz J pela função
decompõe e realizou a eliminação de Gauss com as matrizes da
decomposição LU de J e a matriz F através da função
eliminação_Gauss para o cálculo do c
o Somou-se cada ci ao seu respectivo xi para obter uma solução mais
refinada

A resposta do sistema foi usando o algoritmo foi:

c. Teste 3
Utilizar o método de Newton para determinar solução do sistema n−1× n−1, cujas
𝑒 𝑥𝑖
equações são −𝑥𝑖−1 + 2 ∗ 𝑥𝑖 − 𝑥𝑖+1 = 𝑛2
, 𝑖 = 1, . . . , 𝑛 − 1 ,

com x0 = xn = 0 , a partir da aproximação inicial nula.

Para a construção desse algoritmo foi feito o seguinte procedimento:

• Definiu uma variável n que corresponderá a quantas variáveis que o sistema terá.
• Definiu uma variável x, que é um vetor coluna de dimensão n-1x1 contendo
apenas zeros através da função matriz_zeros
• Definiu duas variáveis F e J, sendo ambas matrizes zeros, mas F sendo de dimensão
n-1x1 e J de dimensão n-1xn-1.
• O J do método de newton tem a seguinte forma:
2 1 0 0 ⋯ 0
1 2 1 0 ⋯ 0
o 𝐽= 0 1 2 1 ⋯ 0
⋮ ⋱ ⋱⋱ ⋮ ⋮
0 ⋯ 0 1 2 1
(0 ⋯ ⋯0 1 2)
• Após a construção de J determinou um loop com um certo número de interações,
que no caso foram 100, pois observou que as soluções já convergiam
o Neste loop foram feitos o processo de decomposição LU da matriz J e a
eliminação de Gauss da matriz LU de J com a matriz F para a determinação
c
o Após o cálculo de c, cada varíavel recebia a soma de seu valor anterior
com o valor respectivo de c

Os resultados foram:

• N=20

• N=40
• N=80
6. Conclusão
De modo geral, verifica-se que os métodos numéricos utilizados no exercício
programa são satisfatórios para realizar aproximações para resolver sistemas lineares,
uma vez que seu erro é relativamente pequeno. Entretanto, deve-se tomar cuidado na
implementação de funções e segmentos de códigos que realizem contas
desnecessárias ou operações complicadas, como inversão de matrizes, pois isto gera
erros de arredondamentos, os quais propagam-se pelo código e pode gerar
incoerências no resultado final.