Este documento apresenta três decomposições matriciais usando autovalores e autovetores: a decomposição de Cholesky para matrizes simétricas, a decomposição A=QR para qualquer matriz e a decomposição em valores singulares (SVD) para qualquer matriz. O documento descreve a teoria e implementação computacional dessas decomposições na linguagem Java.

1. Decomposic¸˜oes de matrizes utilizando conceitos de Auto
Vetores e Auto Valores
Felipe Schimith Batista1
1
Instituto de Matem´atica e Estat´ısitica - Universidade Estadual do Rio de Janeiro
felipeschimith@gmail.com
Resumo. O trabalho visa contextualizar os teoremas e m´etodos da ´Algebra
Linear aplicados em soluc¸˜oes computacionais. Este trabalho apresenta o
referencial te´orico utilizado como base para resolver computacionalmente
decomposic¸˜oes que fazem pate do estudo de Auto Vetores e Auto Valores. Apre-
sentaremos a ”Decomposic¸˜ao de Cholesky”, a ”Decomposic¸˜ao de A em QR”e
a ”Decomposic¸˜ao de Valor Singular”. A implementac¸˜ao foi feita na linguagem
de programac¸˜ao Java e tamb´em ser´a documentada e comentada.
1. Introduc¸˜ao
Na Matem´atica um sistema de equac¸˜oes lineares ´e um conjunto finito de equac¸˜oes lineares
aplicadas num mesmo conjunto, igualmente finito, de vari´aveis.[ANTON 2006]
No estudo da ´Algebra Linear nos aprofundamos na an´alise de sistemas de
equac¸˜oes lineares. Nela se utiliza alguns conceitos e estruturas fundamentais como veto-
res, matrizes, transformac¸˜oes lineares e sistemas de equac¸˜oes lineares.
Com o desenvolvimento da teoria quˆantica nas d´ecadas de 1920 e 1930, o estudo
de matrizes tornou-se de grande importˆancia. No final da d´ecada de 1940, alguns
matem´aticos se perguntavam como o computador digital poderia ser empregado para
resolver o problema de autovalores de matrizes. A determinac¸˜ao dos autovalores de uma
matriz tem merecido grande atenc¸˜ao, devido a sua grande aplicac¸˜ao aos diversos ramos
das Ciˆencias Aplicadas, como, por exemplo:[Oliveira 2006]
• a teoria das vibrac¸˜oes, quer sejam mecˆanicas ou el´etricas, dos tipos macrosc´opica
ou microsc´opica;
• as vibrac¸˜oes de pontes ou outra estrutura s´olida;
• as vibrac¸˜oes das asas de um avi˜ao;
• a oscilac¸˜ao de part´ıculas atˆomicas e moleculares nas ondas mecˆanicas;
• a teoria dos operadores lineares diferenciais e integrais, etc...
A obtenc¸˜ao dos autovalores λ de uma matriz quadrada de ordem n envolve
c´alculos complexos por serem os zeros do polinˆomio caracter´ıstico det(A −λI) = 0, que
´e um polinˆomio de grau n em λ. A busca de soluc¸˜oes para este problema acarretou o
desenvolvimento de uma s´erie de algoritmos, os mais diversos, cada vez mais poderosos
e mais eficientes. O primeiro a surgir foi o mais ´obvio, composto de apenas dois passos.
Primeiro, calcula-se os coeficientes do polinˆomio caracter´ıstico e, ent˜ao, as ra´ızes desse
polinˆomio.[Oliveira 2006]
Neste trabalho apesentaremos um referencial te´orico e uma forma computacio-
nal de implementar a ”Decomposic¸˜ao de Cholesky”, a ”Decomposic¸˜ao de A em QR”e a
”Decomposic¸˜ao de Valor Singular”.

2. 2. Teoria de Autovetores e Autovalores
Este cap´ıtulo tem como objetivo apresentar as propriedades, teoremas e m´etodos da
´Algebra Linear que foram usados como base para implementar soluc¸˜oes computacionais.
2.1. Autovetores e Autovalores
Antes de nos aprofundarmos nas decomposic¸˜oes de matrizes, ´e necess´ario entender como
obter os autovetores e autovalores de uma matriz.
Uma transformac¸˜ao especial T : V → W.
(I) T(v) = ∆v
Onde, ∆ ´e o autovalor (escalar) e v ´e autovetor. Como toda transformac¸˜ao linear
pode ser escrita pela multiplicac¸˜ao de uma matriz por um vetor ent˜ao:
(II) T(v) = Av
Igualando (I) e (II), tem-se:
Av = ∆v ou Av – ∆v = 0 que resulta no sistema homogˆeneo:
(III) (A – ∆I) v = 0
Onde A ´e n x n, v = 0 ´e sempre soluc¸˜ao (trivial).
Os vetores v = 0 para os quais existe um ∆ que resolve a equac¸˜ao (III) s˜ao chama-
dos de autovetores da matriz A e os valores de ∆, que conjuntamente com v resolvem a
equac¸˜ao s˜ao chamados de autovalores da matriz A associados aos respectivos autovetores.
Para que a equac¸˜ao (III) tenha soluc¸˜ao al´em da trivial ´e necess´ario que o determinante da
matriz dos coeficientes seja zero, ou seja,
det(A – ∆I) = 0
ou
det




α11 α12 α13
α21 α22 α23
α31 α32 α33

 − ∆


1 0 0
0 1 0
0 0 1



 = 0
o que resulta em um polinˆomio de grau n em ∆, conhecido como polinˆomio ca-
racter´ıstico. As ra´ızes do polinˆomio caracter´ıstico s˜ao os autovalores da matriz A. Para
se encontrar os autovetores basta substituir o valor do autovalor na equac¸˜ao original e
encontrar o autovetor. O autovalor ser´a, ent˜ao, associado ao autovetor encontrado. Na
verdade, o autovetor encontrado forma uma base para o espac¸o de soluc¸˜ao da equac¸˜ao
(III), dado o respectivo autovalor. Logo, qualquer m´ultiplo do autovetor tamb´em ´e um
autovetor.[Stanford 2002]
2.2. Decomposic¸˜ao de Cholesky
Se a matriz A for sim´etrica e invers´ıvel, vamos escrever esta decomposic¸˜ao na forma A =
LU de modo que
LU = A = AT
= UT
LT
.

3. Como L e U s˜ao invers´ıveis,
U(LT
)−1
= L−1
UT
= D
´e diagonal pois U(LT
)−1
´e triangular superior e L−1
UT
´e triangular inferior. As-
sim, U = DLT
e obtemos a decomposic¸˜ao A = LDLT
onde L ´e triangular inferior cujos
elementos diagonais s˜ao iguais a 1 e D = L−1
UT
´e diagonal.
Como os elementos da diagonal principal de L s˜ao iguais a 1, D = diag(U) onde
diag(U) ´e uma matriz diagonal, cujos elementos da diagonal principal s˜ao iguais aos ele-
mentos da diagonal de U.
Uma matriz sim´etrica A ´e positiva definida se os elementos diagonais de D na
decomposic¸˜ao A = LDLT
forem todos maiores do que zero. Neste caso, podemos cal-
cular a matriz
√
D e definir R = L
√
D, para assim obter a decomposic¸˜ao A = RRT
denominada de decomposic¸˜ao de Cholesky da matriz A.
2.2.1. Ordem de Complexidade
Analisando a Ordem de complexidade do programa desenvolvido para obter a
decomposic¸˜ao de Cholesky, obtemos a Ordem (n3
). Comparando com as decomposic¸˜oes
de A=QR e SVD, esse m´etodo ´e mais r´apido. A pesar de a complexidade ter sido de
mesma Ordem do A=QR e SVD, ´e poss´ıvel execut´a-lo em uma s´o operac¸˜ao, aumentando
seu desempenho.
2.3. Decomposic¸˜ao de A em QR
Toda matriz A mxn
com colunas linearmente independentes pode ser unicamente
fatorada na forma A = Q · R com as colunas da matriz Q mxn
formando uma
base ortonormal para o range(A) e a matriz triangular superior R mxn
tendo os ele-
mentos da diagonal positivos. Esta fatorac¸˜ao pode ser gerada pelo procedimento de
ortogonalizac¸˜ao de Gram-Schmidt desenvolvido no artigo anterior, pois as colunas da
matriz Q = (q1, q2, q3...qn) s˜ao resultados da aplicac¸˜ao do processo de Gram-Schmidt nas
colunas da matriz A = (a1, a2, a3...an), e a matriz R ´e dada por:






v1 qT
1 · a2 qT
1 · a3 ... qT
1 · an
0 v2 qT
2 · a3 ... qT
2 · an
0 0 v3 ... qT
3 · an
... ... ... ... ...
0 0 0 ... vn






onde v1 = a1 e vk = ak − k−1
i=1
qT
i · ak · qi para k = 2, 3, ..., n.
Se a matriz A mxn
´e regular, ent˜ao QT
= Q−1
, pois as colunas da matriz Q s˜ao
ortonormais entre si.
2.3.1. Ordem de Complexidade
Analisando a ordem de complexidade do programa desenvolvido para obter a
decomposic¸˜ao de A=QR, obtemos a Ordem (n3
). A pesar dele ser mais lento que a

4. decomposic¸˜ao de Cholesky e praticamente de mesmo desempenho que a SVD, as pro-
priedades num´ericas dessa decomposic¸˜ao torna o programa mais importante matemati-
camente, pois ele pode ser aplicado em qualquer matriz mxn, podendo facilitar outros
c´alculos torando-o mais ben´efico que a decomposic¸˜ao de Cholesky.
2.4. Decomposic¸˜ao de Valor Singular
A Decomposic¸˜ao de Valor Singular (SVD) ´e uma t´ecnica de fatorac¸˜ao de matrizes que
consiste em representar qualquer matriz Amn na forma apresentada abaixo, onde U e V T
s˜ao matrizes ortogonais, ou seja, UUT
= I e V V T
= I e ´e uma matriz diagonal que
cont´em os valores singulares σj em ordem n˜ao crescente σ1 σ2... ≥ σj ≥ 0 para 1 ≤ j ≤
min(m,n):
A = U V T
Esta func¸˜ao garante a existˆencia e unicidade da SVD para qualquer matriz Amn,
sendo que ela pode ser completa ou reduzida.
Qualquer matriz Amxn possui uma decomposic¸˜ao em valores singulares (SVD) da
forma A = U VT . Al´em disso, tem-se que os valores singulares da mesma s˜ao sempre
´unicos. Por´em, os vetores singulares `a direita e os vetores singulares `a esquerda somente
ser˜ao ´unicos se a matriz A for quadrada e possuir autovalores distintos.
2.4.1. SVD Completa
A forma completa da SVD de uma matriz Amxn (m ≥ n) ´e composta pelas matrizes or-
togonais Umxm e V T
nxn e pela matriz mxn. Se a matriz Amxn tiver posto completo (r
= n) existir´a um conjunto de n vetores ortonormais de U m
e um conjunto de n ve-
tores ortonormais de V T n
. No entanto, se n < m, o conjunto de n vetores m
n˜ao ser´a suficiente para formar uma base de m
e Umxm n˜ao ser´a uma matriz quadrada
ortogonal. Portanto, para obter a forma completa da SVD, ser´a necess´ario a adic¸˜ao de
mn colunas ortonormais em U para transform´a-la em uma matriz ortogonal (Umxm) e mn
linhas nulas em para possibilitar a multiplicac¸˜ao Umxm mxn. Por outro lado, se a
matriz Amxn possuir posto incompleto (r < n), ser´a necess´ario adicionar m−r colunas
ortonormais em U e n−r linhas ortonormais em V T
para completar as bases dos espac¸os
m
e n
respectivamente e transformar U e V em matrizes quadradas ortogonais. Al´em
disso, ser´a necess´ario adicionar m−r linhas nulas e n−r colunas nulas em para pos-
sibilitar a representac¸˜ao Amxn = Umxm mxnV T
nxn . Em outras palavras, qualquer matriz
pode ser diagonalizada ( ), desde que escolhamos um sistema de coordenadas ortogonal
apropriado para m
(colunas de U) e n
(linhas de V ). [Rodrigues 2011]
Figura 1. SVD completa de uma matriz Amxn(m ≥ n).

5. 2.4.2. SVD Reduzida
A forma reduzida da SVD de uma matriz Amxn (m ≥ n) de posto r consiste na remoc¸˜ao
das colunas e linhas extras colocadas com intuito de transformar Umxr e Vrxn em matrizes
ortogonais Umxr e Vrxn. Essa remoc¸˜ao tem por objetivo fornecer apenas a informac¸˜ao
fornecida pelo conjunto de vetores definidos pelo posto da matriz.[Rodrigues 2011]
Figura 2. SVD reduzida de uma matriz Amxn(m ≥ n).
2.4.3. Ordem de Complexidade
Analisando a ordem de complexidade do programa desenvolvido para obter a SVD, ob-
temos a Ordem (n3
). Esse programa ´e mais lento que a decomposic¸˜ao de Cholesky e
praticamente de mesmo desempenho que a A=QR. Matematicamente ela tamb´em se des-
taca pois ´e de grande aplicac¸˜ao em processamento de sinais e estat´ıstica.
3. Programas
Este cap´ıtulo apresenta os programas desenvolvidos utilizando como base os conheci-
mentos adquiridos na ´algebra linear. Algumas func¸˜oes secund´arias como obtenc¸˜ao das
matrizes a partir de arquivos textos e func¸˜ao de impress˜ao de matrizes foram omitidas dos
programas. Focarmos a apresentac¸˜ao nas partes essenciais de processamento de matrizes.
3.1. Decomposic¸˜ao de Cholesky
Esta primeira func¸˜ao consiste em decompor A em LU. Ele percorre todos os elementos
da matriz, fazendo o escalonamento da matriz U e guardando os divisores utilizado no
escalonamento em L, sendo que a diagonal ´e preenchida com 1 e os valores da diagonal
superior de L ´e preenchido por 0.
public static void TransformaTraingularLU(Double[][]
matriz, int numLin,
int numCol, Double[][] matrizL) {
/*
* Decomposi o de A em L e U
*
* L
* |1 0 0|
* |R 1 0|
* |R R 1|
*

6. * U
* |R R R|
* |0 R R|
* |0 0 R|
*
* */
for (int k = 0; k < numLin; k++) {//Ordem n
for (int i = k + 1; i < numLin; i++) {//Ordem n*n
matrizL[i][k] = (double) matriz[i][k].floatValue()
/ matriz[k][k].floatValue();
matriz[i][k] = 0.0;
for (int j = k + 1; j < numLin; j++) {//Ordem n*n*n
matriz[i][j] = (double)
matriz[i][j].floatValue()
-
(matrizL[i][k].floatValue()
* matriz[k][j]
.floatValue());
}
}
}
}
A segunda func¸˜ao consiste em decompor U em L’ D. Ele cria uma matriz D toda
de 0, e depois preenche ela com os elementos da diagonal, sendo que depois divide os
elementos das colunas da diagonal de L’ pelo valor da diagonal. Ap´os isso ele preenche a
diagonal de o L’ com 1.
public static void DecompoeUemDU(Double[][] matriz, int
numLin,
int numCol, Double[][] matrizx) {
/*
* U*matrizy = b (matrizx)
* Calcula U[m,n]/D[x,y] = L’ sendo que x=y
*
* L’
* |1 R R|
* |0 1 R|
* |0 0 1|
*
* D
* |R 0 0|
* |0 R 0|
* |0 0 R|
*
*

7. * */
for (int k = 0; k < numLin; k++) {//Ordem n
for (int i = 0; i < numCol; i++) {//Ordem n*n
matrizx[i][k] = 0.0;
}
}
for (int p = numLin - 1; p >= 0; p--) {//Ordem n
matrizx[p][p]=(double)matriz[p][p].floatValue();
for (int j = p; j < numCol; j++) {//Ordem n*n
matriz[p][j]=
(double)matriz[p][j].floatValue()
/matrizx[p][p].floatValue();
}
}
}
A terceira func¸˜ao percorre todos os elementos da diagonal de D e obt´em a raiz quadrada
deles, formando a Raiz de D.
// Retorna Raiz de D
public static void DecomposicaoD(Double[][] matriz, int
numLin, int numCol,Double[][] D) {
int N = numLin;
for (int i = 0; i < N; i++) {//Ordem n
for (int j = 0; j < N; j++) {//Ordem n*n
if (i==j){
//Aplica a raiz dos elementos da diagonal
principal
D[i][i] =
Math.sqrt(matriz[i][i].floatValue());
}else {
D[i][j] =0.0;
}
}
}
}
A quarta func¸˜ao faz a multipicac¸˜ao matricial de L * Raiz(D), obtendo R.
public static void produtoMatriz(Double[][] matriz, int
numLin, int numCol,
Double[][] matriz2, int numLin2, int numCol2,
Double[][] matrizResultado) {

8. int i, j, k;
Double soma = 0.0;
for (i = 0; i < numLin; ++i)//Ordem n
for (j = 0; j < numCol2; ++j) {//Ordem n*n
for (k = 0; k < numCol; ++k) {//Ordem n*n*n
soma += (double)
(matriz[i][k].floatValue() *
matriz2[k][j].floatValue());
}
matrizResultado[i][j] = soma;
soma = 0.0;
}
}
3.2. Decomposic¸˜ao de A=QR
Este algoritmo consiste em decompor A em Q*R, onde a k-´esima coluna da matriz A, ´e
expressa como combinac¸˜ao linear das k primeiras colunas de Q (com coeficientes R(1,k),
..., R(k,k)). As k primeiras colunas de Q formam uma base ortogonal para o subespac¸o
gerado pelas k primeiras colunas de A. Se a coluna k de A ´e uma combinac¸˜ao linear das p
primeiras colunas de A, ent˜ao, as entradas de R(p+1,k), ..., R(k,k) s˜ao zeros. Neste caso,
R ´e trapezoidal superior. Se A tem posto rk, as linhas R(rk+1,:), R(rk+2,:), ... s˜ao zeros.
//Decomposicao QR
public A_QR (Matrix A) {
// Inicializa.
QR = A.getArrayCopy();
m = A.getRowDimension();
n = A.getColumnDimension();
Rdiag = new double[n];
// Loop Principal.
for (int k = 0; k < n; k++) {//Ordem n
// Computa a segunda normal do k esima coluna sem
sobrecarga.
double nrm = 0;
for (int i = k; i < m; i++) {//Ordem n*n
//Utilizei o a biblioteca Jama.util.Maths para
obter a Normal.
nrm = Maths.hypot(nrm,QR[i][k]);
}
//Caso a normal for diferente de zero
if (nrm != 0.0) {
// Para o k esimo vetor.
if (QR[k][k] < 0) {

9. nrm = -nrm;
}
for (int i = k; i < m; i++) {//Ordem n*n
QR[i][k] /= nrm;
}
QR[k][k] += 1.0;
// Aplica a transforma o nas colunas restantes.
for (int j = k+1; j < n; j++) {//Ordem n*n
double s = 0.0;
for (int i = k; i < m; i++) {//Ordem n*n*n
s += QR[i][k]*QR[i][j];
}
s = -s/QR[k][k];
for (int i = k; i < m; i++) {//Ordem n*n*n
QR[i][j] += s*QR[i][k];
}
}
}
//Gurada o valor do elemento da diagoal
Rdiag[k] = -nrm;
}
}
O programa abaixo monta matriz triangular superior R de mesma dimens˜ao que
A. O primeiro For percorre as linhas ”i”e o segundo For percorre as colunas ”j”. Dentro
do Segundo For, existem trˆes opc¸˜oes de entrada, caso ”i¡j”ent˜ao obt´em o valor calculado
de QR, caso ”i=j”obt´em o valor da Diagonal e caso o valor de ”i¿j”zera os elementos
abaixo da diagonal.
public Matrix getR () {
Matrix X = new Matrix(n,n);
double[][] R = X.getArray();
for (int i = 0; i < n; i++) {//Ordem n
for (int j = 0; j < n; j++) { //Ordem n*n
if (i < j) {
R[i][j] = QR[i][j];
} else if (i == j) {
R[i][j] = Rdiag[i];
} else {
R[i][j] = 0.0;
}
}
}
return X;
}

10. O programa produz computacionalmente uma matriz ortogonal Q que ´e obtido
com a permutac¸˜ao (de colunas) E, uma matriz triangular superior R com elementos na
diagonal decrescentes e uma matriz ortogonal (ou unit´aria) Q tais que A*E = Q*R. Se rk
´e o posto de A, as rk primeiras entradas ao longo da diagonal de R. R(1,1), R(2,2), ...,
R(rk,rk) s˜ao todas diferentes de zero. Isso produz uma ”economia de tamanho”: Se A
i´e m-por-n com m ¿ n, ent˜ao, apenas as n primeiras colunas de Q s˜ao computadas tanto
quanto as n priemiras linhas de R.
Como disse anteriormente o primeiro For percorre inversamente as colunas de
”n-1”at´e ”0”, o segundo for ´e para zerar os elementos de Q que ser˜ao computados poste-
riormente. O Terceiro For faz o somat´orio das multiplicac¸˜oes de ”QR*Q”que ´e guardado
na var´avel s e depois adicionado ao valor de ”Q[i][j].
public Matrix getQ () {
Matrix X = new Matrix(m,n);
double[][] Q = X.getArray();
for (int k = n-1; k >= 0; k--) {//Ordem n
for (int i = 0; i < m; i++) {//Ordem n*n
Q[i][k] = 0.0;
}
Q[k][k] = 1.0;
for (int j = k; j < n; j++) {//Ordem n*n
if (QR[k][k] != 0) {
double s = 0.0;
for (int i = k; i < m; i++) {//Ordem n*n*n
s += QR[i][k]*Q[i][j];
}
s = -s/QR[k][k];
for (int i = k; i < m; i++) {//Ordem n*n*n
Q[i][j] += s*QR[i][k];
}
}
}
}
return X;
}
3.3. Decomposic¸˜ao SVD
Este algoritmo consiste em decompor A em USV T
, onde Umm e V T
nn s˜ao matrizes orto-
gonais, ou seja, UUT
= Im e V V T
= In e mn ´e uma matriz diagonal que cont´em os
valores singulares σj em ordem n˜ao crescente σ1 σ2... ≥ σj ≥ 0 para 1 ≤ j ≤ min(m,n)
public DecomposicaoValorSingular(Matrix Arg) {
// Inicializa.
double[][] A = Arg.getArrayCopy();
m = Arg.getRowDimension();
n = Arg.getColumnDimension();

11. int nu = Math.min(m, n);
s = new double[Math.min(m + 1, n)];
U = new double[m][nu];
V = new double[n][n];
double[] e = new double[n];
double[] trabalha = new double[m];
boolean wantu = true;
boolean wantv = true;
// Reduz A em uma forma bidiagonal, armazendando os
elementos da
// diagonal em s e os elementos da diagonal superior em e.
int nct = Math.min(m - 1, n);
int nrt = Math.max(0, Math.min(n - 2, m));
for (int k = 0; k < Math.max(nct, nrt); k++) {//Ordem n
if (k < nct) {
// Computa a transformacao para a k-esima
coluna
// e coloca a k-esima diagonal em s[k].
// Computa 2-normal da k-esima coluna sem
overflow.
s[k] = 0;
for (int i = k; i < m; i++) {//Ordem n*n
s[k] = hypot(s[k], A[i][k]);
}
if (s[k] != 0.0) {
if (A[k][k] < 0.0) {
s[k] = -s[k];
}
for (int i = k; i < m; i++) {
A[i][k] /= s[k];
}
A[k][k] += 1.0;
}
s[k] = -s[k];
}
for (int j = k + 1; j < n; j++) {//Ordem n*n
if ((k < nct) & (s[k] != 0.0)) {
// Aplica a transformacao
double t = 0;
for (int i = k; i < m; i++)
{//Ordem n*n*n

12. t += A[i][k] * A[i][j];
}
t = -t / A[k][k];
for (int i = k; i < m; i++)
{//Ordem n*n*n
A[i][j] += t * A[i][k];
}
}
// Coloca a k-esima lina de A em e para o
subsequente
// calculo da trasnformacao da linha.
e[j] = A[k][j];
}
if (wantu & (k < nct)) {
// Coloca a transformacao em U para a
subsequente multiplicacao
// retroativa.
for (int i = k; i < m; i++) {
U[i][k] = A[i][k];
}
}
if (k < nrt) {
// Calcula a k-esima transforma o da
linha e coloca a
//k-esima diagonal superior em e[k].
// Calcula segunda normal sem overflow.
e[k] = 0;
for (int i = k + 1; i < n; i++) {//Ordem
n*n
e[k] = hypot(e[k], e[i]);
}
if (e[k] != 0.0) {
if (e[k + 1] < 0.0) {
e[k] = -e[k];
}
for (int i = k + 1; i < n; i++) {
e[i] /= e[k];
}
e[k + 1] += 1.0;
}
e[k] = -e[k];
if ((k + 1 < m) & (e[k] != 0.0)) {

13. // Aplica a transformacao.
for (int i = k + 1; i < m; i++)
{//Ordem n*n
trabalha[i] = 0.0;
}
for (int j = k + 1; j < n; j++)
{//Ordem n*n
for (int i = k + 1; i < m;
i++) {
trabalha[i] +=
e[j] * A[i][j];
}
}
for (int j = k + 1; j < n; j++)
{//Ordem n*n
double t = -e[j] / e[k +
1];
for (int i = k + 1; i < m;
i++) {
A[i][j] += t *
trabalha[i];
}
}
}
if (wantv) {
// Coloca a transformacao em V
para subsequente
//multiplicacao retroativa.
for (int i = k + 1; i < n; i++)
{//Ordem n*n
V[i][k] = e[i];
}
}
}
}
4. Conclus˜ao
Podemos concluir que utilizando os conceitos de Autovetores e Autovalores podemos
manipular e decompor de maneiras diferentes as matrizes, o que possibilita obter ganho de
processamento em c´alculos mais complexos. Devemos lembrar que essas decomposic¸˜oes
s˜ao poss´ıveis em casos espec´ıficos onde as matrizes a serem trabalhadas apresentem as
propriedades como simetria e ou tamb´em sim´etrica definida positiva.
Com esse trabalho serviu para complementar o aprendizado da ´algebra linear

14. computacional no curso de Mestrado em ciˆencias computacionais, esperamos que esses
programas sejam reutilizados e que inspirem a elaborac¸˜ao de teses, n˜ao apenas no escopo
da ´algebra linear, mas tamb´em em outras situac¸˜oes onde seja poss´ıvel aplicar conceitos
matem´aticos na soluc¸˜ao de problemas reais.
Referˆencias
ANTON, H. & BUSBY, R. (2006). Algebra Linear Contemporˆanea. BOOKMAN COM-
PANHIA EDITORA, 1th edition.
Oliveira, D. E. d. (2006). Sobre um m´etodo aseemelhado ao de francis para a
determinac¸˜ao de autocalores de matrizes.
Rodrigues, C. F. (2011). An´alise comparativa entre os m´etodos de composicac¸˜o em va-
lores singulares e an´alise de componentes principais envolvendo matrizes esparsas de
grande porte.
Stanford, A. (2002). Elemento de economia matem´atica i - conceitos fundamentais da
´Algebra linear.