Métodos de decomposição de matrizes e algumas

de suas aplicações à estatı́stica

bob
2019

1 Resumo
A ideia para a elaboração deste documento é de preparar um material objetivo
e de fácil entendimento para o auxilio na aprendizagem de diciplinas em um curso
de Estatı́stica.

A apresentação de cada método de decomposição de matrizes será dada por uma

breve explicação de como a decomposição em questão funciona teoricamente e sob
quais condições. Posteriormente será mostrado como realizá-la na linguagem R e
alguns exemplos.

2 Introdução
3 Aspectos teóricos
3.1 QR Decomposition
Este método consiste em transformar uma matriz A em um produto de matri-
zes, sendo uma matriz ortogonal Q, em que QT Q = I, e uma matriz triangular
superior R.

A = QR

Esta decomposição existe no geral tanto para matrizes retangulares quanto para
matrizes quadradas (Numerical Recipes, pag.103). A decomposição QR pode ser
feita de diversas formas, como pelo processo de Gram-Schmidt que é o qual aqui

1
será apresentado o algorı́timo, e outra forma conhecida seria utilizando trans-
formações por Householder, visto que Gram-Schmidt pode gerar matrizes Q não
ortogonais, Householder é uma alternativa para contornar este problema gerando
uma maior estabilidade numérica.
Algoritmo 1: QR Decomposition utilizando Gram-Schmidt( Schlegel.A )

gramschmidt <- function ( x ) {

x <- as . matrix ( x )

# Pegar o numero de linhas

# e de colunas da matriz de entrada
m <- nrow ( x )
n <- ncol ( x )

# Matrizes Q e R
q <- matrix ( 0 , m , n )
r <- matrix ( 0 , n , n )

for ( j in 1 : n ) {
# Primeiro passo do processo
# de Gram-Schmidt v1 = a1
v = x[,j]

# Pule a primeira coluna

if ( j > 1 ) {
for ( i in 1 :( j - 1 )) {
# Encontre o produto interno
# (Gera a transposta de q)
r [i , j ] <- t ( q [ , i ]) %*% x [ , j ]

# Subtrai a projeç~
ao de v que faz com que v
# seja perpendicular a todas as colunas de Q
v <- v - r [i , j ] * q [ , i ]
}
}
# Encontre a norma L2 da j-ésima diagonal de R
r [j , j ] <- sqrt ( sum ( v ^ 2 ))

# O resultado ortogonalizado e
# guardado na i-ésima coluna de Q.
q [ , j ] <- v / r [j , j ]
}

2
 # Coleta as matrizes Q e R em uma lista e as retorna
qrcomp <- list ( ’Q ’=q , ’R ’= r )
return ( qrcomp )
}

3.2 Singular Value Decomposition (SVD)

Tem por objetivo a decomposição em valores singulares uma matriz A do
tipo M x N, seja real ou complexa:

A = U ΣV ∗

Onde U é uma matriz M x M unitária em que suas colunas são chamadas de

vetores singulares esquerdos de A, V é uma matriz N x N unitária em que
suas colunas são chamadas de vetores singulares direitos de A, e Σ é uma
matriz diagonal M x N com entradas positivas em sua diagonal chamados de
valores singulares de A (Numerical Linear Algebra, pag.28).
Algoritmo 2: Singular Value Decomposition( Gupta.S )

svd <- function (x , nu = min (n , p ) ,

nv = min (n , p ) , LINPACK = FALSE )
{
x <- as . matrix ( x )
if ( any (! is . finite ( x )))
stop ( " Valores infinitos ou ausentes em ’x ’ " )
dx <- dim ( x )
n <- dx [ 1 L ]
p <- dx [ 2 L ]
if (! n || ! p ) stop ( " uma dimens á o é zero " )
La . res <- La . svd (x , nu , nv )
res <- list ( d = La . res $ d )
if ( nu ) res $ u <- La . res $ u
if ( nv ) {
if ( is . complex ( x ))
res $ v <- Conj ( t ( La . res $ vt ))
else
res $ v <- t ( La . res $ vt )
}

3
 res
}

3.3 Spectral Decomposition

Algoritmo 3: Spectral Decomposition( Gupta.S )

eigen <- function (x , symmetric , only . values = FALSE ,

EISPACK = FALSE )
{
x <- unname ( as . matrix ( x ))
n <- nrow ( x )
if (! n ) stop ( " Matriz 0 x 0 " )
if ( n != ncol ( x ))
stop ( " Matriz n á o quadrada em ’ eigen ’ " )
n <- as . integer ( n )
if ( is . na ( n ))
stop ( " nrow ( x ) inv á lido " )

complex . x <- is . complex ( x )

if (! all ( is . finite ( x )))
stop ( " Valores infinitos ou ausentes em ’x ’ " )

if ( missing ( symmetric ))
symmetric <- isSymmetric . matrix ( x )

if ( symmetric ) {
z <- if (! complex . x ) . Internal ( La _ rs (x , only . values ))
else . Internal ( La _ rs _ cmplx (x , only . values ))
ord <- rev ( seq _ along ( z $ values ))
} else {
z <- if (! complex . x ) . Internal ( La _ rg (x , only . values ))
else . Internal ( La _ rg _ cmplx (x , only . values ))
ord <- sort . list ( Mod ( z $ values ) , decreasing = TRUE )
}
return ( list ( values = z $ values [ ord ] ,
vectors = if (! only . values )
z $ vectors [ , ord , drop = FALSE ]))
}

4
3.4 LU Decomposition
A ideia é transformar uma matriz A em uma matriz triangular superior
U com M x M dimensões, introduzindo zeros abaixo da diagonal, primeiro
na primeira coluna, e depois na segunda, e assim por diante. Isso é feito
subtraindo multiplos de cada coluna das colunas subsequentes. Esse processo
de eliminação é equivalente a multiplicar A por uma sequencia de matrizes
triagulares inferiores:

Lm−1 ...L2 L1 A = U.
| {z }
L−1 (1)
A = LU.

(Numerical Linear Algebra, pag.147).

Algoritmo 4: LU Decomposition (Frederick Novomestky - matrixcalc)
#requer o package matrixcalc
library ( ’ matrixcalc ’)
lu . decomposition <- function ( x )
{
# argumentos
# x = uma matriz quadrada numérica
#
if ( ! is . square . matrix ( x ) )
stop ( " o argumento x n á o é uma matriz quadrada . "
)
if ( ! is . numeric ( x ) )
stop ( " o argumento x n á o é numerico " )
#n numero de linhas e colunas de x
n <- nrow ( x )
# L recebe uma matriz nula n x n
L <- matrix ( 0 , nrow =n , ncol = n )
# U recebe uma matriz nula n x n
U <- matrix ( 0 , nrow =n , ncol = n )
diag ( L ) <- rep ( 1 , n )
for ( i in 1 : n ) {
ip 1 <- i + 1
im 1 <- i - 1
for ( j in 1 : n ) {
U [i , j ] <- x [i , j ]

5
 if ( im 1 > 0 ) {
for ( k in 1 : im 1 ) {
U [i , j ] <- U [i , j ] - L [i , k ] * U [k , j ]
}
}
}
if ( ip 1 <= n ) {
for ( j in ip 1 : n ) {
L [j , i ] <- x [j , i ]
if ( im 1 > 0 ) {
for ( k in 1 : im 1 ) {
L [j , i ] <- L [j , i ] - L [j , k ] * U [k ,
i]
}
}
if ( U [i , i ] == 0 )
stop ( " o argumento x é uma matriz
singular " )
L [j , i ] <- L [j , i ] / U [i , i ]
}
}
}
result <- list ( L =L , U = U )
return ( result )
}

3.5 Cholesky Decomposition

O objeitivo é decompor uma matriz A simétrica e definida positiva (ou seja,
se xT Ax > 0, ∀x 6= 0) da seguinte forma:

A = TTT (2)

onde T é uma matriz triangular superior com elementos positivos na diago-

nal.
Algoritmo 5: Cholesky Decomposition (Suraj Gupta)
chol . default <- function (x , pivot = FALSE , LINPACK =
FALSE , tol = -1 , ...)
{

6
 if ( is . complex ( x ) )
stop ( " complex matrices not permitted at present "
)

. Internal ( La _ chol ( as . matrix ( x ) , pivot , tol ) )

}

3.6 Schur Decomposition

•

4 Aplicação
4.1 QR Decomposition
•

4.2 Singular Value Decomposition (SVD)

•

4.3 Spectral Decomposition

•

4.4 LU Decomposition
•

4.5 Cholesky Decomposition

•

4.6 Schur Decomposition

•

7
5 Discussão
6 Conclusões
7 Referências
Gentle, J. E.Matrix Algebra Theory, Computations, and Applications in Statistics.

Golub, G. H; Van Loan, C. F. Matrix Computations.

Press, W. H. et.al. Numerical Recipes: The Art of Scientific Computing 3rd ed.
Schlegel, A. Cholesky Decomposition. Disponı́vel em: <https://rpubs.com/aaronsc32/
cholesky-decomposition>. Acesso em: 19/09/2019.
Schlegel, A. Eigenvalues and Eigenvectors. Disponı́vel em: <https://rpubs.com/
aaronsc32/eigenvalues-eigenvectors-r>. Acesso em: 19/09/2019.
Schlegel, A. QR Decomposition with the Gram-Schmidt Procedure. Disponı́vel em:
<https://rpubs.com/aaronsc32/qr-decomposition-gram-schmidt>. Acesso em:
11/10/2019.
Schlegel, A. Singular Value Decomposition. Disponı́vel em: <https://rpubs.com/
aaronsc32/singular-value-decomposition-r>. Acesso em: 19/09/2019.
Schur Decomposition Of A Matrix. Disponı́vel em: <https://www.rdocumentation.
org/packages/Matrix/versions/0.95-1/topics/Schur>. Acesso em: 19/09/2019.

Serre, D. Matrices: Theory and Applications.

Spectral Decomposition of a Matrix. Disponı́vel em: <https://www.math.ucla.
edu/~anderson/rw1001/library/base/html/eigen.html>. Acesso em: 22/09/2019.

Gupta, S. svd.R. Disponı́vel em: <https://github.com/SurajGupta/r-source/

blob/master/src/library/base/R/svd.R>. Acesso em: 14/11/2019.
Gupta, S. svd.R. Disponı́vel em: <https://github.com/SurajGupta/r-source/
blob/master/src/library/base/R/eigen.R>. Acesso em: 14/11/2019.
Trefethen, L. N.; Bau, D. Numerical Linear Algebra.
Novomestky, F. LU.R. Disponı́vel em: <https://github.com/cran/matrixcalc/

8
blob/master/R/lu.decomposition.R>. Acesso em: 15/11/2019.