Sistemas lineares,

métodos diretos e SciPy Prof. Paulo R. G. Bordoni

UFRJ

Surfista, descubra pela Internet o caminho das pedras sobre

Computação Científica e

Álgebra Linear Computacional.

Vou buscar no Google, Mestre!

Com a palavra-chave scientific computation,

achei:

Python e SciPy!

http://history.siam.org/

E com history of scientific computation,

achei:

Quando busquei por Numerical Linear Algebra, o 1º resultado

foi da Wikipedia:

• BLAS: Basic Linear Algebra Subprograms,

• LAPACK: Linear Algebra Package.

Repetindo: BLAS e LAPACK, bibliotecas

altamente otimizadas que implementam os algoritmos básicos de

Álgebra Linear Computacional.

Não deixem de olhar as listas indicadas de software de análise

numérica e de bibliotecas numéricas.

Fui buscar a BLAS no Google!

Um repositório de software importantíssimo!

O que é a Netlib:

A BLAS na www.netlib.org

Perguntas básicas:

O que é a BLAS:

A LAPACK na Wikipedia:

A continuação de LAPACK na Wikipedia:

O site oficial do LAPACK, claro: www.netlib.org

É aqui que começam as informações sobre Álgebra Linear no

SciPy.

Vamos mergulhar nas “Basic routines”

Basic routines

O que há na parte de rotinas básicas do Scipy sobre

solução de sistemas lineares:

Examinando as informações sobre o

solve()

Nesse “script” criamos uma matriz A e um vetor-coluna b.

Em seguida, chamamos o solve()

para resolver o sistema linear A*x = b.

Outra forma de obter

informações do solve()

Específica para sistemas

triangulares.

Detalhes do parâmetros.

Para resolver sistemas lineares cuja matriz é

de banda.

Detalhes dos parâmetros

Apropriada para matrizes hermitianas e

positivo-definidas.

Detalhamento dos parâmetos.

Exemplo.

Agora vamos explorar as fatorações (Decompositions) existentes no Linear Algebra.

Basic routines

Decompositions

A famosa fatoração LU.

A famosa fatoração LU – continuação.

Rotinas existentes no Reference Guide para

a fatoração LU.

Esta é uma das rotinas do linalg para realizar a fatoração PLU.

Ela só realiza a fatoração; não apresenta a solução.

A rotina pode efetuar o pivoteamento por linha (ou não). Ela retorna:

• as três matrizes P, L e U • ou apenas duas, a PL que é a triangular

inferior permutada e a U.

Esta é uma rotina alternativa à anterior.

Ela recebe a matriz A e retorna uma matriz contendo a fatoração LU e um vetor

contendo os índices de pivoteamento.

Os parâmetros retornados.

Esta rotina recebe a fatorada LU e o vetor piv fornecidos pela LU_factor( ).

Recebe também o termo independente b e retorna a solução x.

Uma brevíssima explicação do que é a

fatoração de Cholesky.

As rotinas do SciPy para a fatoração de Cholesky.

A explicação para passagem de parâmetros.

Esta rotina só efetua a fatoração. Deve ser usa

com a próxima.

Esta rotina resolve o sistema após fatorado pela

rotina cho_factor( ).

Esta é específica para matrizes de banda. Só

fatora.

Esta resolve o sistema linear, após a fatoração pela

cholesky_banded( ).

Carl Friedrich Gauss 30/04/1777 – 23/02/1855

Vamos encerrar este conjunto de transparências

detalhando o famoso Método de Eliminação, de

Gauss.

Na verdade ele não foi criado por Gauss.

Ele já aparece no cap. 8 do livro chinês “Os nove capítulos sobre a arte

matemática”, composto por gerações de mestres ao

longo dos séculos X a II A.C.

Fui buscar estas informações na

Wikipedia!

Vamos agora explicar como resolver um sistema linear como o abaixo, pelo

método de eliminação.

Primeiro descreveremos o método usando as equações.

Nosso objetivo será atingido em várias etapas consecutivas.

Em cada etapa utilizaremos operações elementares

sobre as linhas.

Elas são três:

Somar ou subtrair linhas

Multiplicar uma linha por um número real

Trocar duas linhas de posição

Na 1ª etapa, eliminaremos os termos envolvendo 𝑥1 nas equações após a 1ª, efetuando operações elementares nas

linhas.

Naturalmente os coeficientes e termos

independentes mudarão após essas operações.

Tornamos a repetir até ficarmos com um sistema triangular.

Repetimos o processo para o subsistema sem

a 1ª linha.

O último passo consiste em resolver o sistema triangular.

Algo extremamente simples.

O processo consiste, portanto, em eliminarmos incógnitas nas equações.

Daí o nome.

Ax = b

Já vimos que esse sistema pode ser reescrito na forma

matricial como abaixo:

Acrescentando o vetor b à última coluna da matriz A, obtemos uma

matriz referida na literatura como “matriz aumentada”.

Linha 1

Linha 2

Linha n

O processo de eliminação envolve efetuar as operações elementares,

sobre as linhas da matriz aumentada.

As operações elementares são:

Linha 1 Linha 1

Linha 2 Linha 2 Linha 1 𝐴21/𝐴11 × −

Linha 3 Linha 3 Linha 1 𝐴31/𝐴11 × −

Linha n Linha n Linha 1 𝐴𝑛1/𝐴11 × −

Multiplicadores

Observe que os multiplicadores foram escolhidos de forma a anular

todos os 𝐴𝑖1 abaixo do 𝐴11.

O 𝐴11 é intitulado “pivot”.

Essas operações exigem que o pivot seja não-nulo: 𝐴11 ≠ 0.

Caso 𝐴11 = 0 trocamos a linha 1 com outra onde 𝐴𝑖1 ≠ 0.

O final do processo é o mesmo: uma matriz triangular superior.

Repetimos apenas para evidenciar que não precisamos envolver as incógnitas no

processo – só os vetores linha da matriz aumentada.

De novo, os 𝐴𝑖𝑗 e os 𝑏𝑖 são modificadas a cada

passo do processo.

Quando pensamos nas equações, fica óbvio que as operações

elementares não alteram a solução.

Isto não é tão óbvio quando olhamos para a

matriz aumentada.

Uma forma de contornar a propagação de erro consiste em localizar o 𝐴1𝑗 de maior

valor absoluto e trocar a linha onde ele está com a linha 1.

Esta é a estratégia conhecida na literatura como pivoteamento parcial por coluna.

Quando o 𝐴11 é muito pequeno, por exemplo, 𝐴11 = 10−2, estamos ampliando 100 vezes o erro

envolvido na representação IEEE 754 dos multiplicadores, que então se propaga.

Esse processo, repetido ao longo da eliminação, acaba por arruinar a solução do sistema.

Antes que os Surfista reclame, vamos implementar um

programa para o método de eliminação.

Antes, vou mostrar um programa que facilita muito

a entrada de dados, via teclado, para sistemas lineares

Ax = b. Eu vivo errando na digitação!

Experimentei o programa do Mestre para um sisteminha 3x3.

Na pressa, cometi um erro, mas o programa me salvou

(de digitar tudo novamente) !

Este é o programa.

A continuação do código.

Porque eliminaram o Gauss, Mestre?

Coitado!

Agora o famoso Método de

Eliminação de Gauss.

Primeiro veremos a programação

no estilo clássico

para o Método de Eliminação, de Gauss.

Para facilitar o entendimento, vamos mostrar 1º a execução do

programa.

Depois discutiremos seu código.

Estes são a matriz A e o vetor b de nosso

exemplo.

Eis a 1ª etapa do processo de eliminação.

As operações elementares visam colocar zeros na 1ª coluna, abaixo do pivot.

É a mesma coisa que eliminar a variável x1 na 2ª, na 3ª e na 4ª equação.

pivot

Mestre, seu programa está errado!

A matriz A atualizada deveria ter sido esta aqui, com zeros abaixo

do pivot.

Mil perdões Loirinha!

Esqueci de dizer que usei o espaço dos zeros para guardar

os multiplicadores.

A 2ª etapa do processo de eliminação.

As operações elementares visam colocar zeros na 2ª coluna, abaixo do pivot.

É a mesma coisa que eliminar a variável x2 nas 3ª e 4ª equações.

Novamente, guardei os multiplicadores no lugar dos zeros.

A etapa final do processo de eliminação.

A solução x foi obtida por retro-substituição.

Após completarmos o processo de eliminação:

• a matriz A é a matriz triangular superior que eu marquei em rosa,

• e os multiplicadores estão em verde, abaixo da diagonal.

O método da fatoração LU decorre dessa ideia. U é de

upper e L é de lower.

1º passo

O processo de eliminação pode ser resumido, recursivamente, em dois passos:

1º passo – Zerar os elementos da matriz A abaixo do pivot via operações elementares,

2º passo – Enquanto possível, repetir o processo para a matriz que resta após retirarmos a linha e a coluna do pivot.

2º passo

Esse é o início do código.

Nada excepcional. Apenas definições básicas para

iniciar.

Aqui são definidas duas funções que vão mostrar o que está acontecendo.

Esta é a fase da eliminação.

O loop em k define as etapas do processo de eliminação.

É definido o pivot e, se ele é não-nulo, criamos uma

matriz-coluna, Mult, para guardar os multiplicadores.

No loop em j atualizamos cada elemento da linha i efetuando a operação elementar sobre ele.

O loop em i percorre as linhas abaixo do pivot e define um multiplicador

para cada linha.

Ainda dentro do loop em i efetuamos a operação

elementar sobre o elemento da linha i do termo independente b.

E guardamos esse multiplicador na linha i da coluna do pivot da matriz A e também na linha i do

vetor Mult.

Agora a fase da retro-substituição.

• Da última equação achamos diretamente o valor de xn .

• Substituímos esse valor na penúltima equação e achamos o valor de xn-1 .

• Assim por diante, de trás para frente, até chegar à 1ª equação, de onde achamos x1 .

0 1 2 3

0

1

2

3

Representarei uma matriz 4x4 por uma grade, como abaixo, porque não

estou interessada nos números.

Quero mostrar claramente o conceito de fatiamento.

Antes, vou mostrar 3 formas distintas de criar

matrizes.

A 3ª forma de criar matrizes é mais simples;

é como no Matlab.

Fatiando para obter as três últimas linhas e depois para obter as três 1ªs colunas.

0 1 2 3

0

1

2

3

0 1 2 3

0

1

2

3

Fatiando para obter as três últimas linhas

da 3ª e 4ª colunas e depois para obter

a 3ª coluna.

0 1 2 3

0

1

2

3

0 1 2 3

0

1

2

3

Fatiando para obter a 3ª linha e depois para

obter o bloco constituído pelas 1ª e 2ª linhas e

2ª e 3ª colunas.

0 1 2 3

0

1

2

3

0 1 2 3

0

1

2

3

Agora veremos a programação

com vetorização

para o Método de Eliminação, de Gauss.

O processo é exatamente o mesmo e, quando executado para a mesma matriz A e vetor b, reproduz fotograficamnte

o resultado do clássico.

A única diferença esta na vetorização das operações.

As duas funções

• mostrar_op_elem( ) • mostrar_result( )

são as mesmas do código tradicional.

Insira suas definições na parte rasgada deste código. O início dele é igual ao da programação tradicional.

O loop em k é o único. Como antes, ele descreve as etapas do processo de

eliminação.

Definimos o pivot e, se ele não é zero, criamos o vetor coluna Mult que

guardará os multiplicadores.

Ver nos slides finais.

Esta linha de código está vetorizada!

Nela, calculamos todos os multiplicadores da coluna k,

abaixo do pivot.

Num golpe só, como um samurai!

Veja o exemplo do Prof. na próxima transparência.

2

Em 1 temos vetorização, em 2

um loop.

1

Esta outra linha de código também está vetorizada.

Ela atualiza, de uma vez só, toda a sub matriz que pintei de azul.

A Professora explica uma parte desse código na próxima transparência.

Observem que:

e isso se repete para as outras duas linhas

0.5

-0.5 1.5 2.5

-1. 3. 5.

=

*

A 1ª das linhas acima coloca os multiplicadores na coluna k da matriz A,

abaixo do pivot. Num ato só.

A 2ª aplica as operações elementares em todos os elementos do vetor b, após

a posição correspondente ao pivot. Também num ato só.

Na substituição retroativa, também temos uma

vetorização.

Executem a versão vetorizada com os mesmos dados e

verifiquem que os resultados são idênticos.

No Guia de Referência do NumPy temos

Descendo um pouco em “Standard array subclasses”

encontraremos o que nos interessa:

“Matrix objects”:

Pois é Manuel, os detalhes sobre

matrizes começam aqui:

A continuação:

Muito simples mesmo, Mestra.

Professor, criei uma matriz M, 3x3.

Em seguida, mostrei o array M.A associado a ela, a sua transposta M.T, a hermitiana

associada, M.H, e a inversa M.I.

Tchau, até a próxima aula!