Disciplina: Métodos Numéricos

Temática: Métodos Diretos para

Resolução de Sistemas Lineares

Professor: Vinícius da Rocha Motta

vinicius.motta@uvv.br
Introdução

● Solução de sistemas de equações lineares algébricas

(SELA) é muito utilizado para simular problemas do mundo
real;
● Implementação eficiente dos algoritmos é importante para
reduzir o tempo de processamento computacional;
● SELA é usado em vários problemas da engenharia, como
determinação do potencial em redes elétricas e cálculo da
razão de escoamento em sistemas hidráulicos;
Introdução

● Resolução de SELA é fundamental para métodos numéricos de

resolução de equações diferenciais parciais;
● Dinâmica dos Fluidos Computacional é uma área que trabalha
com computadores para resolver sistemas lineares com muitas
equações;
● É importante aprender a trabalhar com métodos numéricos de
resolução de sistemas lineares para entender como as
ferramentas funcionam.
Revisão Geral dos Conceitos de Sistemas Lineares

● Quando temos uma equação, é uma expressão

matemática que contém um sinal de igualdade.
● Ao resolver essa equação, encontramos um valor
que faz com que a equação seja verdadeira.
● Esse valor pode ser único ou pode haver mais de
uma solução.
Revisão Geral dos Conceitos de Sistemas Lineares

● Algumas equações têm apenas uma variável, como "x", por

exemplo.
● Já outras podem ter várias variáveis, como "x", "y" e "z".
● Quando cada termo da equação tem apenas uma variável e
cada variável aparece apenas uma vez, isso é chamado de
equação linear.
● Além disso, quando todas as variáveis aparecem elevadas à
primeira potência, isso também é uma equação linear.
Revisão Geral dos Conceitos de Sistemas Lineares

● Por exemplo, a equação "3x + 2y = 10" é uma

equação linear, pois tem apenas as variáveis "x" e
"y" e elas aparecem elevadas à primeira potência.
● Já a equação "x² + y² = 25" é uma equação
não-linear, pois as variáveis aparecem elevadas à
segunda potência.
Exercicios

Classifique as equações como lineares ou não

lineares:
3x + 4y - 10z = -3
xy - 3y = -3

x³ + y - z = 0
Revisão Geral dos Conceitos de Sistemas Lineares
Um conjunto de n equações lineares com n variáveis (incógnitas) é denominado de:
Sistemas de n equações lineares; ou Sistema Linear de ordem n
Uma solução para um sistema linear consiste em determinar valores para as n
variáveis que satisfaçam todas as equações simultaneamente.
Por exemplo, o sistema de três equações lineares:

tem solução x = 1, y = 1 e z = -1, isto é, se substituirmos em cada

equação do sistema linear acima, os valores das variáveis, tornará
cada equação verdadeira e, neste caso, nenhuma outra solução faz as
três equações verdadeiras ao mesmo tempo.
Revisão Geral dos Conceitos de Sistemas Lineares

O sistema linear acima pode ser escrito na seguinte forma, chamada matricial:
Representação geral de sistemas lineares algébricos – SELA’s
De um modo geral, um sistema de equações lineares é escrito como:

e é representado na forma matricial por:

ou simplesmente por Ax = b
Classificação dos sistemas lineares

Fazemos a classificação de um sistema linear em função do número

de soluções que ele admite, da seguinte maneira:

Possível ou consistente: possui pelo menos uma solução, que,

dependendo do número de soluções pode ser classificado como:

● Determinado, se admite uma única solução;

● Indeterminado, se admite mais de uma solução.
● Impossível ou inconsistente: não admite nenhuma solução.
Sistema possível e determinado

Temos duas equações e,

neste caso, um sistema
possível e determinado,
isto é, possui uma única
solução comum que é o
ponto (0.5; 2.5).
Representação geométrica de
um sistema possível e
determinado de ordem 2.
Sistema possível e indeterminado
Temos duas equações e, neste caso, um sistema possível e indeterminado, isto é,
possui infinitas soluções comuns.

Representação geométrica
de um sistema possível e
indeterminado de ordem 2.
Sistema impossível
Neste exemplo são duas equações e, neste caso, um sistema impossível,
isto é, não possui soluções comuns.

Representação geométrica de
um sistema impossível de
ordem 2.
Sistema possível e determinado - Ordem 3

Temos três equações e, neste caso, um sistema possível e determinado, isto é, possui uma
única solução comum que é o ponto

Representação geométrica de um
sistema possível e determinado de
ordem 3.
Sistema possível e indeterminado - Ordem 3

Temos três equações e, neste caso, um sistema possível e indeterminado, isto é, possui
infinitas soluções comuns que é toda uma reta.

Representação geométrica de
um sistema possível e
indeterminado de ordem 3.
Sistema impossível

Neste exemplo são três equações e, neste caso, um sistema impossível, isto é, não possui
soluções comuns.

Representação geométrica de
um sistema impossível de
ordem 3.
Objetivo dos métodos numéricos de resolução de
sistemas de equações lineares
● Métodos numéricos resolvem SELA's com solução única.
● Se o sistema não tiver uma solução única, uma modelagem matemática
adequada pode transformá-lo em um sistema possível e determinado,
como no caso de problemas de balanceamento de equações químicas.
●

Os sistemas de equações lineares com solução possível e determinada são

aqueles onde a matriz dos coeficientes é não singular.
Objetivo dos métodos numéricos de resolução de
sistemas de equações lineares
● Uma matriz dos coeficientes é não singular quando sua determinante é
diferente de zero.
● Essa condição é importante porque quando a matriz é não singular, ela
pode ser invertida e, assim, podemos resolver o sistema de equações
lineares correspondente de forma única.
● Se a matriz dos coeficientes fosse singular, isso significaria que duas
ou mais equações são combinações lineares umas das outras, o que
implicaria em um sistema de equações lineares redundante, com
infinitas soluções ou sem solução.
Objetivo dos métodos numéricos de resolução de sistemas
de equações lineares
Por exemplo, considere o seguinte sistema de equações lineares:

|x + 2y + z = 3|
O determinante desta matriz é 0, o que
|2x + 4y + 6z = 12|
significa que a matriz é singular e o sistema
|x + 3y + 2z = 6 | de equações lineares correspondente tem
infinitas soluções.
A matriz dos coeficientes é:
Por outro lado, se a matriz dos coeficientes
fosse não singular, isso implicaria que todas
|1 2 1|
as equações do sistema são independentes
|2 4 6| entre si e, assim, o sistema teria uma única
|1 3 2| solução possível e determinada.
Objetivo dos métodos numéricos de resolução de sistemas
de equações lineares
O determinante de uma matriz quadrada é uma operação matemática que envolve seus
elementos e é usado em muitos campos da matemática, como álgebra linear, cálculo e
geometria.
O determinante de uma matriz 2x2 é dado pela seguinte fórmula:
|a b|
|c d| = ad - bc

O determinante de uma matriz 3x3 é dado pela soma dos produtos das diagonais principais
e secundárias, da seguinte forma:
|a b c|
|d e f|
|g h i| = aei + bfg + cdh - ceg - bdi - afh
Objetivo dos métodos numéricos de resolução de sistemas
de equações lineares
Para encontrar seu determinante, podemos usar a fórmula do determinante de
uma matriz 3x3:

det = 1(42 - 36) - 2(22 - 31) + 1(23 - 41)

det = -12 + 2 + 2
det = -8

O determinante da matriz dos coeficientes é -8. Como o determinante é diferente

de zero, podemos concluir que a matriz dos coeficientes é não singular e,
portanto, o sistema de equações lineares correspondente tem uma solução única
e possível.
Exercicio

Calcule o determinante da matriz abaixo em

python:
matriz = [[3, 1, 2],
[1, 2, 3],
[2, 3, 1]]
Norma vetorial
A norma vetorial é uma medida da magnitude de um vetor. Em outras palavras,
ela é um valor que indica o comprimento do vetor. A norma vetorial é definida
como a raiz quadrada da soma dos quadrados dos elementos do vetor.

Matematicamente, se o vetor é denotado por v = (v1, v2, ..., vn), a norma vetorial
||v|| é dada por:

||v|| = sqrt(v1^2 + v2^2 + ... + vn^2)

Norma vetorial

A norma vetorial é uma medida importante em muitas áreas da matemática e

da física, porque ela permite quantificar a magnitude de um vetor. Além
disso, ela é útil para determinar a distância entre dois vetores.

Por exemplo, se temos dois vetores v = (1, 2, 3) e u = (4, 5, 6), podemos

calcular a distância entre eles como a norma do vetor diferença:

d(u, v) = ||u - v|| = sqrt((4-1)^2 + (5-2)^2 + (6-3)^2) = sqrt(27) ≈ 5.196

Assim, a norma vetorial é uma medida importante na geometria e na álgebra

linear, e permite quantificar a magnitude de um vetor e a distância entre dois
vetores.
Exemplo Prático do uso da Norma vetorial
Um exemplo prático de uso da norma vetorial é na análise de dados em aprendizado de máquina. Quando
se trabalha com dados em alta dimensão, muitas vezes é necessário normalizá-los, ou seja,
transformá-los para que eles fiquem em uma escala comum e comparável.

A norma vetorial pode ser usada nesse contexto para normalizar cada vetor de dados. Por exemplo, se
temos um conjunto de dados representado por uma matriz X, onde cada linha é um vetor de dados,
podemos normalizar cada vetor dividindo-o pela sua norma vetorial:

import numpy as np

# Exemplo de matriz de dados

X = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

# Normalização de cada vetor

normas = np.linalg.norm(X, axis=1) # Calcula a norma de cada vetor
X_norm = X / normas[:, np.newaxis] # Divide cada vetor pela sua norma

print(X_norm)
Norma matricial
A norma matricial é uma medida da magnitude de uma matriz. Em outras palavras, ela é um
valor que indica o tamanho da matriz.

A norma matricial é definida como o maior valor possível da multiplicação entre a matriz e
um vetor unitário.

Existem diferentes tipos de normas matriciais, mas uma das mais comuns é a norma de
Frobenius, que é definida como a raiz quadrada da soma dos quadrados de todos os
elementos da matriz.

Matematicamente, se a matriz A é de tamanho m x n, a norma de Frobenius ||A||F é dada

por:

||A||F = sqrt(sum(sum(A^2)))
 Norma matricial
A norma matricial é uma medida importante em muitas áreas da matemática e da física,
porque ela permite quantificar a magnitude de uma matriz. Além disso, ela é útil para
determinar a estabilidade de um sistema linear, ou seja, a sensibilidade do sistema às
mudanças nos seus parâmetros.

Por exemplo, se temos uma matriz A de tamanho 2 x 2, podemos calcular sua norma de
Frobenius:
import numpy as np

# Exemplo de matriz
A = np.array([[1, 2],
[3, 4]])

# Cálculo da norma de Frobenius

norma = np.linalg.norm(A, ord='fro')

print(norma)
 Exemplo Prático
Um exemplo prático de uso da norma matricial é na avaliação da estabilidade de sistemas lineares. Por exemplo, se temos
um sistema linear representado por uma matriz A, podemos calcular a norma matricial de A para determinar se o sistema é
estável ou não. Um sistema é considerado estável se a norma matricial de A for menor que 1, e é considerado instável se a
norma matricial de A for maior que 1.

Vamos considerar um exemplo simples de um sistema linear representado por uma matriz 2x2:

import numpy as np Nesse exemplo, utilizamos a função np.linalg.norm da biblioteca NumPy para calcular a
norma matricial de A.
# Exemplo de matriz
A = np.array([[0.5, 0.7], A opção "ord=2" indica que queremos calcular a norma matricial de ordem 2, que é a norma
[0.3, 0.9]]) espectral, também conhecida como raio espectral ou maior autovalor.
Como a norma matricial de A é menor que 1, podemos concluir que o sistema representado
# Cálculo da norma matricial por A é estável.
norma = np.linalg.norm(A, ord=2)

Note que existem diferentes tipos de normas matriciais, como a norma de Frobenius e a
print(norma)
norma de máximo, e que cada uma delas pode produzir um resultado diferente. No caso da
estabilidade de sistemas lineares, a norma espectral é a mais utilizada.
Transformações básicas sobre as linhas dos SELA’s
As transformações básicas sobre as linhas dos sistemas de equações lineares (SELA)
podem ser facilmente implementadas em Python utilizando a biblioteca NumPy.

As transformações básicas são operações que podemos aplicar sobre as linhas de uma
matriz de coeficientes de um SELA sem alterar a solução do sistema.

As três transformações básicas são:

1. Troca de linhas

2. Multiplicação de uma linha por uma constante não nula

3. Adição de um múltiplo de uma linha em outra linha

Transformações básicas sobre as linhas dos SELA’s
Vamos considerar um exemplo de um SELA com 3 equações e 3 incógnitas:
import numpy as np

O resultado da concatenação da
# Matriz de coeficientes matriz A com o vetor b é:
A = np.array([[2, 3, 1],
[1, -1, 2], [[ 2 3 1 5]
[4, 2, 3]]) [ 1 -1 2 1]
[ 4 2 3 4]]
# Vetor de termos independentes
b = np.array([5, 1, 4])

# Concatenação da matriz A com o

vetor b
AB = np.c_[A, b]

print(AB)
Transformações básicas sobre as linhas dos SELA’s
Para realizar as transformações básicas sobre as linhas, podemos utilizar as funções do NumPy.

Por exemplo, para trocar a primeira e a segunda linha, podemos fazer:

# Troca da primeira e segunda linha

AB[[0,1]] = AB[[1,0]]

print(AB)

O resultado da troca da primeira e segunda linha é:

[[ 1 -1 2 1]
[ 2 3 1 5]
[ 4 2 3 4]]
Transformações básicas sobre as linhas dos SELA’s
Para multiplicar a terceira linha por 2, podemos fazer:

# Multiplicação da terceira linha

por 2
AB[2] *= 2

print(AB)

O resultado da multiplicação da terceira linha por 2 é:

[[ 1 -1 2 1]
[ 2 3 1 5]
[ 8 4 6 8]]
 Transformações básicas sobre as linhas dos SELA’s
Para adicionar o dobro da primeira linha à segunda linha, podemos fazer:

# Adição do dobro da primeira linha

à segunda linha
AB[1] += 2*AB[0]

print(AB)

O resultado da adição do dobro da primeira linha à segunda linha é:

[[ 1 -1 2 1] Note que, apesar de terem sido realizadas transformações nas

[ 0 1 5 7]
[ 8 4 6 8]]
linhas da matriz, a solução do sistema não é alterada, pois as
transformações básicas não mudam a equivalência do sistema
original.
Etapas na resolução dos SELA’s
Para exemplificar o processo de eliminação de Gauss em um sistema de equações lineares, considere o seguinte sistema:

2x + 3y - z = 5

4x + 2y + z = 4

-2x + y + 2z = 2

Para realizar a eliminação de Gauss, podemos utilizar o seguinte algoritmo:

1. Escreva o sistema em forma de matriz aumentada.

[2 3 -1 | 5]
[4 2 1 | 4]
[-2 1 2 | 2]

2. Utilize operações elementares de linha para transformar a matriz aumentada em uma matriz triangular superior.
Comece pela primeira coluna e aplique as operações necessárias para zerar os elementos abaixo do primeiro
elemento na diagonal principal.
[2 3 -1 | 5 ]
[0 -4 3 |-6 ]
[0 7 0 | 12]
Etapas na resolução dos SELA’s
3. Repita o processo para as colunas seguintes, seguindo a mesma lógica de zerar os elementos abaixo da diagonal
principal.
[2 3 -1 | 5]
[0 -4 3 | -6]
[0 0 15 | 30]

4. Agora que a matriz está na forma triangular superior, podemos resolver o sistema de equações a partir da última
equação e substituindo os valores obtidos nas equações anteriores.
z = 2
-4y + 3z = -6 => -4y + 3(2) = -6 => y = 3/2
2x + 3y - z = 5 => 2x + 3(3/2) - 2 = 5 => x = 3/2

Portanto, a solução do sistema é (x, y, z) = (3/2, 3/2, 2)

 Etapas na resolução dos SELA’s
Aqui está um exemplo de como podemos implementar a eliminação de Gauss em Python:
import numpy as np

# Matriz aumentada do sistema

A = np.array([[2, 3, -1, 5],
[4, 2, 1, 4],
[-2, 1, 2, 2]])

# Aplicação da eliminação de Gauss

n, m = A.shape
for j in range(n-1):
for i in range(j+1, n):
factor = A[i,j] / A[j,j]
A[i,j:] = A[i,j:] - factor * A[j,j:]

# Resolução do sistema
x = np.zeros(n)
for i in range(n-1, -1, -1):
x[i] = (A[i,-1] - np.dot(A[i,i+1:-1],
x[i+1:])) / A[i,i]

print("Solução do sistema:", x)
Sistemas triangulares
Um sistema triangular é um sistema de equações lineares em que a matriz dos coeficientes é triangular superior ou
inferior. Resolver sistemas triangulares é um processo simples, que pode ser implementado facilmente em Python. Aqui
estão alguns exemplos:

Sistema triangular superior:

2x + 3y + z = 5
Considere o seguinte sistema triangular superior: 4y - 2z = -2
5z = 5
Sistemas triangulares
import numpy as np
Podemos resolver esse sistema facilmente usando substituição para trás:
# Matriz dos coeficientes
A = np.array([[2, 3, 1],
[0, 4, -2],
[0, 0, 5]])

# Vetor dos termos independentes

b = np.array([5, -2, 1])

# Solução do sistema
x = np.zeros(3)
for i in range(2, -1, -1):
x[i] = (b[i] -
np.dot(A[i,i+1:], x[i+1:])) /
A[i,i]

print("Solução do sistema:", x)
Sistemas triangulares
Sistema triangular inferior:
x + 0y + 0z = 1
Considere o seguinte sistema triangular inferior: 2x - 3y + 0z = -1
5x + 4y + z = 3

import numpy as np

# Matriz dos coeficientes

A = np.array([[1, 0, 0],
[2, -3, 0],
[5, 4, 1]])

Podemos resolver esse sistema facilmente usando substituição para frente: # Vetor dos termos independentes
b = np.array([1, -1, 3])

# Solução do sistema
x = np.zeros(3)
for i in range(3):
x[i] = (b[i] - np.dot(A[i,:i], x[:i])) /
A[i,i]

print("Solução do sistema:", x)
Método da fatoração ou decomposição LU
O método da fatoração ou decomposição LU é um método de resolução de sistemas
lineares que consiste em decompor a matriz dos coeficientes em um produto de duas
matrizes triangulares, L e U, de forma que:
A = LU

onde A é a matriz dos coeficientes, L é uma matriz triangular inferior e U é uma matriz
triangular superior.
O método consiste em resolver dois sistemas triangulares:
● um sistema triangular inferior com a matriz L
● outro sistema triangular superior com a matriz U
Método da fatoração ou decomposição LU
Para exemplificar como o método funciona em Python, vamos resolver o seguinte sistema linear usando o método da
decomposição LU:
2x + 3y - z = 5
3x + 2y + z = 6
import numpy as np
x - 2y + 2z = 2

A = np.array([[2, 3, -1],
Primeiro, vamos criar a matriz dos coeficientes e o vetor dos termos independentes: [3, 2, 1],
[1, -2, 2]])

b = np.array([5, 6, 2])

Agora, vamos decompor a matriz A em L e U usando a função LU do NumPy: P, L, U = scipy.linalg.lu(A)

Método da fatoração ou decomposição LU

A matriz P é uma matriz de permutação que é usada para trocar as linhas de A durante a decomposição
LU, se necessário. Em geral, é uma matriz identidade com algumas linhas trocadas.

Agora, vamos resolver o sistema triangular inferior Lc = Pb, onde c é um vetor auxiliar:
c = np.linalg.solve(L, np.dot(P, b))

Finalmente, vamos resolver o sistema triangular superior Ux = c: x = np.linalg.solve(U, c)

A solução do sistema é dada pelo vetor x: print("Solução do sistema:", x)

 Método da fatoração ou decomposição LU
● Note que a decomposição LU pode ser útil para resolver
sistemas lineares com a mesma matriz dos coeficientes,
mas com diferentes termos independentes.

● A decomposição LU pode ser calculada uma vez e as soluções

para diferentes termos independentes podem ser obtidas
resolvendo os sistemas triangulares inferiores e superiores
correspondentes.
ANÁLISE DE ERRO

● Sistemas mal condicionados

○ Um sistema de equações lineares é considerado mal condicionado quando
pequenas perturbações nos dados de entrada (coeficientes da matriz ou
termos independentes) resultam em grandes variações na solução do
sistema.

○ Essas variações podem ser tão grandes que a solução pode se tornar
completamente inútil. Em outras palavras, pequenos erros de arredondamento
na entrada do sistema podem levar a grandes erros na saída.

○ A condição de uma matriz pode ser medida pelo seu número de

condicionamento, que é definido como a norma da matriz vezes a norma da
matriz inversa. Se o número de condicionamento for grande, o sistema é
considerado mal condicionado.
Um exemplo de sistema mal condicionado
x + y + z = 6
2x + 2y + 3z = 11
4x + 6y + 8z = 22

Este sistema pode ser representado na forma

matricial como Ax = b, onde:
A = [[1, 1, 1],
[2, 2, 3],
[4, 6, 8]]

x = [x, y, z]

b = [6, 11, 22]

 Um exemplo de sistema mal condicionado

Usando o NumPy em Python, podemos resolver esse sistema de equações lineares usando a função solve e
plotar os gráficos dos resultados. import numpy as np
import matplotlib .pyplot as plt

Vamos dar um exemplo: # Definir a matriz do sistema

A = np.array ([[1, 1, 1],
[ 2, 2, 3],
[ 4, 6, 8]])

# Definir o vetor de termos independentes

b = np.array ([6, 11, 22])

# Resolver o sistema
x = np.linalg .solve (A, b)

# Imprimir a solução
print ('Solução do sistema:' , x)

# Plotar os gráficos dos resultados

fig, axs = plt.subplots (2)
axs[0].bar(['x', 'y', 'z'], x)
axs[0].set_title ('Solução do sistema' )
axs[1].bar(['x', 'y', 'z'], [1, 1, 1])
axs[1].set_title ('Valores verdadeiros' )
plt.show()
Um exemplo de sistema mal condicionado
O resultado da solução será [-0.22222222 5.88888889 -1.44444444].

Como podemos ver, os valores estão longe dos valores verdadeiros [1, 2, 3], o
que indica que o sistema é mal condicionado. Podemos visualizar isso plotando um
gráfico comparando os valores da solução com os valores verdadeiros.

No exemplo acima, usamos um gráfico de barras para fazer essa comparação.

Note que, em geral, pode ser difícil visualizar o comportamento de um sistema mal
condicionado apenas através de gráficos.

Para avaliar a condição de um sistema de equações lineares, é necessário calcular o

número de condicionamento da matriz A.
 Sistemas lineares instáveis
Um sistema de equações lineares é instável quando qualquer pequena perturbação nos dados de entrada
(coeficientes da matriz ou termos independentes) resulta em grandes variações na solução do sistema,
levando a uma solução completamente inútil.

Em outras palavras, pequenas mudanças nos valores da matriz A ou do vetor b podem causar grandes
mudanças na solução x. x + y = 1
x - y = 1

Podemos representar esse sistema na forma matricial como Ax = b, onde: A = [[1, 1],
[1, -1]]

x = [x, y]

b = [1, 1]
 Sistemas lineares instáveis
Usando o NumPy em Python, podemos resolver esse sistema de equações lineares usando a função solve e
plotar os gráficos dos resultados. Vamos dar um exemplo: import numpy as np
import matplotlib.pyplot as plt

# Definir a matriz do sistema

A = np.array([[1, 1],
[1, -1]])

# Definir o vetor de termos independentes

b = np.array([1, 1])

# Resolver o sistema
x = np.linalg.solve(A, b)

# Imprimir a solução
print('Solução do sistema:', x)

# Plotar os gráficos dos resultados

fig, axs = plt.subplots(2)
axs[0].bar(['x', 'y'], x)
axs[0].set_title('Solução do sistema')
axs[1].plot([0, x[0]], [0, x[1]])
axs[1].set_xlim([-1, 1])
axs[1].set_ylim([-1, 1])
axs[1].set_title('Direções do vetor de solução'
)
plt.show()
 Sistemas lineares instáveis
O resultado da solução será [1., 0.]. Como podemos ver, essa solução é instável, o que significa que
qualquer pequena perturbação na matriz A ou no vetor b pode levar a grandes variações na solução x.
Podemos visualizar isso plotando um gráfico da direção do vetor de solução, que é uma linha que passa pela
origem e pelo ponto da solução.

Como podemos ver no gráfico anterior, qualquer outra linha que passa pela origem terá uma interseção com
essa linha, o que significa que pequenas mudanças nos valores da matriz ou do vetor podem levar a
grandes variações na solução.

Note que, em geral, pode ser difícil visualizar o comportamento de um sistema instável apenas através
de gráficos. Para avaliar a estabilidade de um sistema de equações lineares, é necessário analisar a
sua matriz A e determinar se ela é invertível. Caso contrário, o sistema é instável.
 Número de condição
O número de condição de uma matriz é uma medida da sensibilidade da solução de um sistema
de equações lineares à mudanças nos dados de entrada (coeficientes da matriz ou termos
independentes). Em outras palavras, ele mede o quão "bem comportado" é o sistema e indica se
pequenas perturbações nos dados de entrada podem resultar em grandes variações na solução.

O número de condição é definido como o produto da norma da matriz e da norma da sua matriz
inversa. Ele é calculado da seguinte forma: cond(A) = ||A|| * ||A-1||

Onde ||A|| é a norma da matriz A e ||A-1|| é a norma da matriz inversa de A.

Número de condição

● Um número de condição próximo de 1 indica que a matriz é bem-condicionada,

ou seja, pequenas mudanças nos dados de entrada resultam em pequenas
variações na solução.

● Um número de condição grande indica que a matriz é mal-condicionada, ou seja,

pequenas mudanças nos dados de entrada podem resultar em grandes variações
na solução.
 import numpy as np

Número de condição
import matplotlib.pyplot as plt

# Definir a matriz do sistema

A = np.array([[2, 1],
[1, 1]])

Vamos dar um exemplo em Python # Calcular o número de condição

de como calcular e plotar o número cond = np.linalg.cond(A)

de condição de uma matriz: # Imprimir o número de condição

print('Número de condição:', cond)

# Plotar a matriz A e a sua inversa

fig, axs = plt.subplots(1, 2)
axs[0].imshow(A)
axs[0].set_title('Matriz A')
axs[1].imshow(np.linalg.inv(A))
axs[1].set_title('Matriz A^-1')

# Plotar o número de condição

fig, ax = plt.subplots()
ax.bar(['cond(A)'], cond)
ax.set_title('Número de condição')
ax.set_ylim([0, 5])
plt.show()
Número de condição
O número de condição da matriz A é cerca de 3.8,
isso indica que pequenas perturbações nos dados
de entrada podem resultar em grandes variações
na solução do sistema.
Podemos visualizar a matriz A e sua inversa
plotando imagens das matrizes e o número de
condição plotando um gráfico de barra
O número de condição é uma medida geral da
sensibilidade do sistema, mas não indica
diretamente a estabilidade da solução
Um sistema pode ter um número de condição baixo
e ainda ser instável se a matriz A não for invertível
Um sistema pode ter um número de condição alto e
ainda ser estável se a matriz A for
bem-condicionada.
import numpy as np
import matplotlib.pyplot as plt
# Definir a matriz do sistema
A = np.array([[2, 1],
[1, 1]])
# Calcular o número de condição
cond = np.linalg.cond(A)
# Imprimir o número de condição
print('Número de condição:', cond)
# Plotar a matriz A e a sua inversa
fig, axs = plt.subplots(1, 2)
axs[0].imshow(A)
axs[0].set_title('Matriz A')
axs[1].imshow(np.linalg.inv(A))
axs[1].set_title('Matriz A^-1')
# Plotar o número de condição
fig, ax = plt.subplots()
ax.bar(['cond(A)'], cond)
ax.set_title('Número de condição')
ax.set_ylim([0, 5])
plt.show()
Cálculo da matriz inversa usando o método da eliminação de Gauss

O método da eliminação de Gauss é uma técnica utilizada para calcular a matriz inversa de uma matriz
quadrada A.

O processo envolve a transformação da matriz A em uma matriz identidade I por meio de operações
elementares de linha, e aplicando as mesmas operações na matriz identidade, resultando na matriz inversa
de A.

Em Python, podemos usar a biblioteca NumPy para calcular a matriz inversa de uma matriz usando o
método da eliminação de Gauss. Para isso, precisamos seguir os seguintes passos:
Cálculo da matriz inversa usando o método da eliminação de Gauss

1. Importar a biblioteca NumPy: import numpy as np

2. Definir a matriz A: A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 10]])

3. Definir a matriz identidade I: I = np.identity(3)

4. Concatenar as matrizes A e I: M = np.concatenate((A, I), axis=1)

for i in range(3):
5. Aplicar o método da eliminação de Gauss
pivot = M[i][i]
para transformar a matriz M em uma matriz
M[i] = M[i] / pivot
escada:
for j in range(3):
if i != j:
M[j] = M[j] - M[j][i] * M[i]

6. Extrair a matriz inversa de A a partir da matriz resultante: A_inv = M[:, 3:]

Cálculo da matriz inversa usando o método da eliminação de Gauss

O resultado final será a matriz inversa de A, que pode ser usada

para resolver sistemas lineares e outras operações matemáticas.

É importante lembrar que a matriz inversa só pode ser calculada se

a matriz A for invertível, ou seja, se seu determinante for diferente
de zero. Caso contrário, um erro será gerado.
Tipos especiais de matrizes
● Uma matriz banda é uma matriz em que a maioria dos elementos são zeros,
exceto aqueles que estão próximos da diagonal principal.

● Essa estrutura especial pode ser usada para otimizar cálculos matriciais, uma
vez que reduz a quantidade de operações necessárias para manipular a
matriz.

● Em Python, podemos criar uma matriz banda usando a biblioteca NumPy.

Para isso, podemos usar a função numpy.diag, que permite criar uma matriz
diagonal com os elementos especificados em uma lista. Em seguida,
podemos criar uma matriz vazia e inserir os elementos diagonais na posição
correta usando a função numpy.fill_diagonal.
Matriz banda
O código abaixo mostra um exemplo de
como criar uma matriz banda 5x5 com
valores aleatórios na diagonal principal e
secundária:
import numpy as np
# Criar uma matriz 5x5 vazia
A = np.zeros((5, 5))
# Definir a largura da banda (número de elementos
diferentes de zero próximos à diagonal principal)
k = 2
# Definir valores aleatórios para a diagonal principal e
secundária
diag_principal = np.random.rand(5)
diag_secundaria = np.random.rand(4)
# Inserir os elementos diagonais na matriz A
np.fill_diagonal (A, diag_principal , k=0)
np.fill_diagonal (A[:,1:], diag_secundaria , k=-1)
np.fill_diagonal (A[1:,:], diag_secundaria , k=1)
print(A)
Matriz banda

O resultado será uma matriz 5x5 com uma banda de largura 2 ao redor da diagonal principal, contendo
valores aleatórios na diagonal principal e secundária:

array([[0.655, 0.499, 0. , 0. , 0. ],
[0.976, 0.617, 0.811, 0. , 0. ],
[0. , 0.154, 0.808, 0.287, 0. ],
[0. , 0. , 0.064, 0.261, 0.841],
[0. , 0. , 0. , 0.115, 0.569]])

Podemos então usar essa matriz para realizar cálculos matriciais, como multiplicação de matriz e
resolução de sistemas lineares, aproveitando sua estrutura de banda para otimizar os cálculos.
Dúvidas?
vinicius.motta@uvv.br