[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14 Álgebra Linear

Esse capítulo descreve funções para solucionar sistemas lineares. A biblioteca fornece operações de álgebra linear que atuam diretamente sobre objetos gsl_vector e objetos gsl_matrix. Essas rotinas usam algoritmos padronizados de Golub & Van Loan’s Matrix Computations com chamadas a BLAS Nível 1 e Nível 2 em nome da eficiência.

As funções descritas nesse capítulo são declaradas no arquivo de cabeçalho ‘gsl_linalg.h’.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.1 Decomposição LU

Uma matriz quadrada genérica A tem uma decomposição LU em matrizes triangulares alta e baixa,

P A = L U
onde P é uma matriz de permutação, L é a matriz unitária triangular baixa e U é a matriz triangular alta. Para matrizes quadradas essa decomposição pode ser usada para converter o sistema linear A x = b em um par de sistemas triangulares (L y = P b, U x = y), que pode ser resolvido por substituição. Note que a decomposição LU é válida para matrizes singulares.

Function: int gsl_linalg_LU_decomp (gsl_matrix * A, gsl_permutation * p, int * signum)
Function: int gsl_linalg_complex_LU_decomp (gsl_matrix_complex * A, gsl_permutation * p, int * signum)

Essas funções fatora a matriz quadrada A na decomposição LU PA = LU. Na saída a diagonal e a parte triangular alta da matriz de entrada A possuem a matriz U. A parte triangular baixa da matriz de entrada (excluindo a diagonal) contém L. Os elementos da diagonal L são unidades, e não são armazenados.

A matriz de permutação P é codificada na permutação p. A j-ésima coluna da matriz P é fornecida pela k-ésima coluna da matriz identidade, onde k = p_j o j-ésimo elemento do vetor de permutação. O sinal da permutação é fornecido por signum. O sinal da permutação tem o valor (-1)^n, onde n é o número de trocas na permutação.

O algoritmo usado na decomposição é a Eliminação de Gauss com pivotamento parcial (Golub & Van Loan, Matrix Computations, Algorithm 3.4.1).

Function: int gsl_linalg_LU_solve (const gsl_matrix * LU, const gsl_permutation * p, const gsl_vector * b, gsl_vector * x)
Function: int gsl_linalg_complex_LU_solve (const gsl_matrix_complex * LU, const gsl_permutation * p, const gsl_vector_complex * b, gsl_vector_complex * x)

Essas funções resolvem os sistema quadrado A x = b usando a decomposição LU de A em (LU, p) fornecido por gsl_linalg_LU_decomp ou gsl_linalg_complex_LU_decomp como entrada.

Function: int gsl_linalg_LU_svx (const gsl_matrix * LU, const gsl_permutation * p, gsl_vector * x)
Function: int gsl_linalg_complex_LU_svx (const gsl_matrix_complex * LU, const gsl_permutation * p, gsl_vector_complex * x)

Essas funções resolvem o sistema quadrado A x = b localmente usando a decomposição LU pré-computada de A em (LU,p). Na entrada x deve conter o segundo membro b, que é substituído pela solução na saída.

Function: int gsl_linalg_LU_refine (const gsl_matrix * A, const gsl_matrix * LU, const gsl_permutation * p, const gsl_vector * b, gsl_vector * x, gsl_vector * residual)
Function: int gsl_linalg_complex_LU_refine (const gsl_matrix_complex * A, const gsl_matrix_complex * LU, const gsl_permutation * p, const gsl_vector_complex * b, gsl_vector_complex * x, gsl_vector_complex * residual)

Essas funções aplicam um melhoramento iterativo ao valor de x, que é a solução de A x = b, a partir da decomposição LU pré-computada de A dentro de (LU,p). O resíduo inicial r = A x - b é também computado e armazenado em residual.

Function: int gsl_linalg_LU_invert (const gsl_matrix * LU, const gsl_permutation * p, gsl_matrix * inverse)
Function: int gsl_linalg_complex_LU_invert (const gsl_matrix_complex * LU, const gsl_permutation * p, gsl_matrix_complex * inverse)

Essas funções calculam a inversa de uma matriz A partindo de sua decomposição LU (LU,p), armazenando o resultado na matriz inverse. A inversa é calculada resolvendo o sistema A x = b para cada coluna da matriz identidade. Essa forma é preferível para evitar uso direto da inversa sempre que possível, uma vez que as funções resolvedoras lineares podem obter o mesmo resultado mais eficientemente e de forma mais confiável (consulte qualquer livro texto introdutório sobre álgebra numérica linear para maiores detalhes).

Function: double gsl_linalg_LU_det (gsl_matrix * LU, int signum)
Function: gsl_complex gsl_linalg_complex_LU_det (gsl_matrix_complex * LU, int signum)

Essas funções calculam o determinante de uma matriz A a partir de sua decomposição LU, armazenada na variável LU. O determinante é calculado como o produto dos elementos da diagonal de U e o sinal da permutação de linha signum.

Function: double gsl_linalg_LU_lndet (gsl_matrix * LU)
Function: double gsl_linalg_complex_LU_lndet (gsl_matrix_complex * LU)

Essas funções calculam o logaritmo do valor absoluto do determinante de uma matriz A, \ln|\det(A)|, a partir de sua decomposição LU, armazenada na variável LU. Essa função pode ser útil se o cálculo direto do determinante causar overflow ou underflow.

Function: int gsl_linalg_LU_sgndet (gsl_matrix * LU, int signum)
Function: gsl_complex gsl_linalg_complex_LU_sgndet (gsl_matrix_complex * LU, int signum)

Essas funções calculam o sinal ou fator de fase do determinante de uma matriz A, \det(A)/|\det(A)|, a partir de sua decomposição LU, armazenada na variável LU.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.2 Decomposição QR

Uma matriz genérica A retangular M-por-N tem uma decomposição QR composta pelo produto de uma matriz quadrada Q ortogonal M-por-M (onde Q^T Q = I) e uma matriz M-por-N triangular direita R,

A = Q R
Essa decomposição pose ser usada para converter o sistema linear A x = b no sistema triangular R x = Q^T b, que pode ser resolvido por substituição reversa. Outro uso da decomposição QR é para calcular uma base ortonormal para um conjunto de vetores. As primeiras N colunas de Q formam um base ortonormal para o intervalo de A, ran(A), quando A tiver posto de coluna completo.

Function: int gsl_linalg_QR_decomp (gsl_matrix * A, gsl_vector * tau)

Essa função fatoriza a matriz A de ordem M-por-N na decomposição QR A = Q R. Na saída a diagonal e a parte triangular alta da matriz de entrada possuem a matriz R. O vetor tau e as colunas da parte triangular baixa da matriz A possuem os coeficientes de Householder e vetores de Householder que codificam a matriz ortogonal Q. O vetor tau deve ser de comprimento k=\min(M,N). O vetor da matriz Q está relacionado a essas componentes por, Q = Q_k ... Q_2 Q_1 onde Q_i = I - \tau_i v_i v_i^T e v_i é o vetor de Householder v_i = (0,...,1,A(i+1,i),A(i+2,i),...,A(m,i)). Esse é o mesmo esquema de armazenamento usado na biblioteca LAPACK.

O algoritmo usado para executar a decomposição é Householder QR (Golub & Van Loan, Matrix Computations, Algoritmo 5.2.1).

Function: int gsl_linalg_QR_solve (const gsl_matrix * QR, const gsl_vector * tau, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema quadrado A x = b usando a decomposição QR de A mantida em (QR, tau) que deve ter sido calculada previamente com gsl_linalg_QR_decomp. A solução mínimo quadrado para sistemas retangulares pode ser encontrada usando gsl_linalg_QR_lssolve.

Function: int gsl_linalg_QR_svx (const gsl_matrix * QR, const gsl_vector * tau, gsl_vector * x)

Essa função resolve o sistema quadrado A x = b localmente usando a decomposição QR da matriz A mantida em (QR,tau) que deve ter sido calculada previamente através de gsl_linalg_QR_decomp. Na entrada x deve conter o segundo membro b, que é substituido pela solução na saída.

Function: int gsl_linalg_QR_lssolve (const gsl_matrix * QR, const gsl_vector * tau, const gsl_vector * b, gsl_vector * x, gsl_vector * residual)

Essa função encontra a solução mínima quadrada para o sistema sobredeterminado A x = b onde a matriz A tem mais linhas que colunas. A solução mínima quadrada minimiza o módulo Euclideano do resíduo, ||Ax - b||. A rotina requer como entrada a decomposição QR de A em (QR, tau) fornecido através de gsl_linalg_QR_decomp. A solução é retornada em x. O resíduo é calculado como um por-produto e armazenado em residual.

Function: int gsl_linalg_QR_QTvec (const gsl_matrix * QR, const gsl_vector * tau, gsl_vector * v)

Essa função aplica a matriz Q^T codificada na decomposição (QR,tau) para o vetor v, armazenando o resultado Q^T v em v. A multiplicação de matriz é realizada diretamente usando a codificação de vetores de Householder sem precisar formar a matriz completa Q^T.

Function: int gsl_linalg_QR_Qvec (const gsl_matrix * QR, const gsl_vector * tau, gsl_vector * v)

Essa função aplica a matriz Q codificada na decomposição (QR,tau) ao vetor v, armazenando o resultado Q v em v. A multiplicação da matriz é realizada diretamente usando a codificação de vetores de Householder sem precisar formar a matriz completa Q.

Function: int gsl_linalg_QR_QTmat (const gsl_matrix * QR, const gsl_vector * tau, gsl_matrix * A)

Essa função aplica a matriz Q^T codificada na decomposição (QR,tau) na matriz A, armazenado o resultado Q^T A em A. A multiplicação de matriz é realizada diretamente usando a codificação de vetores de Householder sem precisar formar a matriz completa Q^T.

Function: int gsl_linalg_QR_Rsolve (const gsl_matrix * QR, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema triangular R x = b em relação a x. Essa função pode ser útil se o produto b' = Q^T b já tiver sido calculado usando gsl_linalg_QR_QTvec.

Function: int gsl_linalg_QR_Rsvx (const gsl_matrix * QR, gsl_vector * x)

Essa função resolve o sistema triangular R x = b em relação a x localmente. Na entrada x deve conter o segundo membro da igualdade b e é substituído pela solução na saída. Essa função pode ser útil se o produto b' = Q^T b já tiver sido calculado usando gsl_linalg_QR_QTvec.

Function: int gsl_linalg_QR_unpack (const gsl_matrix * QR, const gsl_vector * tau, gsl_matrix * Q, gsl_matrix * R)

Essa função desempacota a decomposição codificada QR (QR,tau) em matrizes Q e R, onde Q é de ordem M-por-M e R é de ordem M-por-N.

Function: int gsl_linalg_QR_QRsolve (gsl_matrix * Q, gsl_matrix * R, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema R x = Q^T b em relação a x. Essa função pode ser usada quando a decomposição QR de uma matriz está disponível na forma desempacotada como (Q, R).

Function: int gsl_linalg_QR_update (gsl_matrix * Q, gsl_matrix * R, gsl_vector * w, const gsl_vector * v)

Essa função executa uma atualização posto-1 w v^T da decomposição QR (Q, R). A atualização é fornecida por Q'R' = Q (R + w v^T) onde as matrizes de saída Q' e R' são também ortogonal e triangular direita. Note que w é destruída pela atualização.

Function: int gsl_linalg_R_solve (const gsl_matrix * R, const gsl_vector * b, gsl_vector * x)

Essa função resolve sistema triangular R x = b para a matriz R de ordem N-por-N.

Function: int gsl_linalg_R_svx (const gsl_matrix * R, gsl_vector * x)

Essa função resolve o sistema triangular R x = b localmente. Na entrada x deve conter o segundo membro da igualdade b, o qual é substituído pela solução na saída.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.3 Decomposição QR com Pivotamento de Colunas

A decomposição QR pode ser extendida para o caso deficiente de posto por introdução de uma permutação de coluna P,

A P = Q R
As primeiras r colunas de Q formam uma base ortonormal para o intervalo de A para uma matriz com posto coluna r. Essa decomposição pode também ser usada para converter o sistema linear A x = b no sistema triangular R y = Q^T b, x = P y, o qual pode ser resolvido por substituição reversa e permutação. Denotamos a decomposição QR com pivotamento de coluna através de QRP^T uma vez que A = Q R P^T.

Function: int gsl_linalg_QRPT_decomp (gsl_matrix * A, gsl_vector * tau, gsl_permutation * p, int * signum, gsl_vector * norm)

Essa função fatoriza a matriz A de ordem M-por-N na decomposição QRP^Tde forma que A = Q R P^T. Na saída a diagonal e a parte triangular alta da matriz de entrada possuem a matriz R. A matriz de permutação P é armazenada na permutação p. O sinal da permutação é fornecido por signum. O sinal da permutação tem o valor (-1)^n, onde n é o número de trocas na permutação. O vetor tau e as colunas da parte triangular baixa da matriz A possuem os coeficientes de Householder e vetores que codificam a matriz ortogonal Q. O vetor tau deve ser de comprimento k=\min(M,N). A matriz Q é relacionada a esses componentes através de, Q = Q_k ... Q_2 Q_1 onde Q_i = I - \tau_i v_i v_i^T e v_i é o vetor de Householder v_i = (0,...,1,A(i+1,i),A(i+2,i),...,A(m,i)). Esse esquema de armazenamento é o mesmo usado por LAPACK. O vetor norm é um espaço de trabalho de comprimento N usado para pivotamento de coluna.

O algoritmo usado para executar a decomposição é o de Householder QR com pivotamento de coluna (Golub & Van Loan, Matrix Computations, Algorítimo 5.4.1).

Function: int gsl_linalg_QRPT_decomp2 (const gsl_matrix * A, gsl_matrix * q, gsl_matrix * r, gsl_vector * tau, gsl_permutation * p, int * signum, gsl_vector * norm)

Essa função fatoriza a matriz A na decomposição A = Q R P^T sem modificar a matriz A propriamente dita e armazena a saída em matrizes separadas q e r.

Function: int gsl_linalg_QRPT_solve (const gsl_matrix * QR, const gsl_vector * tau, const gsl_permutation * p, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema quadrado A x = b usando a decomposição QRP^T da matriz A mantida em QR, tau, p) que deve ter sido calculado previamente por gsl_linalg_QRPT_decomp.

Function: int gsl_linalg_QRPT_svx (const gsl_matrix * QR, const gsl_vector * tau, const gsl_permutation * p, gsl_vector * x)

Essa função resolve o sistema quadrado A x = b localmente usando a decomposição QRP^T de A mantida em (QR,tau,p). Na entrada x deve conter o segundo membro da igualdade b, que é substituído pela solução na saída.

Function: int gsl_linalg_QRPT_QRsolve (const gsl_matrix * Q, const gsl_matrix * R, const gsl_permutation * p, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema quadrado R P^T x = Q^T b em relação a x. Pode ser usada quando a decomposição QR de uma matriz estiver disponível na forma desempacotada como (Q, R).

Function: int gsl_linalg_QRPT_update (gsl_matrix * Q, gsl_matrix * R, const gsl_permutation * p, gsl_vector * w, const gsl_vector * v)

Essa função pexecuta uma atualização posto-1 w v^T da decomposição QRP^T (Q, R, p). A atualização é fornecida por Q'R' = Q (R + w v^T P) onde as matrizes de saída Q' e R' são também ortogonais e triangular direita. Note que w é destruído pela atualização. a permutação p não é modificada.

Function: int gsl_linalg_QRPT_Rsolve (const gsl_matrix * QR, const gsl_permutation * p, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema triangular R P^T x = b para a matriz R de ordem N-por-N contida em QR.

Function: int gsl_linalg_QRPT_Rsvx (const gsl_matrix * QR, const gsl_permutation * p, gsl_vector * x)

Essa função resolve o sistema triangular R P^T x = b localmente para a matriz R de ordem N-por-N contida em QR. Na entrada x deve conter o segundo membro b, que é substituído pela solução na saída.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.4 Decomposição de Valor Singular

Uma matriz A retangular genérica de ordem M-por-N tem uma decomposição de valor singular (DVS (36)) no produto de uma matriz ortogonal U de ordem M-por-N , matriz diagonal de valores singulares S de ordem N-por-N e a transposta de uma matriz ortogonal quadrada V de ordem N-por-N,

A = U S VT
Os valores singulares \sigma_i = S_{ii} são todos não negativos e são geralmente escolhidos para formar uma sequência não crescente \sigma_1 >= \sigma_2 >= ... >= \sigma_N >= 0.

A decomposição de valor singular de uma matriz tem muitos usos práticos. O número de condição da matriz é dado pela razão entre o maior valor singular e o menor valor singular. A presença de um valor singular zero indica que a matriz é singular. O número de valores singulares não nulos indica o posto da matriz. Na prática a decomposição de valor singular de uma matriz posto deficiente não irá produzir zeros exatos para valores singulares, devido à precisão numérica finita. Pequenos valores singulares devem ser editados escolhendo uma tolerância adequada.

Para uma matriz posto deficiente, o espaço nulo de A é dado pelas colunas de V que correspondem a valores singulares nulos. Semelhantemente, o intervalo de A é dado pelas colunas de U que correspondem a valores singulares não nulos.

Note que as rotinas aqui calculam a versão “esparsa” da DVS com U como matriz ortogonal de ordem M-por-N. Isso permite cálculos localmente e é a forma mais comumente usada na prática. Matematicamente, a DVS “completa” é definida com U como uma matriz ortogonal de ordem M-por-M e S como uma matriz diagonal de ordem M-por-N (com linhas adicionais nulas).

Function: int gsl_linalg_SV_decomp (gsl_matrix * A, gsl_matrix * V, gsl_vector * S, gsl_vector * work)

Essa função fatora a matriz A de ordem M-por-N na decomposição de valor singular A = U S V^T para M >= N. Na saída a matriz A é substituída por U. Os elementos da diagonal da matriz de valores singulares S são armazenados no vetor S. Os valores singulares são não negativos e formam uma sequência não crescente de S_1 a S_N. A matriz V contém os elementos de V na forma não transposta. Para formar o produto U S V^T é necessário tomar a transposta de V. Um espaço de trabalho de comprimento N é necessário e armazenado em work.

Essa rotina usa o algoritmo de decomposição em valores singulares de Golub-Reinsch.

Function: int gsl_linalg_SV_decomp_mod (gsl_matrix * A, gsl_matrix * X, gsl_matrix * V, gsl_vector * S, gsl_vector * work)

Essa função calcula a DVS usando o algoritmo modificado de Golub-Reinsch, que é mais rápido nos casos onde M>>N. Requer o vetor work de comprimento N e a matriz X de ordem N-por-N como espaço de trabalho adicional.

Function: int gsl_linalg_SV_decomp_jacobi (gsl_matrix * A, gsl_matrix * V, gsl_vector * S)

Essa função calcula a DVS da matriz A de ordem M-por-N usando ortogonalização de Jacobi de um lado para M >= N. O método de Jacobi pode calcular valores singulares para maiores precisões relativas que os algoritmos de Golub-Reinsch (veja as referências para detalhes).

Function: int gsl_linalg_SV_solve (const gsl_matrix * U, const gsl_matrix * V, const gsl_vector * S, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema A x = b usando a decomposição de valor singular (U, S, V) de A que deve ter sido calculada préviamente com gsl_linalg_SV_decomp.

Somente valores singulares não nulos são usados no cálculo da solução. As partes da solução correspondendo aos valores singulares nulos são ignoradas. Outros valores singulares podem ser editados na saída ajustando-os para zero antes de chamar essa função.

No caso onde A tem mais linhas que colunas o sistema é resolvido no senso dos mínimos quadrados, retornando a solução x que minimiza ||A x - b||_2.

Function: int gsl_linalg_SV_leverage (const gsl_matrix * U, gsl_vector * h)

Essa função calcula os valores estatísticos de maximização h_i de uma matriz A usando decomposição em valores singulares (U, S, V) previamente calculados com gsl_linalg_SV_decomp. Os h_i são os valores de diagonal da matriz A (A^T A)^{-1} A^T e dependem somente da matriz U que é a entrada para essa função.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.5 Decomposição de Cholesky

Uma matriz quadrada definida positiva A simétrica tem uma decomposição de Cholesky em um produto de uma matriz triangular baixa L e sua transposta L^T,

A = L LT
Isso é algumas vezes referido como tomar a raíz quadrada de uma matriz. A decomposição de Cholesky pode somente ser realizada quando todos os autovalores da matriz são positivos. Essa decomposição pode ser usada para converter o sistema linear A x = b em um par de sistemas triangulares (L y = b, L^T x = y), que podem ser resovidos por substituição adiante e e por substituição voltando.

Function: int gsl_linalg_cholesky_decomp (gsl_matrix * A)
Function: int gsl_linalg_complex_cholesky_decomp (gsl_matrix_complex * A)

Essas funções fatoram a matriz quadrada definida positiva simétrica A na decomposição de Cholesky A = L L^T (ou A = L L^H para o caso complexo). Na entrada, os valores da diagonal e da parte triangular baixa da matriz A são usados (a parte triangular alta é ignorada). Na saída a diagonal e a parte triangular baixa da matriz de entrada A possuem a matriz L, enquanto a parte triangular alta da matriz de entrada é sobrescrita com L^T (os termos da diagonal sendo idênticos para ambas as matrizes L e L^T). Se a matriz não for definida positiva então a decomposição irá falhar, retornando o código de erro GSL_EDOM.

Ao testar se uma matriz é definida positiva, desabilite o controlador de erro primeiramente para evitar o bombardeamento com mensagens de erro.

Function: int gsl_linalg_cholesky_solve (const gsl_matrix * cholesky, const gsl_vector * b, gsl_vector * x)
Function: int gsl_linalg_complex_cholesky_solve (const gsl_matrix_complex * cholesky, const gsl_vector_complex * b, gsl_vector_complex * x)

Essas funções resolve o sistema A x = b usando a decomposição de Cholesky de A mantida na matriz cholesky que deve ter sido previamente calculada por gsl_linalg_cholesky_decomp ou por gsl_linalg_complex_cholesky_decomp.

Function: int gsl_linalg_cholesky_svx (const gsl_matrix * cholesky, gsl_vector * x)
Function: int gsl_linalg_complex_cholesky_svx (const gsl_matrix_complex * cholesky, gsl_vector_complex * x)

Essas funções resolve o sistema A x = b localmente usando a decomposição de Cholesky de A mantida na matriz cholesky que deve ter sido previamente calculada por gsl_linalg_cholesky_decomp ou por gsl_linalg_complex_cholesky_decomp. Na entrada x deve conter o segundo membro b, que é substituído pela solução na saída.

Function: int gsl_linalg_cholesky_invert (gsl_matrix * cholesky)
Function: int gsl_linalg_complex_cholesky_invert (gsl_matrix_complex * cholesky)

Essas funções calculam a inversa de uma matriz a partir de sua decomposição de Cholesky cholesky, que deve ter sido calculada previamente por gsl_linalg_cholesky_decomp ou por gsl_linalg_complex_cholesky_decomp. Na saída, a inversa é armazenada localmente em cholesky.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.6 Decomposição Tridiagonal de Matrizes Simétricas Reais

Uma matriz simétrica A pode ser fatorada por transformação de semelhança na forma,

A = Q T QT
onde Q é uma matriz ortogonal e T é matriz simétrica tridiagonal.

Function: int gsl_linalg_symmtd_decomp (gsl_matrix * A, gsl_vector * tau)

Essa função fatora matriz quadrada simétrica A na decomposição tridiagonal simétrica Q T Q^T. Na saída a diagonal e a parte da subdiagonal da matriz de entrada A possuem a matriz tridiagonal T. A parte restante triangular baixa da matriz de entrada possui os vetores de Householder que, juntamente com os coeficientes de Householder tau, codificam a matriz ortogonal Q. Esse esquema de armazenagem é o mesmo usado em LAPACK. A parte triangular alta de A não é referenciada.

Function: int gsl_linalg_symmtd_unpack (const gsl_matrix * A, const gsl_vector * tau, gsl_matrix * Q, gsl_vector * diag, gsl_vector * subdiag)

Essa função desempacota a decomposição tridiagonal simética codificada em (A, tau) obtida a partir de gsl_linalg_symmtd_decomp na matriz ortogonal Q, no vetor de elementos da diagonal diag e no vetor de elementos da subdiagonal subdiag.

Function: int gsl_linalg_symmtd_unpack_T (const gsl_matrix * A, gsl_vector * diag, gsl_vector * subdiag)

Essa função desempacota a diagonal e a subdiagonal da decomposição simétrica tridiagonal codificada em (A, tau) obtida a partir de gsl_linalg_symmtd_decomp nos vetores diag e subdiag.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.7 Decomposição Tridiagonal de Matrizes de Hermite

Uma matriz de Hermite A pode ser fatorada por transformações de semelhança na forma,

A = U T UT
onde U é uma matriz unitária e T é uma matriz tridiagonal real simétrica.

Function: int gsl_linalg_hermtd_decomp (gsl_matrix_complex * A, gsl_vector_complex * tau)

Essa função fatora a matriz de Hermite A na decomposição tridiagonal simétrica U T U^T. Na saída as partes real da diagonal e a parte da subdiagonal da matriz de entrada A possuem a matriz tridiagonal T. A restante parte triangular baixa da matriz de entrada contém os vetores de Householder que, juntamente com os coeficientes de Householder tau, codificam a matriz unitária U. Esse esquema de armazenagem é o mesmo usado em LAPACK. A parte triangular alta de A e as partes imaginárias da diagonal não são referenciadas.

Function: int gsl_linalg_hermtd_unpack (const gsl_matrix_complex * A, const gsl_vector_complex * tau, gsl_matrix_complex * U, gsl_vector * diag, gsl_vector * subdiag)

Essa função desempacota a decomposição tridiagonal codificada em (A, tau) obtida a partir de gsl_linalg_hermtd_decomp na matriz unitária U, no vetor real de elementos da diagonal diag e o vetor real de elementos da subdiagonal subdiag.

Function: int gsl_linalg_hermtd_unpack_T (const gsl_matrix_complex * A, gsl_vector * diag, gsl_vector * subdiag)

Essa função desempacota a diagonal e a subdiagonal da decomposição tridiagonal codificada em (A, tau) obtida a partir de gsl_linalg_hermtd_decomp nos vetores reais diag e subdiag.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.8 Decomposição de Hessenberg de Matrizes Reais

Uma matriz genérica A pode ser decomposta por transformações de semelhança ortogonais na forma

A = U H UT
onde U é ortogonal e H é uma matriz alta de Hessenberg, significando que essa matriz tem zeros abaixo da primeira subdiagonal. A redução de Hessenberg é o primeiro passo na decomposição de Schur para o problema do autovalor não simétrico, mas tem aplicações em outras áreas também.

Function: int gsl_linalg_hessenberg_decomp (gsl_matrix * A, gsl_vector * tau)

Essa função calcula a decomposição de Hessenberg da matriz A aplicando a transformação de semelhança H = U^T A U. Na saída, H é armazenada na porção alta de A. A informação requerida para construir a matriz U é armazenada na porção triangular baixa de A. U é um produto de N - 2 matrizes de Householder. Os vetores de Householder são armazenados na porção baixa de A (abaixo da subdiagonal) e os coeficientes de Householder são armazenados no vetor tau. O vetor tau deve ser de comprimento N.

Function: int gsl_linalg_hessenberg_unpack (gsl_matrix * H, gsl_vector * tau, gsl_matrix * U)

Essa função contrói a matriz ortogonal U a partir da informação armazenada na matriz de Hessenberg H juntamente com o vetor tau. H e tau são saídas de gsl_linalg_hessenberg_decomp.

Function: int gsl_linalg_hessenberg_unpack_accum (gsl_matrix * H, gsl_vector * tau, gsl_matrix * V)

Essa função é semelhante a gsl_linalg_hessenberg_unpack, exceto que acumula a matriz U em V, de forma que V' = VU. A matriz V deve ser inicializada previamente para chamar essa função. Ajustando V para a matriz identidade fornece o mesmo resultado que gsl_linalg_hessenberg_unpack. Se H for de ordem N, então V deve ter N colunas mas pode ter qualquer número de linhas.

Function: int gsl_linalg_hessenberg_set_zero (gsl_matrix * H)

Essa função ajusta a porção triangular baixa de H, abaixo da subdiagonal, para zero. É útil para limpar a saída dos vetores de Householder após chamar gsl_linalg_hessenberg_decomp.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.9 Decomposição Triangular de Hessemberg de Matrizes Reais

Um par genérico de matrizes reais (A, B) pode ser decomposto em transformações de semelhança ortogonais na forma

A = U H VT

B = U R VT
onde U e V são ortogonais, H é uma matriz de Hessenberg alta, e R é triangular alta. A redução triangular de Hessenberg é o primeiro passo na decomposição de Schur generalizada para o problema generalizado de autovalor.

Function: int gsl_linalg_hesstri_decomp (gsl_matrix * A, gsl_matrix * B, gsl_matrix * U, gsl_matrix * V, gsl_vector * work)

Essa função calcula a decomposição triangular de Hessenberg do par de matrizes (A, B). Na saída, H é armazenada em A, e R é armazenada em B. Se U e V forem fornecidas (elas podem ser nulas), as transformações de semelhança são armazenadas nelas. Espaço de trabalho adicional de comprimento N é necessário em work.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.10 Bidiagonalização

Uma matriz genérica A pode ser fatorada por transformações de semelhança na forma,

A = U B VT
onde U e V são matrizes ortogonais e B é uma matriz bidiagonal de ordem N-por-N com entradas não nulas somente na diagonal e na superdiagonal. A ordem de U é M-por-N e a ordem de V é N-por-N.

Function: int gsl_linalg_bidiag_decomp (gsl_matrix * A, gsl_vector * tau_U, gsl_vector * tau_V)

Essa função fatora a matriz A de ordem M-por-N na forma bidiagonal U B V^T. A diagonal e a superdiagonal da matriz B são armazenadas na diagonal e na superdiagonal de A. As matrizes ortogonais U e V são armazenadas como vetores comprimidos de Householder nos elementos restantes de A. Os coeficientes de Householder são armazenados nos vetores tau_U e tau_V. O comprimento de tau_U deve ser igual ao número de elementos na diagonal de A e o comprimento de tau_V deve sem um elementos mais curto.

Function: int gsl_linalg_bidiag_unpack (const gsl_matrix * A, const gsl_vector * tau_U, gsl_matrix * U, const gsl_vector * tau_V, gsl_matrix * V, gsl_vector * diag, gsl_vector * superdiag)

Essa função revela a decomposição bidiagonal de A produzida por gsl_linalg_bidiag_decomp, (A, tau_U, tau_V) em matrizes ortogonais separadas U, V e o vetor diagonal diag e o vetor superdiagonal superdiag. Note que U é armazenado como uma matriz ortogonal compacta de ordem M-por-N satisfazendo U^T U = I por eficiência.

Function: int gsl_linalg_bidiag_unpack2 (gsl_matrix * A, gsl_vector * tau_U, gsl_vector * tau_V, gsl_matrix * V)

Essa função revela a decomposição bidiagonal de A produzida por gsl_linalg_bidiag_decomp, (A, tau_U, tau_V) nas matrizes ortogonais separadas U, V e o vetor diagonal diag e o vetor superdiagonal superdiag. A matriz U é armazenada localmente em A.

Function: int gsl_linalg_bidiag_unpack_B (const gsl_matrix * A, gsl_vector * diag, gsl_vector * superdiag)

Essa função revela a diagonal e a superdiagonal da decomposição bidiagonal de A a partir de gsl_linalg_bidiag_decomp, no vetor diagonal diag e no vetor superdiagonal superdiag.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.11 Transformações de Householder

Uma transformação de Householder é uma modificação posto-1 da matriz identidade a qual pode ser usada para zerar elementos selecionados de um vetor. Uma matriz de Householder P toma a forma,

P = I − τv vT
onde v é um vetor (chamado vetor de Householder) e \tau = 2/(v^T v). As funções descritas nessa seção usam a estrutura posto-1 da matriz de Householder para criar e aplicar transformações de Householder eficientemente.

Function: double gsl_linalg_householder_transform (gsl_vector * v)
Function: gsl_complex gsl_linalg_complex_householder_transform (gsl_vector_complex * v)

Essa função prepara uma transformação de Householder P = I - \tau v v^T que pode ser usada para zerar todos os elentos do vetor de entrada exceto o primeiro. Na saída a transformação é armazenada no vetor v e o escalar \tau é retornado.

Function: int gsl_linalg_householder_hm (double tau, const gsl_vector * v, gsl_matrix * A)
Function: int gsl_linalg_complex_householder_hm (gsl_complex tau, const gsl_vector_complex * v, gsl_matrix_complex * A)

Essa função aplica a matriz de Householder P definida pelo escalar tau e o vetor v ao lado esquerdo da matriz A. Na saída o resultado P A é armazenado em A.

Function: int gsl_linalg_householder_mh (double tau, const gsl_vector * v, gsl_matrix * A)
Function: int gsl_linalg_complex_householder_mh (gsl_complex tau, const gsl_vector_complex * v, gsl_matrix_complex * A)

Essa função aplica a matriz de Householder P definida pelo escalar tau e pelo vetor v ao lado direito da matriz A. Na saída o resultado A P é armazenado em A.

Function: int gsl_linalg_householder_hv (double tau, const gsl_vector * v, gsl_vector * w)
Function: int gsl_linalg_complex_householder_hv (gsl_complex tau, const gsl_vector_complex * v, gsl_vector_complex * w)

Essa função aplica a transformação de Householder P definida pelo escalar tau e pelo vetor v para o vetor w. Na saída o resultado P w é armazenado em w.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.12 Resolvedor de Householder para sistemas lineares

Function: int gsl_linalg_HH_solve (gsl_matrix * A, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema A x = b diretamente usando transformações de Householder. Na saída a solução é armazenada em x e b não é modificada. A matriz A é destruída pelas transformações de Householder.

Function: int gsl_linalg_HH_svx (gsl_matrix * A, gsl_vector * x)

Essa função resolve o sistema A x = b localmente usando transformações de Householder. Na entrada x deve conter o segundo membro da igualdade b, o qual é substituído pela solução na saída. A matriz A é destruída pelas transformações de Householder.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.13 Sistemas Tridiagonais

As funções descritas nessa seção resolvem eficientemente sistemas tridiagonais simétricos, não simétricos e cíclicos com armazenamento mínimo. Note que as implementações atuais dessas funções usam uma variante da decomposição de Cholesky, de forma que a matriz tridiagonal deve ser definida positiva. Para matrizes não definidas positivas, as funções retornam o código de erro GSL_ESING.

Function: int gsl_linalg_solve_tridiag (const gsl_vector * diag, const gsl_vector * e, const gsl_vector * f, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema genérico A x = b de ordem N-por-N onde A é uma matriz tridiagonal (N >= 2). Os vetores superdiagonal e subdiagonal e e f devem ser um elemento mais curto que o vetor diagonal diag. A forma de A para o caso 4-por-4 é mostrado abaixo,

A =





d0
e0
0
0
f0
d1
e1
0
0
f1
d2
e2
0
0
f2
d3






Function: int gsl_linalg_solve_symm_tridiag (const gsl_vector * diag, const gsl_vector * e, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema genérico A x = b de ordem N-por-N onde A é tridiagonal simétrica (N >= 2). O vetor off-diagonal e (37)deve ser um elementos mais curto que o vetor diagonal diag. A forma de A para o caso 4-por-4 é mostrada abaixo,

A =





d0
e0
0
0
e0
d1
e1
0
0
e1
d2
e2
0
0
e2
d3






Function: int gsl_linalg_solve_cyc_tridiag (const gsl_vector * diag, const gsl_vector * e, const gsl_vector * f, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema genérico A x = b de ordem N-por-N onde A é tridiagonal cíclica (N >= 3). Os vetores cíclicos superdiagonal e e subdiagonal f devem ter o mesmo número de elementos do vetor diagonal diag. A forma de A para o caso 4-por-4 é mostrado abaixo,

A =





d0
e0
0
f3
f0
d1
e1
0
0
f1
d2
e2
e3
0
f2
d3






Function: int gsl_linalg_solve_symm_cyc_tridiag (const gsl_vector * diag, const gsl_vector * e, const gsl_vector * b, gsl_vector * x)

Essa função resolve o sistema genérico A x = b de ordem N-por-N onde A é tridiagonal cíclica (38) simétrica (N >= 3). O vetor cíclico off-diagonal e deve ter o mesmo número de elementos do vetor diagonal diag. A forma de A para o caso 4-por-4 é mostrada abaixo,

A =





d0
e0
0
e3
e0
d1
e1
0
0
e1
d2
e2
e3
0
e2
d3







[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.14 Balanceamento

O processo de balanceamento de uma matriz aplica transformações de semelhança para fazer com que linhas e colunas tenham normas comparáveis. Isso é útil, por exemplo, para reduzir erros de arredondamento na solução de problemas com autovalores. Balancear uma matriz A consiste na substituição de A por uma matriz semelhante

A′ = D−1 A D
onde D é uma matriz diagonal cujas entradas são expoentes da raiz em ponto flutuante.

Function: int gsl_linalg_balance_matrix (gsl_matrix * A, gsl_vector * D)

Essa função substitui a matriz A por sua correspondente balanceada e armazena os elementos da diagonal da transformação de semelhança no vetor D.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.15 Exemplos

O seguinte programa resolve o sistema linear A x = b. O sistema a ser resolvido é,







0.18
0.60
0.57
0.96
0.41
0.24
0.99
0.58
0.14
0.30
0.97
0.66
0.51
0.13
0.19
0.85












x0
x1
x2
x3






=





1.0
2.0
3.0
4.0






e a solução é encontrada usando a decomposição LU da matriz A.

#include <stdio.h>
#include <gsl/gsl_linalg.h>

int
main (void)
{
  double a_data[] = { 0.18, 0.60, 0.57, 0.96,
                      0.41, 0.24, 0.99, 0.58,
                      0.14, 0.30, 0.97, 0.66,
                      0.51, 0.13, 0.19, 0.85 };

  double b_data[] = { 1.0, 2.0, 3.0, 4.0 };

  gsl_matrix_view m 
    = gsl_matrix_view_array (a_data, 4, 4);

  gsl_vector_view b
    = gsl_vector_view_array (b_data, 4);

  gsl_vector *x = gsl_vector_alloc (4);
  
  int s;

  gsl_permutation * p = gsl_permutation_alloc (4);

  gsl_linalg_LU_decomp (&m.matrix, p, &s);

  gsl_linalg_LU_solve (&m.matrix, p, &b.vector, x);

  printf ("x = \n");
  gsl_vector_fprintf (stdout, x, "%g");

  gsl_permutation_free (p);
  gsl_vector_free (x);
  return 0;
}

Aqui está a saída do programa,

x = -4.05205
-12.6056
1.66091
8.69377

Isso pode ser verificado multiplicando a solução x pela matriz original A usando GNU OCTAVE,

octave> A = [ 0.18, 0.60, 0.57, 0.96;
              0.41, 0.24, 0.99, 0.58; 
              0.14, 0.30, 0.97, 0.66; 
              0.51, 0.13, 0.19, 0.85 ];

octave> x = [ -4.05205; -12.6056; 1.66091; 8.69377];

octave> A * x
ans =
  1.0000
  2.0000
  3.0000
  4.0000

Isso reproduz o vetor do lado direito original, b, em conformidade com a equação A x = b.


[ << ] [ < ] [ Acima ] [ > ] [ >> ]         [Topo] [Conteúdo] [Índice] [ ? ]

14.16 Referências e Leituras Adicionais

Informação adicional sobre os algoritmos descritos nessa seção pode ser encontrada no seguinte livro,

A biblioteca LAPACK é descrita no seguinte manual,

O código fonte da LAPACK pode ser encontrado no website acima, juntamente com uma cópia online do guia de usuário.

O algoritmo modificado de Golub-Reinsch é descrito no seguinte artigo,

O algoritmo de Jacobi para decomposição de valor singular é descrito nos seguintes artigos,


[ << ] [ >> ]           [Topo] [Conteúdo] [Índice] [ ? ]

Esse documento foi gerado em 23 de Julho de 2013 usando texi2html 5.0.