SlideShare uma empresa Scribd logo
1 de 18
Baixar para ler offline
´Algebra Linear - Operac¸˜oes com Matrizes
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 Li-
near aplicados em soluc¸˜oes computacionais. Este trabalho apresenta o refe-
rencial te´orico utilizado como base para resolver computacionalmente sistemas
lineares. Apresentaremos a ”Decomposic¸˜ao A=LU”fazendo uma comparac¸˜ao
com a decomposic¸˜ao de Gauss, a ”Decomposic¸˜ao A=LDU”comparando-a com
o m´etodo de Crout. Por fim apresentamos o ”M´etodo de Gauss-Jordan”que
obt´em a inversa de uma matriz. 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 a teoria de sistemas lineares ´e a base e uma parte fundamental da ´algebra
linear, um tema que ´e usado na maior parte da matem´atica moderna. Deve-se observar
que, em primeiro lugar, a equac¸˜ao linear ´e, necessariamente, uma equac¸˜ao polinomial.
Tamb´em na matem´atica aplicada, podemos encontrar v´arios usos de sistemas lineares.
Exemplos s˜ao a f´ısica, a economia, a engenharia, a biologia, a geografia, a navegac¸˜ao,
a aviac¸˜ao, a cartografia, a demografia e a astronomia.[RUGGIERO 1996] 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]
Algoritmos computacionais s˜ao, por encontrar as soluc¸˜oes, uma parte importante
da ´algebra linear num´erica. Voltando na hist´oria da ´algebra linear, uma vers˜ao preliminar
da eliminac¸˜ao gaussiana apareceu pela primeira vez no livro chinˆes “Nove Cap´ıtulos de
Arte Matem´atica”, em torno de 200 a.C.
O poder do m´etodo n˜ao tinha sido reconhecido at´e que o grande matem´atico Carl
Friedich Gauss no ano de 1801 utilizou o m´etodo para calcular a ´orbita do asteroide Ceres
com pouqu´ıssimas informac¸˜oes utilizando m´ınimos quadrados e o procedimento que hoje
denominamos eliminac¸˜ao gaussiana. O trabalho de Gauss causou sensac¸˜ao quando Ceres
reapareceu na constelac¸˜ao de Virgem, local aproximado aos seus c´alculos.[ANTON 2006]
Mais tarde o m´etodo foi popularizado quando Willian Jordan (engenheiro alem˜ao)
em 1888 publicou no seu livro de geod´esia intitulado “Handbuch der Vermessungskunde”.
Embora as ideias tenham sido conhecidas antes, muitas vezes o cr´edito pela
popularizac¸˜ao da decomposic¸˜ao LU ´e atribu´ıda ao l´ogico e matem´atico britˆanico Alan
Turing, pelo seu trabalho de 1948 nesse assunto.
Ao final dos anos 1970, a Fundac¸˜ao Nacional de Ciˆencias e o Departamento de
Energia dos EUA financiaram o desenvolvimento de rotinas de computacionais para in-
verter matrizes e resolver sistemas de equac¸˜oes lineares. Aquela pesquisa levou a um
conjunto de programas Fortran chamado LINPAC que s˜ao uma referˆencia para muitos
algoritmos computacionais de hoje, inclusive no MATLAB. As rotinas LIMPAC est˜ao
organizadas em torno de quatro fatorac¸˜oes de matrizes, uma das quais ´e a decomposic¸˜ao
LU. C.B. Moler, J.J. Dongarra, G.W. Stewart e J.R. Brunch, os principais programadores
do LINPAC, basearam muitas de suas id´eias no trabalho de Jemes Boyle e Kenneth Dritz,
do Laborat´orio Argonne (nos EUA).[ANTON 2006]
2. Teoria de Matrizes
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
para resolver equac¸˜oes lineares utilizando matrizes.
2.1. Resoluc¸˜ao de Sistemas Lineares
Antes de nos aprofundarmos nas operac¸˜oes com matrizes, ´e necess´ario entender os con-
ceitos e m´etodos das operac¸˜oes elementares de um sistema linear que podemos imple-
mentar para encontrar as soluc¸˜oes computacionalmente. Por exemplo, um m´etodo para
resolver um sistema linear ´e substituir o sistema inicial por outro que tenha o mesmo con-
junto soluc¸˜ao do primeiro, mas que seja muito mais f´acil de resolver. O novo sistema ´e
obtido ap´os a aplicac¸˜ao de uma s´erie de operac¸˜oes que simplificam as equac¸˜oes do sistema
que tˆem a propriedade especial de n˜ao alterar o conjunto soluc¸˜ao.
Estas operac¸˜oes s˜ao chamadas operac¸˜oes elementares e s˜ao de trˆes tipos diferentes.
• Trocar duas equac¸˜oes do sistema de posic¸˜ao.
• Substituir uma equac¸˜ao pela mesma equac¸˜ao multiplicada por um escalar diferente
de 0.
• Substituir uma equac¸˜ao pela mesma equac¸˜ao somada a outra equac¸˜ao multiplicada
por um escalar.
Note que se multiplicarmos uma equac¸˜ao por 0, estaremos excluindo esta equac¸˜ao
do sistema, o que tem o efeito prov´avel de aumentar o conjunto soluc¸˜ao, por isso,
esta n˜ao ´e uma operac¸˜ao elementar. ´E f´acil ver que ao efetuarmos qualquer uma das
operac¸˜oes acima sobre as equac¸˜oes do sistema, n˜ao estaremos acrescentando nem dimi-
nuindo soluc¸˜oes.
Somente os coeficientes do sistema s˜ao alterados atrav´es das operac¸˜oes elemen-
tares, as vari´aveis permanecem inalteradas. Portanto, na hora de efetuar os c´alculos, ao
inv´es de considerar todo o sistema, podemos considerar apenas a matriz de coeficientes
do sistema, chamada matriz aumentada:
[A|B] =
α11 α12 ... α1n β1
α21 α22 ... α2n β2
α31 α32 ... α3n β3
... ... ... ...
αm1 αm2 ... αmn βm
As operac¸˜oes elementares ser˜ao efetuadas sobre as linhas desta matriz.
Definic¸˜ao. Operac¸˜oes Elementares sobre as linhas de uma matriz:
• a troca da posic¸˜ao relativa de duas linhas
Li ← Lj
• a multiplicac¸˜ao de uma linha por uma constante
Li ← cLj ⇔ c = 0
• a substituic¸˜ao de uma linha pela sua soma com outra linha qualquer
Li ← Li + Lj
Teorema. Se dois sistemas lineares Ax = B e Cx = D s˜ao tais que a matriz aumentada
[C|D] ´e obtida de [A|B] aplicando-se operac¸˜oes elementares, ent˜ao os dois sistemas pos-
suem as mesmas soluc¸˜oes. Sistemas que possuem as mesmas soluc¸˜oes s˜ao chamados
sistemas equivalentes.
2.2. Decomposic¸˜ao A=LU
A decomposic¸˜ao LU de uma matriz A surge da necessidade de resolver um conjunto de
sistemas do tipo Ax = b1, Ax = b2, Ax = b3 e assim por diante. Poder´ıamos resolver cada
um desses sistemas escalonando a matriz completa [A b] correspondente at´e sua forma
escalonada reduzida mas, computacionalmente, o escalonamento ´e um processo muito
demorado e poder´ıamos ter centenas de b’s para resolver.
Supondo-se que A seja uma matriz mxm que pode ser escalonada at´e sua forma
reduzida sem trocar linhas, a ´Algebra Linear nos diz que ela pode ser escrita na forma A
= LU, onde L Lower ´e uma matriz triangular inferior mxm cuja diagonal principal possui
apenas 1’s e U Upper ´e uma matriz triangular superior mxm que nada mais ´e do que a
pr´opria forma escalonada reduzida de A.
Para uma matriz 3x3: A = L*U


a11 a12 a13
a21 a22 a23
a31 a32 a33

 =


1 0 0
l21 1 0
l31 l32 1

 ∗


u11 u12 u13
0 u22 u23
0 0 u33


A importˆancia de escrevermos uma matriz como o produto de duas outras matrizes
triangulares, uma inferior e a outra superior, se d´a pelo fato de que, ao assumirmos que
A = LU, podemos reescrever a equac¸˜ao Ax = b como LUx = B ou, pela propriedade
associativa, L(Ux) = B. Tomando-se Ux = y, temos Ly = b e Ux = y. Resolvendo-se
a primeira equac¸˜ao para y e a segunda para x, obteremos a resposta procurada de uma
maneira bem mais simples do que fazer pelo m´etodo tradicional, visto que as matrizes
s˜ao triangulares.
Vale lembrar que quando um pivˆo nulo ´e encontrado temos um caso onde pode ou
n˜ao existir uma decomposic¸˜ao LU.
2.2.1. Comparando eliminac¸˜ao gaussiana com decomposic¸˜ao LU
Para determinac¸˜ao das inc´ognitas, o m´etodo da eliminac¸˜ao de Gauss desenvolve duas fa-
ses: a primeira ´e a eliminac¸˜ao progressiva, onde reduz o n´umero de vari´aveis ao longo
da execuc¸˜ao para, ent˜ao, aplicar a segunda fase, chamada de substituic¸˜ao regressiva, onde
utiliza o resultado da primeira para determinar a soluc¸˜ao geral do sistema. Dois passos
descritos, o primeiro ´e o que consome mais tempo de c´alculo, uma vez que ´e nesta fase
que consiste o maior n´umero de operac¸˜oes aritm´eticas e de trocas dedados.
Por isso, encontrar um m´etodo que minimize esta fase cr´ıtica implica em aumentar o
desempenho para realizar a tarefa de resoluc¸˜ao de sistemas lineares. Os m´etodos de
decomposic¸˜ao LU consistem em separar a fase de eliminac¸˜ao da matriz dos coeficien-
tes, que consomem maior tempo, das manipulac¸˜oes envolvidas com o vetor dos termos
independentes.
Portanto, devemos deixar claro que, ao contr´ario da eliminac¸˜ao de Gauss, uma
decomposic¸˜ao de LU ´e uma estrat´egia de melhoria na resoluc¸˜ao de sistemas lineares.
Sendo assim, n˜ao existe “o m´etodo” de decomposic¸˜ao LU, mas sim algumas abordagens
a serem tomadas que permitem decompor o sistema. Uma implicac¸˜ao interessante disso
´e que a pr´opria eliminac¸˜ao de Gauss pode ser descrita como uma decomposic¸˜ao LU.
O custo de processamento do algoritmo de decomposic¸˜ao LU pode ser visto pelo
n´umero de estruturas de repetic¸˜ao utilizados no c´odigo. No c´odigo implementado, o custo
´e da Ordem(n3
) para a decomposic¸˜ao LU.
/*
* Decomposi o de A em L e U
* */
for (int k = 0; k < numLin; k++) { //n
for (int i = k + 1; i < numLin; i++) { //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++)
{//n*n*n
matriz[i][j] = (double)
matriz[i][j].floatValue()-
(matrizL[i][k].floatValue() *
matriz[k][j].floatValue());
}
}
}
}
Da mesma forma podemos calcular o custo de processamento do algoritmo de
eliminac¸˜ao Gaussiana pode ser visto pelo n´umero de estruturas de repetic¸˜ao utilizados no
c´odigo. No c´odigo implementado no trabalho anterior, o custo ´e da Ordem(n3
).
/**
* A primeira funcao obtem a triangular superior da matriz
composta.
*/
public static void TriangularSuperior(Double[][] matriz,
int numLin, int numCol, Double[][] matriz2, int
numLin2, int numCol2,Double[][] matrizx) {
double calculo;
for (int coluna = 0; coluna < numLin2; coluna++) {n
for (int linha = coluna + 1; linha < numLin2;
linha++) {n*n
calculo =
(matriz[linha][coluna].floatValue() /
matriz[coluna][coluna].floatValue());
matriz[linha][coluna]=0.0;
for(int s=coluna+1; s <numLin2;
s++){n*n*n
matriz[linha][s]=
matriz[linha][s].floatValue() -
(calculo*matriz[coluna][s].floatValue());
}
matriz2[linha][0]=
(double)matriz2[linha][0].floatValue()
-
(matriz2[coluna][0].floatValue()*calculo);
}
}
}
Podemos concluir que o custo do processamento da decomposic¸˜ao LU ´e idˆentico
ao custo da Eliminac¸˜ao Gaussiana.
2.3. Decomposic¸˜ao A=LDU
A Decomposic¸˜ao A=LDU tamb´em ´e utilizada para soluc¸˜ao de sistemas lineares, que con-
siste em efetuar a decomposic¸˜ao da matriz A em trˆes componentes L Lower, D Diagonal
e U Upper a soma dos elementos correspondentes.
A decomposic¸˜ao A = LDU permite resolver um sistema Ax = b em trˆes passos:
• achar c de Lc = b
• achar z de Dz = c
• achar x de Ux = z
A decomposic¸˜ao LDU ´e ´unica e permite flexibilidade para o c´alculo pr´atico das
matrizes L e U. Por exemplo, isto acontece com a reduc¸˜ao de Crout, na qual considera-se
LD como sendo uma matriz triangular inferior L (sem elementos unit´arios na sua diago-
nal) de modo que A = LU com U triangular superior e elementos unit´arios na sua diagonal.
Esta reduc¸˜ao permite calcular alternadamente as colunas de L e de U.
O processo consiste em obter primeiramente a fatorac¸˜ao LU, e depois decom-
pondo a matriz U no produto de uma matriz D, com uma matriz que tamb´em se designa
por U, onde:
• D ´e uma matriz m x m diagonal cujos elementos da diagonal principal s˜ao os pivos
da eliminac¸˜ao de Gauss ou zero no caso de n˜ao haver pivˆo;
• U ´e uma matriz m x m obtida apos eliminac¸˜ao de Gauss, dividindo cada linha pelo
respectivo pivo.
Para uma matriz 3x3: A=LDU


a11 a12 a13
a21 a22 a23
a31 a32 a33

 =


1 0 0
l21 1 0
l31 l32 1

 ∗


d11 0 0
0 d22 0
0 0 d33

 ∗


1 u12 u13
0 1 u23
0 0 1


Quando um pivˆo nulo ´e encontrado temos um caso onde pode ou n˜ao existir uma
decomposic¸˜ao LU. A decomposic¸˜ao LU n˜ao ´e ´unica, j´a a decomposic¸˜ao LDU por sua vez
´e ´unica.
2.3.1. Comparac¸˜ao da decomposic¸˜ao LDU e Crout
Para compararmos LDU com Crout primeiro precisamos de fazer uma pequena
apresentac¸˜ao de Crout que ´e uma variante da fatorac¸˜ao triangular da matriz A. Toma-se a
matriz U como triangular de diagonal unit´aria e L como triangular inferior.


a11 a12 a13
a21 a22 a23
a31 a32 a33

 =


l11 0 0
l21 l22 0
l31 l32 l33

 ∗


1 u12 u13
0 1 u23
0 0 1


Como falado anteriormente a decomposic¸˜ao LDU consiste numa pequena alterac¸˜ao da
fatorac¸˜ao de Crout e tem a vantagem de atribuir `as matrizes triangulares L e U um papel
totalmente idˆentico. Consiste em considerar que estas s˜ao ambas matrizes triangulares
com diagonal unit´aria e tomar a fatorac¸˜ao na seguinte forma A = LDU em que D ´e uma
matriz diagonal.
O custo de processamento do algoritmo de decomposic¸˜ao LDU pode ser visto pelo
n´umero de estruturas de repetic¸˜ao utilizados no c´odigo. No c´odigo implementado, o custo
´e da Ordem (n3
) para a decomposic¸˜ao de A em LU e n2
para decomposic¸˜ao de U em DU’.
Resumindo podemos concluir que a decomposic¸˜ao LDU tem o custo ´e da Ordem(n3
).
public static void TransformaTraingularLU(Double[][]
matriz, int numLin,
int numCol, Double[][] matrizL) {
/*
* Decomposi o de A em L e U
* */
for (int k = 0; k < numLin; k++) { //n
for (int i = k + 1; i < numLin; i++) { //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++)
{//n*n*n
matriz[i][j] = (double)
matriz[i][j].floatValue()-
(matrizL[i][k].floatValue() *
matriz[k][j].floatValue());
}
}
}
}
public static void DecompoeUemDU(Double[][] matriz, int
numLin, int numCol, Double[][] matrizx) {
/*
* U*matrizy = b (matrizx)
* Calcula U[m,n]/D[x,y] = U’ sendo que x=y
* */
for (int k = 0; k < numLin; k++) {//n
for (int i = 0; i < numCol; i++) {//n*n
matrizx[i][k] = 0.0;
}
}
for (int p = numLin - 1; p >= 0; p--) {//n
matrizx[p][p]=(double)matriz[p][p].floatValue();
for (int j = p; j < numCol; j++) {//n*n
matriz[p][j]=(double)matriz[p][j].floatValue()
/matrizx[p][p].floatValue();
}
}
}
O custo de processamento do algoritmo de Crout tamb´em pode ser visto pelo
n´umero de estruturas de repetic¸˜ao utilizados no c´odigo. No c´odigo implementado, o custo
´e n3
para a decomposic¸˜ao de A em LU e n2
para decomposic¸˜ao de L em DL’.
public static void TransformaTraingularLU(Double[][]
matriz, int numLin,
int numCol, Double[][] matrizL,Double[][] matrizU)
{
/*
* Decomposi o de A em L e U
* */
int i, j, k;
double sum = 0;
for (int linha = 0; linha < numLin; linha++) {//n
for (int coluna = 0; coluna < numCol; coluna++)
{//n*n
if (linha == coluna) {
matrizU[linha][coluna] = 1.0;
} else {
matrizU[linha][coluna] = 0.0;
}
}
}
for (j = 0; j < numLin; j++) {//n
for (i = j; i < numCol; i++) {//n*n
sum = 0;
for (k = 0; k < j; k++) {//n*n*n
sum = sum +
matrizL[i][k].floatValue() *
matrizU[k][j].floatValue();
}
matrizL[i][j] = matriz[i][j].floatValue()
- sum;
}
for (i = j; i < numCol; i++) {//n*n
sum = 0;
for(k = 0; k < j; k++) {//n*n*n
sum = sum +
matrizL[j][k].floatValue() *
matrizU[k][i].floatValue();
}
if (matrizL[j][j] == 0) {
System.out.printf("t Foi
encontrada uma divizao por zero
que impossibilita a execucao
desse metodo.");
}
else{
matrizU[j][i] =
(matriz[j][i].floatValue() -
sum) /
matrizL[j][j].floatValue();
}
}
}
}
public static void DecompoeLemDL(Double[][] matriz, int
numLin,
int numCol, Double[][] matrizx) {
/*
* L*matrizy = b (matrizx)
* Calcula L[m,n]/D[x,y] = L’ sendo que x=y
* */
for (int k = 0; k < numLin; k++) { //n
for (int i = 0; i < numCol; i++) {//n*n
matrizx[i][k] = 0.0;
}
}
for (int p = numLin - 1; p >= 0; p--) {//n
matrizx[p][p]=(double)matriz[p][p].floatValue();
for (int j = p; j >= 0; j--) {//n*n
matriz[p][j]=
(double)matriz[p][j].floatValue()/
matrizx[p][p].floatValue();
}
}
}
Avaliando os algoritmos implementados podemos concluir que o algoritmo
de Crout tem o custo O(n3
) o que o torna praticamente idˆentico ao algoritmo de
decomposic¸˜ao LDU o custo ´e da Ordem(n3
).
2.4. M´etodo de Gauss-Jordan
O m´etodo de Gauss-Jordan ´e um m´etodo de escalonamento que consiste em aplicar
operac¸˜oes elementares `a matriz aumentada de um sistema, at´e que ela esteja na forma
escalonada reduzida. A vantagem deste processo ´e que um sistema cuja matriz aumentada
´e uma matriz na forma escalonada reduzida tem soluc¸˜ao imediata, enquanto que para
resolver um sistema que est´a apenas na forma escalonada ainda ´e necess´ario fazer uma
s´erie de substituic¸˜oes para obter a soluc¸˜ao final.
• O primeiro elemento n˜ao-nulo de cada linha n˜ao-nula (chamado o pivˆo da linha)
´e igual a 1.
• O pivˆo da linha i + 1 ocorre `a direita do pivˆo da linha i.
• Se uma coluna cont´em um pivˆo, ent˜ao todas os outros elementos desta coluna s˜ao
iguais a 0.
• Todas as linhas nulas ocorrem abaixo das linhas n˜ao-nulas.
As etapas para resolver um sistemas de equac¸˜oes utilizando a eliminac¸˜ao de
Gauss-Jordan ´e descrito a seguir.
1. Escreva a matriz aumentada do sistema.
2. Use as operac¸˜oes lineares para transformar a matriz aumentada na forma descrita
abaixo, que ´e chamado de forma escalonada reduzida de linha.
(a) Em cada linha que n˜ao consiste inteiramente em zeros, o elemento dife-
rente de zero mais `a esquerda ´e o pivˆo.
(b) Cada coluna que cont´em um pivˆo tem zeros em todas as outras entradas.
(c) O pivˆo em qualquer linha est´a `a esquerda de qualquer pivˆo nas linhas
abaixo dele.
(d) ) Caso existam linhas que consistem inteiramente de zeros, elas s˜ao agru-
padas em conjunto na parte inferior da matriz.
3. Ao atingir o resultado descrito no processo 2, se vocˆe obter uma linha cujos ele-
mentos s˜ao todos os zeros, exceto a ´ultima `a direita. Nesse caso, o sistema ´e
inconsistente e n˜ao tem soluc¸˜oes. Caso contr´ario, as soluc¸˜oes do sistema est˜ao na
matriz final.
Avaliando os algoritmos implementados podemos concluir que o algoritmo de
Gauss-Jordan tem o custo na Ordem(n3
) o que o torna praticamente idˆentico ao custo do
algoritmo de decomposic¸˜ao LDU e ao custo do M´etodo de Crout avaliados nesse artigo.
3. Algoritmos
Este cap´ıtulo apresenta os algoritmos 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 A=LU
Este algoritmo consiste em fazer a fatorac¸˜ao da A em LU. Abaixo inclu´ımos o c´odigo
utilizado para processar computacionalmente essa operac¸˜ao.
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|
*
* U
* |R R R|
* |0 R R|
* |0 0 R|
*
* */
for (int k = 0; k < numLin; k++) { //n
for (int i = k + 1; i < numLin; i++) { //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++)
{//n*n*n
matriz[i][j] = (double)
matriz[i][j].floatValue()-
(matrizL[i][k].floatValue() *
matriz[k][j].floatValue());
}
}
}
}
3.2. Decomposic¸˜ao A=LDU
Este algoritmo consiste em fazer a fatorac¸˜ao da A em LU, depois fatorar U para obter DU’.
Abaixo inclu´ımos o c´odigo utilizado para processar computacionalmente essa operac¸˜ao.
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|
*
* U
* |R R R|
* |0 R R|
* |0 0 R|
*
* */
for (int k = 0; k < numLin; k++) { //n
for (int i = k + 1; i < numLin; i++) { //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++)
{//n*n*n
matriz[i][j] = (double)
matriz[i][j].floatValue()-
(matrizL[i][k].floatValue() *
matriz[k][j].floatValue());
}
}
}
}
public static void DecompoeUemDU(Double[][] matriz, int
numLin, int numCol, Double[][] matrizx) {
/*
* U*matrizy = b (matrizx)
* Calcula U[m,n]/D[x,y] = U’ sendo que x=y
*
* U’
* |1 R R|
* |0 1 R|
* |0 0 1|
*
* D
* |R 0 0|
* |0 R 0|
* |0 0 R|
*
*
* */
for (int k = 0; k < numLin; k++) {n
for (int i = 0; i < numCol; i++) {n*n
matrizx[i][k] = 0.0;
}
}
for (int p = numLin - 1; p >= 0; p--) {n
matrizx[p][p]=(double)matriz[p][p].floatValue();
for (int j = p; j < numCol; j++) {n*n
matriz[p][j]=(double)matriz[p][j].floatValue()/matrizx[p][p].flo
}
}
}
3.3. M´etodo de Gauss-Jordan
Este algoritmo consiste em aplicar operac¸˜oes elementares `a matriz aumentada de um sis-
tema, at´e que ela esteja na forma escalonada reduzida. Abaixo inclu´ımos o c´odigo utili-
zado para processar computacionalmente essa operac¸˜ao.
public static void Gauss(double[][] matriz, int numLin,
int numCol, double[] matriz2, int numCol2,
double[][] matrizx ) {
double[][] a;// N-por-N+1 matriz aumentada
// constroi a matriz
a = new double[numCol2][numCol2 + numCol2 + 1];
for (int i = 0; i < numCol2; i++)//n
for (int j = 0; j < numCol2; j++)//n*n
a[i][j] = matriz[i][j];
for (int i = 0; i < numCol2; i++)
a[i][numCol2 + i] = 1.0;
for (int i = 0; i < numCol2; i++)
a[i][numCol2 + numCol2] = matriz2[i];
// E l i m i n a o de Gauss-Jordan
for (int p = 0; p < numCol2; p++) {//n
// busca a linha do pivo usando pivoteamento
parcial
int max = p;
for (int i = p + 1; i < numCol2; i++) {//n*n
if (Math.abs(a[i][p]) >
Math.abs(a[max][p])) {
max = i;
}
}
// muda aposicao da linha p com a linha max
swap(p, max,a);
// singular ou quase singular
if (Math.abs(a[p][p]) <= EPSILON) {
continue;
// throw new
// RuntimeException("A Matriz e singular
ou quase singular");
}
// pivota
pivota(p, p,numCol2,a);//n*n*n
}
for (int i = 0; i < numCol2; i++){
matriz2[i]=a[i][6];
for (int j = 0; j < numCol2; j++)
matrizx[i][j] = a[i][j];
}
System.out.println();
}
// executa o pivoteamento em (p, q) usando Eliminacao
Gauss-Jordan
private static void pivota(int p, int q,int N, double
a[][]) {
// altera tudo, menos linha p e coluna q
for (int i = 0; i < N; i++) {//n
double alpha = a[i][q] / a[p][q];
for (int j = 0; j <= N + N; j++) {//n*n
if (i != p && j != q)
a[i][j] -= alpha * a[p][j];
}
}
// zera a coluna q
for (int i = 0; i < N; i++)
if (i != p)
a[i][q] = 0.0;
// escala a linha p
for (int j = 0; j <= N + N; j++)
if (j != q)
a[p][j] /= a[p][q];
a[p][q] = 1.0;
}
3.4. M´etodo de Crout
Este algoritmo consiste em fazer a fatorac¸˜ao da A em LU, sendo que L ´e triangular
inferior e U ´e triangular superior unit´aria. Abaixo inclu´ımos o c´odigo utilizado para
processar computacionalmente essa operac¸˜ao.
public static void TransformaTraingularLU(Double[][]
matriz, int numLin,
int numCol, Double[][] matrizL,Double[][] matrizU)
{
/*
* Decomposi o de A em L e U
*
* L
* |R 0 0|
* |R R 0|
* |R R R|
*
* U
* |1 R R|
* |0 1 R|
* |0 0 1|
*
*
* */
int i, j, k;
double sum = 0;
for (int linha = 0; linha < numLin; linha++) {
for (int coluna = 0; coluna < numCol; coluna++) {
if (linha == coluna) {
matrizU[linha][coluna] = 1.0;
} else {
matrizU[linha][coluna] = 0.0;
}
}
}
for (j = 0; j < numLin; j++) {
for (i = j; i < numCol; i++) {
sum = 0;
for (k = 0; k < j; k++) {
sum = sum +
matrizL[i][k].floatValue() *
matrizU[k][j].floatValue();
}
matrizL[i][j] = matriz[i][j].floatValue()
- sum;
}
for (i = j; i < numCol; i++) {
sum = 0;
for(k = 0; k < j; k++) {
sum = sum +
matrizL[j][k].floatValue() *
matrizU[k][i].floatValue();
}
if (matrizL[j][j] == 0) {
System.out.printf("t Foi
encontrada uma divizao por zero
que impossibilita a e x e c u o
desse metodo.");
}
else{
matrizU[j][i] =
(matriz[j][i].floatValue() -
sum) /
matrizL[j][j].floatValue();
}
}
}
}
public static void DecompoeLemDL(Double[][] matriz, int
numLin,
int numCol, Double[][] matrizx) {
/*
* L*matrizy = b (matrizx)
* Calcula L[m,n]/D[x,y] = L’ sendo que x=y
*
* L
* |R 0 0|
* |R R 0|
* |R R R|
*
* <=>
*
* L’
* |1 0 0|
* |R 1 0|
* |R R 1|
*
* D
* |R 0 0|
* |0 R 0|
* |0 0 R|
*
* */
for (int k = 0; k < numLin; k++) {
for (int i = 0; i < numCol; i++) {
matrizx[i][k] = 0.0;
}
}
for (int p = numLin - 1; p >= 0; p--) {
matrizx[p][p]=(double)matriz[p][p].floatValue();
for (int j = p; j >= 0; j--) {
matriz[p][j]=
(double)matriz[p][j].floatValue()/
matrizx[p][p].floatValue();
}
}
}
4. Conclus˜ao
Podemos concluir que existem v´arias formas de processar e resolver sistemas lineares uti-
lizando conceitos de ´Algebra Linear de forma computacional. O estudo visa alcanc¸ar a
utilizac¸˜ao pr´atica de sistemas lineares e de matrizes, superando as limitac¸˜oes da resoluc¸˜ao
manual de problemas reais e compreendendo os resultados obtidos atrav´es de sistemas
computacionais. Com esse trabalho esperamos contribuir com o aprendizado da ´algebra
linear computacional no curso de ciˆencias computacionais, possibilitando que esses algo-
ritmos sejam utilizadas e que inspirem a elaborac¸˜ao de teses, n˜ao apenas no conte´udo de
sistemas lineares, sua representac¸˜ao e soluc¸˜ao matricial mas tamb´em em outras situac¸˜oes
onde seja poss´ıvel discutir a contribuic¸˜ao da matem´atica da soluc¸˜ao de problemas reais.
5. Apˆendice
Nessa sess˜ao apresentamos os algoritmos que serviram de apoio para o desenvolvimento
das operac¸˜oes com matrizes. S˜ao eles:
5.1. Impress˜ao de Matriz
Essa func¸˜ao percorre todos os campos da matriz apresentando-os no log do console do
programa.
public static void imprimeMatriz(Double[][] matriz, int
numLin, int numCol) {
for (int linha = 0; linha < numLin; linha++) {
for (int coluna = 0; coluna < numCol; coluna++) {
System.out.printf("t %.2f t",
matriz[linha][coluna]);
}
System.out.println();
}
}
5.2. Carrega a Matriz
Essa func¸˜ao carrega os campos de uma matriz que est˜ao armazenados em um arquivo
texto para uma array de Double. Essa func¸˜ao foi desenvolvida para facilitar o processo de
carga da matriz.
public static String carregaMatriz(Double[][] matriz,
String nomeArquivo) {
Scanner arquivo;
String linCol = "";
try {
arquivo = new Scanner(new File(nomeArquivo));
int j = 0;
int i = 0;
while (arquivo.hasNextLine()) {
String line = arquivo.nextLine();
Scanner scanner = new Scanner(line);
scanner.useDelimiter(",");
j = 0;
while (scanner.hasNextDouble()) {
matriz[i][j] =
scanner.nextDouble();
j++;
}
scanner.close();
i++;
}
arquivo.close();
linCol = Integer.toString(i) + "," +
Integer.toString(j);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return linCol;
}
Referˆencias
ANTON, H. & BUSBY, R. (2006). Algebra Linear Contemporˆanea. BOOKMAN COM-
PANHIA EDITORA, 1th edition.
RUGGIERO, M.G. & LOPES, V. (1996). C´alculo num´erico – aspectos computacionais.

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Aula 21: Exercícios
Aula 21: ExercíciosAula 21: Exercícios
Aula 21: Exercícios
 
Gustavo relatorio
Gustavo relatorioGustavo relatorio
Gustavo relatorio
 
Aula 17: Separação da equação de Schrödinger em coordenadas cartesianas. Part...
Aula 17: Separação da equação de Schrödinger em coordenadas cartesianas. Part...Aula 17: Separação da equação de Schrödinger em coordenadas cartesianas. Part...
Aula 17: Separação da equação de Schrödinger em coordenadas cartesianas. Part...
 
Congruências Lineares e Classes Residuais
Congruências Lineares e Classes ResiduaisCongruências Lineares e Classes Residuais
Congruências Lineares e Classes Residuais
 
Aula 8 profmat congruencias - 20 10-17
Aula 8   profmat congruencias - 20 10-17Aula 8   profmat congruencias - 20 10-17
Aula 8 profmat congruencias - 20 10-17
 
Aula 14: O poço de potencial infinito
Aula 14: O poço de potencial infinitoAula 14: O poço de potencial infinito
Aula 14: O poço de potencial infinito
 
Aula 10: Exercícios
Aula 10: ExercíciosAula 10: Exercícios
Aula 10: Exercícios
 
Sistemas lineares
Sistemas linearesSistemas lineares
Sistemas lineares
 
Rodrigo de lima (uff) edo - parte 1edo
Rodrigo de lima (uff)   edo - parte 1edoRodrigo de lima (uff)   edo - parte 1edo
Rodrigo de lima (uff) edo - parte 1edo
 
Equações lineares
Equações lineares Equações lineares
Equações lineares
 
Aula 15: O oscilador harmônico
Aula 15: O oscilador harmônicoAula 15: O oscilador harmônico
Aula 15: O oscilador harmônico
 
Aula 20: O átomo de hidrogênio
Aula 20: O átomo de hidrogênioAula 20: O átomo de hidrogênio
Aula 20: O átomo de hidrogênio
 
Calculo d edo_1
Calculo d edo_1Calculo d edo_1
Calculo d edo_1
 
Aula 5 autovetores e autovalores
Aula 5   autovetores e autovaloresAula 5   autovetores e autovalores
Aula 5 autovetores e autovalores
 
Apostila álgebra linear
Apostila   álgebra linearApostila   álgebra linear
Apostila álgebra linear
 
Sistemas lineares
Sistemas linearesSistemas lineares
Sistemas lineares
 
92 268-1-pb (2)
92 268-1-pb (2)92 268-1-pb (2)
92 268-1-pb (2)
 
Cálculo e equações em Química - Apostila + exercícios com gabarito.
Cálculo e equações em Química - Apostila + exercícios com gabarito.Cálculo e equações em Química - Apostila + exercícios com gabarito.
Cálculo e equações em Química - Apostila + exercícios com gabarito.
 
Aula 13: O poço de potencial finito
Aula 13: O poço de potencial finitoAula 13: O poço de potencial finito
Aula 13: O poço de potencial finito
 
Princípios básicos da matemática do movimento - PDF
Princípios básicos da matemática do movimento - PDFPrincípios básicos da matemática do movimento - PDF
Princípios básicos da matemática do movimento - PDF
 

Destaque

Stevens-Benchmarking Sorting Algorithms
Stevens-Benchmarking Sorting AlgorithmsStevens-Benchmarking Sorting Algorithms
Stevens-Benchmarking Sorting Algorithms
James Stevens
 
Sec 3N Hist (Elec) Chapter 4.1: Outbreak of War in Europe (Hitler's Expansion...
Sec 3N Hist (Elec) Chapter 4.1: Outbreak of War in Europe (Hitler's Expansion...Sec 3N Hist (Elec) Chapter 4.1: Outbreak of War in Europe (Hitler's Expansion...
Sec 3N Hist (Elec) Chapter 4.1: Outbreak of War in Europe (Hitler's Expansion...
Weng Lun Ho
 
Sec 5N Hist (Elec) Chapter 11: End of Cold War
Sec 5N Hist (Elec) Chapter 11: End of Cold WarSec 5N Hist (Elec) Chapter 11: End of Cold War
Sec 5N Hist (Elec) Chapter 11: End of Cold War
Weng Lun Ho
 

Destaque (20)

GrainBinSafetyWeek
GrainBinSafetyWeekGrainBinSafetyWeek
GrainBinSafetyWeek
 
ACES Medical - How to choose a clearinghouse
ACES Medical - How to choose a clearinghouseACES Medical - How to choose a clearinghouse
ACES Medical - How to choose a clearinghouse
 
Stevens-Benchmarking Sorting Algorithms
Stevens-Benchmarking Sorting AlgorithmsStevens-Benchmarking Sorting Algorithms
Stevens-Benchmarking Sorting Algorithms
 
Introduction to WWI
Introduction to WWIIntroduction to WWI
Introduction to WWI
 
Airs Training Principles Of Recruiting Recap
Airs Training Principles Of Recruiting RecapAirs Training Principles Of Recruiting Recap
Airs Training Principles Of Recruiting Recap
 
Ingrid Lotze - Social Media in Marketing Africa 2011 - 25 February 2011
Ingrid Lotze - Social Media in Marketing Africa 2011 - 25 February 2011Ingrid Lotze - Social Media in Marketing Africa 2011 - 25 February 2011
Ingrid Lotze - Social Media in Marketing Africa 2011 - 25 February 2011
 
Every Player, All in
Every Player, All inEvery Player, All in
Every Player, All in
 
Proyect escobar byron
Proyect escobar byronProyect escobar byron
Proyect escobar byron
 
Garry Kasparov Unleashing Human Creativity with Intelligent Machines
Garry Kasparov Unleashing Human Creativity with Intelligent MachinesGarry Kasparov Unleashing Human Creativity with Intelligent Machines
Garry Kasparov Unleashing Human Creativity with Intelligent Machines
 
Causes of WWI
Causes of WWICauses of WWI
Causes of WWI
 
2015 advanced higher history exam
2015 advanced higher history exam2015 advanced higher history exam
2015 advanced higher history exam
 
Virginie vast - Self-disruption: How cognitive computing will recreate procur...
Virginie vast - Self-disruption:How cognitive computingwill recreate procur...Virginie vast - Self-disruption:How cognitive computingwill recreate procur...
Virginie vast - Self-disruption: How cognitive computing will recreate procur...
 
Industria lítica paleolítico inferior
Industria lítica paleolítico inferiorIndustria lítica paleolítico inferior
Industria lítica paleolítico inferior
 
Managing Healthcare in Singapore
Managing Healthcare in SingaporeManaging Healthcare in Singapore
Managing Healthcare in Singapore
 
Sec 3N Hist (Elec) Chapter 4.1: Outbreak of War in Europe (Hitler's Expansion...
Sec 3N Hist (Elec) Chapter 4.1: Outbreak of War in Europe (Hitler's Expansion...Sec 3N Hist (Elec) Chapter 4.1: Outbreak of War in Europe (Hitler's Expansion...
Sec 3N Hist (Elec) Chapter 4.1: Outbreak of War in Europe (Hitler's Expansion...
 
Outbreak of WWII in Europe
Outbreak of WWII in EuropeOutbreak of WWII in Europe
Outbreak of WWII in Europe
 
5. impact of nazi foreign policy
5. impact of nazi foreign policy5. impact of nazi foreign policy
5. impact of nazi foreign policy
 
Hitler's Germany - Impact of Hitler's Rule
Hitler's Germany - Impact of Hitler's RuleHitler's Germany - Impact of Hitler's Rule
Hitler's Germany - Impact of Hitler's Rule
 
Sec 3N Hist (Elec) Chapter 5.1: Germany's Defeat (USA's entry)
Sec 3N Hist (Elec) Chapter 5.1: Germany's Defeat (USA's entry)Sec 3N Hist (Elec) Chapter 5.1: Germany's Defeat (USA's entry)
Sec 3N Hist (Elec) Chapter 5.1: Germany's Defeat (USA's entry)
 
Sec 5N Hist (Elec) Chapter 11: End of Cold War
Sec 5N Hist (Elec) Chapter 11: End of Cold WarSec 5N Hist (Elec) Chapter 11: End of Cold War
Sec 5N Hist (Elec) Chapter 11: End of Cold War
 

Semelhante a Algebra linear operações com matrizes

Apostila sistemas lineares
Apostila sistemas linearesApostila sistemas lineares
Apostila sistemas lineares
day ....
 
Cálculo numérico aula 04 - resolução de sistemas de equações lineares - mét...
Cálculo numérico   aula 04 - resolução de sistemas de equações lineares - mét...Cálculo numérico   aula 04 - resolução de sistemas de equações lineares - mét...
Cálculo numérico aula 04 - resolução de sistemas de equações lineares - mét...
Rodolfo Almeida
 
Resolução da prova 1
Resolução da prova 1Resolução da prova 1
Resolução da prova 1
Ronaldo Chaves
 
Resolução da prova 1
Resolução da prova 1Resolução da prova 1
Resolução da prova 1
Ronaldo Chaves
 

Semelhante a Algebra linear operações com matrizes (20)

Métodos Para Resolver Sistemas de Equações Lineares
Métodos Para Resolver Sistemas de Equações LinearesMétodos Para Resolver Sistemas de Equações Lineares
Métodos Para Resolver Sistemas de Equações Lineares
 
Analise comparativa de métodos diretos e iterativos para a solução de sistema...
Analise comparativa de métodos diretos e iterativos para a solução de sistema...Analise comparativa de métodos diretos e iterativos para a solução de sistema...
Analise comparativa de métodos diretos e iterativos para a solução de sistema...
 
Introducao_a_Algebra_Linear.pdf
Introducao_a_Algebra_Linear.pdfIntroducao_a_Algebra_Linear.pdf
Introducao_a_Algebra_Linear.pdf
 
Mat sc conicas 002
Mat sc conicas  002Mat sc conicas  002
Mat sc conicas 002
 
108792 3107 28.07.2015 11.30.12_lista_1_algebra_linear_a1
108792 3107 28.07.2015 11.30.12_lista_1_algebra_linear_a1108792 3107 28.07.2015 11.30.12_lista_1_algebra_linear_a1
108792 3107 28.07.2015 11.30.12_lista_1_algebra_linear_a1
 
Sdnotes
SdnotesSdnotes
Sdnotes
 
Apontamento quantica
Apontamento quanticaApontamento quantica
Apontamento quantica
 
Numerov schrodinger
Numerov schrodingerNumerov schrodinger
Numerov schrodinger
 
Apostila sistemas lineares
Apostila sistemas linearesApostila sistemas lineares
Apostila sistemas lineares
 
Sist cont i_conf2_2014
Sist cont i_conf2_2014Sist cont i_conf2_2014
Sist cont i_conf2_2014
 
Algebra kat
Algebra  katAlgebra  kat
Algebra kat
 
Flexibilidade
FlexibilidadeFlexibilidade
Flexibilidade
 
Sistemas lineares
Sistemas linearesSistemas lineares
Sistemas lineares
 
Cálculo numérico aula 04 - resolução de sistemas de equações lineares - mét...
Cálculo numérico   aula 04 - resolução de sistemas de equações lineares - mét...Cálculo numérico   aula 04 - resolução de sistemas de equações lineares - mét...
Cálculo numérico aula 04 - resolução de sistemas de equações lineares - mét...
 
Resolução da prova 1
Resolução da prova 1Resolução da prova 1
Resolução da prova 1
 
Resolução da prova 1
Resolução da prova 1Resolução da prova 1
Resolução da prova 1
 
Formula luderiana racional para raiz cubica
Formula luderiana racional para raiz cubicaFormula luderiana racional para raiz cubica
Formula luderiana racional para raiz cubica
 
Vibracoes
VibracoesVibracoes
Vibracoes
 
Diogo t.robaina edp
Diogo t.robaina edpDiogo t.robaina edp
Diogo t.robaina edp
 
Integral multiplas
Integral multiplasIntegral multiplas
Integral multiplas
 

Algebra linear operações com matrizes

  • 1. ´Algebra Linear - Operac¸˜oes com Matrizes 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 Li- near aplicados em soluc¸˜oes computacionais. Este trabalho apresenta o refe- rencial te´orico utilizado como base para resolver computacionalmente sistemas lineares. Apresentaremos a ”Decomposic¸˜ao A=LU”fazendo uma comparac¸˜ao com a decomposic¸˜ao de Gauss, a ”Decomposic¸˜ao A=LDU”comparando-a com o m´etodo de Crout. Por fim apresentamos o ”M´etodo de Gauss-Jordan”que obt´em a inversa de uma matriz. 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 a teoria de sistemas lineares ´e a base e uma parte fundamental da ´algebra linear, um tema que ´e usado na maior parte da matem´atica moderna. Deve-se observar que, em primeiro lugar, a equac¸˜ao linear ´e, necessariamente, uma equac¸˜ao polinomial. Tamb´em na matem´atica aplicada, podemos encontrar v´arios usos de sistemas lineares. Exemplos s˜ao a f´ısica, a economia, a engenharia, a biologia, a geografia, a navegac¸˜ao, a aviac¸˜ao, a cartografia, a demografia e a astronomia.[RUGGIERO 1996] 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] Algoritmos computacionais s˜ao, por encontrar as soluc¸˜oes, uma parte importante da ´algebra linear num´erica. Voltando na hist´oria da ´algebra linear, uma vers˜ao preliminar da eliminac¸˜ao gaussiana apareceu pela primeira vez no livro chinˆes “Nove Cap´ıtulos de Arte Matem´atica”, em torno de 200 a.C. O poder do m´etodo n˜ao tinha sido reconhecido at´e que o grande matem´atico Carl Friedich Gauss no ano de 1801 utilizou o m´etodo para calcular a ´orbita do asteroide Ceres com pouqu´ıssimas informac¸˜oes utilizando m´ınimos quadrados e o procedimento que hoje denominamos eliminac¸˜ao gaussiana. O trabalho de Gauss causou sensac¸˜ao quando Ceres reapareceu na constelac¸˜ao de Virgem, local aproximado aos seus c´alculos.[ANTON 2006] Mais tarde o m´etodo foi popularizado quando Willian Jordan (engenheiro alem˜ao) em 1888 publicou no seu livro de geod´esia intitulado “Handbuch der Vermessungskunde”. Embora as ideias tenham sido conhecidas antes, muitas vezes o cr´edito pela popularizac¸˜ao da decomposic¸˜ao LU ´e atribu´ıda ao l´ogico e matem´atico britˆanico Alan Turing, pelo seu trabalho de 1948 nesse assunto. Ao final dos anos 1970, a Fundac¸˜ao Nacional de Ciˆencias e o Departamento de Energia dos EUA financiaram o desenvolvimento de rotinas de computacionais para in- verter matrizes e resolver sistemas de equac¸˜oes lineares. Aquela pesquisa levou a um conjunto de programas Fortran chamado LINPAC que s˜ao uma referˆencia para muitos algoritmos computacionais de hoje, inclusive no MATLAB. As rotinas LIMPAC est˜ao
  • 2. organizadas em torno de quatro fatorac¸˜oes de matrizes, uma das quais ´e a decomposic¸˜ao LU. C.B. Moler, J.J. Dongarra, G.W. Stewart e J.R. Brunch, os principais programadores do LINPAC, basearam muitas de suas id´eias no trabalho de Jemes Boyle e Kenneth Dritz, do Laborat´orio Argonne (nos EUA).[ANTON 2006] 2. Teoria de Matrizes 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 para resolver equac¸˜oes lineares utilizando matrizes. 2.1. Resoluc¸˜ao de Sistemas Lineares Antes de nos aprofundarmos nas operac¸˜oes com matrizes, ´e necess´ario entender os con- ceitos e m´etodos das operac¸˜oes elementares de um sistema linear que podemos imple- mentar para encontrar as soluc¸˜oes computacionalmente. Por exemplo, um m´etodo para resolver um sistema linear ´e substituir o sistema inicial por outro que tenha o mesmo con- junto soluc¸˜ao do primeiro, mas que seja muito mais f´acil de resolver. O novo sistema ´e obtido ap´os a aplicac¸˜ao de uma s´erie de operac¸˜oes que simplificam as equac¸˜oes do sistema que tˆem a propriedade especial de n˜ao alterar o conjunto soluc¸˜ao. Estas operac¸˜oes s˜ao chamadas operac¸˜oes elementares e s˜ao de trˆes tipos diferentes. • Trocar duas equac¸˜oes do sistema de posic¸˜ao. • Substituir uma equac¸˜ao pela mesma equac¸˜ao multiplicada por um escalar diferente de 0. • Substituir uma equac¸˜ao pela mesma equac¸˜ao somada a outra equac¸˜ao multiplicada por um escalar. Note que se multiplicarmos uma equac¸˜ao por 0, estaremos excluindo esta equac¸˜ao do sistema, o que tem o efeito prov´avel de aumentar o conjunto soluc¸˜ao, por isso, esta n˜ao ´e uma operac¸˜ao elementar. ´E f´acil ver que ao efetuarmos qualquer uma das operac¸˜oes acima sobre as equac¸˜oes do sistema, n˜ao estaremos acrescentando nem dimi- nuindo soluc¸˜oes. Somente os coeficientes do sistema s˜ao alterados atrav´es das operac¸˜oes elemen- tares, as vari´aveis permanecem inalteradas. Portanto, na hora de efetuar os c´alculos, ao inv´es de considerar todo o sistema, podemos considerar apenas a matriz de coeficientes do sistema, chamada matriz aumentada: [A|B] = α11 α12 ... α1n β1 α21 α22 ... α2n β2 α31 α32 ... α3n β3 ... ... ... ... αm1 αm2 ... αmn βm As operac¸˜oes elementares ser˜ao efetuadas sobre as linhas desta matriz. Definic¸˜ao. Operac¸˜oes Elementares sobre as linhas de uma matriz: • a troca da posic¸˜ao relativa de duas linhas Li ← Lj
  • 3. • a multiplicac¸˜ao de uma linha por uma constante Li ← cLj ⇔ c = 0 • a substituic¸˜ao de uma linha pela sua soma com outra linha qualquer Li ← Li + Lj Teorema. Se dois sistemas lineares Ax = B e Cx = D s˜ao tais que a matriz aumentada [C|D] ´e obtida de [A|B] aplicando-se operac¸˜oes elementares, ent˜ao os dois sistemas pos- suem as mesmas soluc¸˜oes. Sistemas que possuem as mesmas soluc¸˜oes s˜ao chamados sistemas equivalentes. 2.2. Decomposic¸˜ao A=LU A decomposic¸˜ao LU de uma matriz A surge da necessidade de resolver um conjunto de sistemas do tipo Ax = b1, Ax = b2, Ax = b3 e assim por diante. Poder´ıamos resolver cada um desses sistemas escalonando a matriz completa [A b] correspondente at´e sua forma escalonada reduzida mas, computacionalmente, o escalonamento ´e um processo muito demorado e poder´ıamos ter centenas de b’s para resolver. Supondo-se que A seja uma matriz mxm que pode ser escalonada at´e sua forma reduzida sem trocar linhas, a ´Algebra Linear nos diz que ela pode ser escrita na forma A = LU, onde L Lower ´e uma matriz triangular inferior mxm cuja diagonal principal possui apenas 1’s e U Upper ´e uma matriz triangular superior mxm que nada mais ´e do que a pr´opria forma escalonada reduzida de A. Para uma matriz 3x3: A = L*U   a11 a12 a13 a21 a22 a23 a31 a32 a33   =   1 0 0 l21 1 0 l31 l32 1   ∗   u11 u12 u13 0 u22 u23 0 0 u33   A importˆancia de escrevermos uma matriz como o produto de duas outras matrizes triangulares, uma inferior e a outra superior, se d´a pelo fato de que, ao assumirmos que A = LU, podemos reescrever a equac¸˜ao Ax = b como LUx = B ou, pela propriedade associativa, L(Ux) = B. Tomando-se Ux = y, temos Ly = b e Ux = y. Resolvendo-se a primeira equac¸˜ao para y e a segunda para x, obteremos a resposta procurada de uma maneira bem mais simples do que fazer pelo m´etodo tradicional, visto que as matrizes s˜ao triangulares. Vale lembrar que quando um pivˆo nulo ´e encontrado temos um caso onde pode ou n˜ao existir uma decomposic¸˜ao LU. 2.2.1. Comparando eliminac¸˜ao gaussiana com decomposic¸˜ao LU Para determinac¸˜ao das inc´ognitas, o m´etodo da eliminac¸˜ao de Gauss desenvolve duas fa- ses: a primeira ´e a eliminac¸˜ao progressiva, onde reduz o n´umero de vari´aveis ao longo da execuc¸˜ao para, ent˜ao, aplicar a segunda fase, chamada de substituic¸˜ao regressiva, onde utiliza o resultado da primeira para determinar a soluc¸˜ao geral do sistema. Dois passos descritos, o primeiro ´e o que consome mais tempo de c´alculo, uma vez que ´e nesta fase que consiste o maior n´umero de operac¸˜oes aritm´eticas e de trocas dedados. Por isso, encontrar um m´etodo que minimize esta fase cr´ıtica implica em aumentar o
  • 4. desempenho para realizar a tarefa de resoluc¸˜ao de sistemas lineares. Os m´etodos de decomposic¸˜ao LU consistem em separar a fase de eliminac¸˜ao da matriz dos coeficien- tes, que consomem maior tempo, das manipulac¸˜oes envolvidas com o vetor dos termos independentes. Portanto, devemos deixar claro que, ao contr´ario da eliminac¸˜ao de Gauss, uma decomposic¸˜ao de LU ´e uma estrat´egia de melhoria na resoluc¸˜ao de sistemas lineares. Sendo assim, n˜ao existe “o m´etodo” de decomposic¸˜ao LU, mas sim algumas abordagens a serem tomadas que permitem decompor o sistema. Uma implicac¸˜ao interessante disso ´e que a pr´opria eliminac¸˜ao de Gauss pode ser descrita como uma decomposic¸˜ao LU. O custo de processamento do algoritmo de decomposic¸˜ao LU pode ser visto pelo n´umero de estruturas de repetic¸˜ao utilizados no c´odigo. No c´odigo implementado, o custo ´e da Ordem(n3 ) para a decomposic¸˜ao LU. /* * Decomposi o de A em L e U * */ for (int k = 0; k < numLin; k++) { //n for (int i = k + 1; i < numLin; i++) { //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++) {//n*n*n matriz[i][j] = (double) matriz[i][j].floatValue()- (matrizL[i][k].floatValue() * matriz[k][j].floatValue()); } } } } Da mesma forma podemos calcular o custo de processamento do algoritmo de eliminac¸˜ao Gaussiana pode ser visto pelo n´umero de estruturas de repetic¸˜ao utilizados no c´odigo. No c´odigo implementado no trabalho anterior, o custo ´e da Ordem(n3 ). /** * A primeira funcao obtem a triangular superior da matriz composta. */ public static void TriangularSuperior(Double[][] matriz, int numLin, int numCol, Double[][] matriz2, int numLin2, int numCol2,Double[][] matrizx) { double calculo; for (int coluna = 0; coluna < numLin2; coluna++) {n for (int linha = coluna + 1; linha < numLin2;
  • 5. linha++) {n*n calculo = (matriz[linha][coluna].floatValue() / matriz[coluna][coluna].floatValue()); matriz[linha][coluna]=0.0; for(int s=coluna+1; s <numLin2; s++){n*n*n matriz[linha][s]= matriz[linha][s].floatValue() - (calculo*matriz[coluna][s].floatValue()); } matriz2[linha][0]= (double)matriz2[linha][0].floatValue() - (matriz2[coluna][0].floatValue()*calculo); } } } Podemos concluir que o custo do processamento da decomposic¸˜ao LU ´e idˆentico ao custo da Eliminac¸˜ao Gaussiana. 2.3. Decomposic¸˜ao A=LDU A Decomposic¸˜ao A=LDU tamb´em ´e utilizada para soluc¸˜ao de sistemas lineares, que con- siste em efetuar a decomposic¸˜ao da matriz A em trˆes componentes L Lower, D Diagonal e U Upper a soma dos elementos correspondentes. A decomposic¸˜ao A = LDU permite resolver um sistema Ax = b em trˆes passos: • achar c de Lc = b • achar z de Dz = c • achar x de Ux = z A decomposic¸˜ao LDU ´e ´unica e permite flexibilidade para o c´alculo pr´atico das matrizes L e U. Por exemplo, isto acontece com a reduc¸˜ao de Crout, na qual considera-se LD como sendo uma matriz triangular inferior L (sem elementos unit´arios na sua diago- nal) de modo que A = LU com U triangular superior e elementos unit´arios na sua diagonal. Esta reduc¸˜ao permite calcular alternadamente as colunas de L e de U. O processo consiste em obter primeiramente a fatorac¸˜ao LU, e depois decom- pondo a matriz U no produto de uma matriz D, com uma matriz que tamb´em se designa por U, onde: • D ´e uma matriz m x m diagonal cujos elementos da diagonal principal s˜ao os pivos da eliminac¸˜ao de Gauss ou zero no caso de n˜ao haver pivˆo; • U ´e uma matriz m x m obtida apos eliminac¸˜ao de Gauss, dividindo cada linha pelo respectivo pivo. Para uma matriz 3x3: A=LDU
  • 6.   a11 a12 a13 a21 a22 a23 a31 a32 a33   =   1 0 0 l21 1 0 l31 l32 1   ∗   d11 0 0 0 d22 0 0 0 d33   ∗   1 u12 u13 0 1 u23 0 0 1   Quando um pivˆo nulo ´e encontrado temos um caso onde pode ou n˜ao existir uma decomposic¸˜ao LU. A decomposic¸˜ao LU n˜ao ´e ´unica, j´a a decomposic¸˜ao LDU por sua vez ´e ´unica. 2.3.1. Comparac¸˜ao da decomposic¸˜ao LDU e Crout Para compararmos LDU com Crout primeiro precisamos de fazer uma pequena apresentac¸˜ao de Crout que ´e uma variante da fatorac¸˜ao triangular da matriz A. Toma-se a matriz U como triangular de diagonal unit´aria e L como triangular inferior.   a11 a12 a13 a21 a22 a23 a31 a32 a33   =   l11 0 0 l21 l22 0 l31 l32 l33   ∗   1 u12 u13 0 1 u23 0 0 1   Como falado anteriormente a decomposic¸˜ao LDU consiste numa pequena alterac¸˜ao da fatorac¸˜ao de Crout e tem a vantagem de atribuir `as matrizes triangulares L e U um papel totalmente idˆentico. Consiste em considerar que estas s˜ao ambas matrizes triangulares com diagonal unit´aria e tomar a fatorac¸˜ao na seguinte forma A = LDU em que D ´e uma matriz diagonal. O custo de processamento do algoritmo de decomposic¸˜ao LDU pode ser visto pelo n´umero de estruturas de repetic¸˜ao utilizados no c´odigo. No c´odigo implementado, o custo ´e da Ordem (n3 ) para a decomposic¸˜ao de A em LU e n2 para decomposic¸˜ao de U em DU’. Resumindo podemos concluir que a decomposic¸˜ao LDU tem o custo ´e da Ordem(n3 ). public static void TransformaTraingularLU(Double[][] matriz, int numLin, int numCol, Double[][] matrizL) { /* * Decomposi o de A em L e U * */ for (int k = 0; k < numLin; k++) { //n for (int i = k + 1; i < numLin; i++) { //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++) {//n*n*n matriz[i][j] = (double) matriz[i][j].floatValue()- (matrizL[i][k].floatValue() * matriz[k][j].floatValue()); } }
  • 7. } } public static void DecompoeUemDU(Double[][] matriz, int numLin, int numCol, Double[][] matrizx) { /* * U*matrizy = b (matrizx) * Calcula U[m,n]/D[x,y] = U’ sendo que x=y * */ for (int k = 0; k < numLin; k++) {//n for (int i = 0; i < numCol; i++) {//n*n matrizx[i][k] = 0.0; } } for (int p = numLin - 1; p >= 0; p--) {//n matrizx[p][p]=(double)matriz[p][p].floatValue(); for (int j = p; j < numCol; j++) {//n*n matriz[p][j]=(double)matriz[p][j].floatValue() /matrizx[p][p].floatValue(); } } } O custo de processamento do algoritmo de Crout tamb´em pode ser visto pelo n´umero de estruturas de repetic¸˜ao utilizados no c´odigo. No c´odigo implementado, o custo ´e n3 para a decomposic¸˜ao de A em LU e n2 para decomposic¸˜ao de L em DL’. public static void TransformaTraingularLU(Double[][] matriz, int numLin, int numCol, Double[][] matrizL,Double[][] matrizU) { /* * Decomposi o de A em L e U * */ int i, j, k; double sum = 0; for (int linha = 0; linha < numLin; linha++) {//n for (int coluna = 0; coluna < numCol; coluna++) {//n*n if (linha == coluna) { matrizU[linha][coluna] = 1.0; } else { matrizU[linha][coluna] = 0.0; } } }
  • 8. for (j = 0; j < numLin; j++) {//n for (i = j; i < numCol; i++) {//n*n sum = 0; for (k = 0; k < j; k++) {//n*n*n sum = sum + matrizL[i][k].floatValue() * matrizU[k][j].floatValue(); } matrizL[i][j] = matriz[i][j].floatValue() - sum; } for (i = j; i < numCol; i++) {//n*n sum = 0; for(k = 0; k < j; k++) {//n*n*n sum = sum + matrizL[j][k].floatValue() * matrizU[k][i].floatValue(); } if (matrizL[j][j] == 0) { System.out.printf("t Foi encontrada uma divizao por zero que impossibilita a execucao desse metodo."); } else{ matrizU[j][i] = (matriz[j][i].floatValue() - sum) / matrizL[j][j].floatValue(); } } } } public static void DecompoeLemDL(Double[][] matriz, int numLin, int numCol, Double[][] matrizx) { /* * L*matrizy = b (matrizx) * Calcula L[m,n]/D[x,y] = L’ sendo que x=y * */ for (int k = 0; k < numLin; k++) { //n for (int i = 0; i < numCol; i++) {//n*n matrizx[i][k] = 0.0;
  • 9. } } for (int p = numLin - 1; p >= 0; p--) {//n matrizx[p][p]=(double)matriz[p][p].floatValue(); for (int j = p; j >= 0; j--) {//n*n matriz[p][j]= (double)matriz[p][j].floatValue()/ matrizx[p][p].floatValue(); } } } Avaliando os algoritmos implementados podemos concluir que o algoritmo de Crout tem o custo O(n3 ) o que o torna praticamente idˆentico ao algoritmo de decomposic¸˜ao LDU o custo ´e da Ordem(n3 ). 2.4. M´etodo de Gauss-Jordan O m´etodo de Gauss-Jordan ´e um m´etodo de escalonamento que consiste em aplicar operac¸˜oes elementares `a matriz aumentada de um sistema, at´e que ela esteja na forma escalonada reduzida. A vantagem deste processo ´e que um sistema cuja matriz aumentada ´e uma matriz na forma escalonada reduzida tem soluc¸˜ao imediata, enquanto que para resolver um sistema que est´a apenas na forma escalonada ainda ´e necess´ario fazer uma s´erie de substituic¸˜oes para obter a soluc¸˜ao final. • O primeiro elemento n˜ao-nulo de cada linha n˜ao-nula (chamado o pivˆo da linha) ´e igual a 1. • O pivˆo da linha i + 1 ocorre `a direita do pivˆo da linha i. • Se uma coluna cont´em um pivˆo, ent˜ao todas os outros elementos desta coluna s˜ao iguais a 0. • Todas as linhas nulas ocorrem abaixo das linhas n˜ao-nulas. As etapas para resolver um sistemas de equac¸˜oes utilizando a eliminac¸˜ao de Gauss-Jordan ´e descrito a seguir. 1. Escreva a matriz aumentada do sistema. 2. Use as operac¸˜oes lineares para transformar a matriz aumentada na forma descrita abaixo, que ´e chamado de forma escalonada reduzida de linha. (a) Em cada linha que n˜ao consiste inteiramente em zeros, o elemento dife- rente de zero mais `a esquerda ´e o pivˆo. (b) Cada coluna que cont´em um pivˆo tem zeros em todas as outras entradas. (c) O pivˆo em qualquer linha est´a `a esquerda de qualquer pivˆo nas linhas abaixo dele. (d) ) Caso existam linhas que consistem inteiramente de zeros, elas s˜ao agru- padas em conjunto na parte inferior da matriz. 3. Ao atingir o resultado descrito no processo 2, se vocˆe obter uma linha cujos ele- mentos s˜ao todos os zeros, exceto a ´ultima `a direita. Nesse caso, o sistema ´e inconsistente e n˜ao tem soluc¸˜oes. Caso contr´ario, as soluc¸˜oes do sistema est˜ao na matriz final.
  • 10. Avaliando os algoritmos implementados podemos concluir que o algoritmo de Gauss-Jordan tem o custo na Ordem(n3 ) o que o torna praticamente idˆentico ao custo do algoritmo de decomposic¸˜ao LDU e ao custo do M´etodo de Crout avaliados nesse artigo. 3. Algoritmos Este cap´ıtulo apresenta os algoritmos 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 A=LU Este algoritmo consiste em fazer a fatorac¸˜ao da A em LU. Abaixo inclu´ımos o c´odigo utilizado para processar computacionalmente essa operac¸˜ao. 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| * * U * |R R R| * |0 R R| * |0 0 R| * * */ for (int k = 0; k < numLin; k++) { //n for (int i = k + 1; i < numLin; i++) { //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++) {//n*n*n matriz[i][j] = (double) matriz[i][j].floatValue()- (matrizL[i][k].floatValue() * matriz[k][j].floatValue()); } } }
  • 11. } 3.2. Decomposic¸˜ao A=LDU Este algoritmo consiste em fazer a fatorac¸˜ao da A em LU, depois fatorar U para obter DU’. Abaixo inclu´ımos o c´odigo utilizado para processar computacionalmente essa operac¸˜ao. 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| * * U * |R R R| * |0 R R| * |0 0 R| * * */ for (int k = 0; k < numLin; k++) { //n for (int i = k + 1; i < numLin; i++) { //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++) {//n*n*n matriz[i][j] = (double) matriz[i][j].floatValue()- (matrizL[i][k].floatValue() * matriz[k][j].floatValue()); } } } } public static void DecompoeUemDU(Double[][] matriz, int numLin, int numCol, Double[][] matrizx) { /* * U*matrizy = b (matrizx) * Calcula U[m,n]/D[x,y] = U’ sendo que x=y * * U’ * |1 R R|
  • 12. * |0 1 R| * |0 0 1| * * D * |R 0 0| * |0 R 0| * |0 0 R| * * * */ for (int k = 0; k < numLin; k++) {n for (int i = 0; i < numCol; i++) {n*n matrizx[i][k] = 0.0; } } for (int p = numLin - 1; p >= 0; p--) {n matrizx[p][p]=(double)matriz[p][p].floatValue(); for (int j = p; j < numCol; j++) {n*n matriz[p][j]=(double)matriz[p][j].floatValue()/matrizx[p][p].flo } } } 3.3. M´etodo de Gauss-Jordan Este algoritmo consiste em aplicar operac¸˜oes elementares `a matriz aumentada de um sis- tema, at´e que ela esteja na forma escalonada reduzida. Abaixo inclu´ımos o c´odigo utili- zado para processar computacionalmente essa operac¸˜ao. public static void Gauss(double[][] matriz, int numLin, int numCol, double[] matriz2, int numCol2, double[][] matrizx ) { double[][] a;// N-por-N+1 matriz aumentada // constroi a matriz a = new double[numCol2][numCol2 + numCol2 + 1]; for (int i = 0; i < numCol2; i++)//n for (int j = 0; j < numCol2; j++)//n*n a[i][j] = matriz[i][j]; for (int i = 0; i < numCol2; i++) a[i][numCol2 + i] = 1.0; for (int i = 0; i < numCol2; i++) a[i][numCol2 + numCol2] = matriz2[i]; // E l i m i n a o de Gauss-Jordan for (int p = 0; p < numCol2; p++) {//n
  • 13. // busca a linha do pivo usando pivoteamento parcial int max = p; for (int i = p + 1; i < numCol2; i++) {//n*n if (Math.abs(a[i][p]) > Math.abs(a[max][p])) { max = i; } } // muda aposicao da linha p com a linha max swap(p, max,a); // singular ou quase singular if (Math.abs(a[p][p]) <= EPSILON) { continue; // throw new // RuntimeException("A Matriz e singular ou quase singular"); } // pivota pivota(p, p,numCol2,a);//n*n*n } for (int i = 0; i < numCol2; i++){ matriz2[i]=a[i][6]; for (int j = 0; j < numCol2; j++) matrizx[i][j] = a[i][j]; } System.out.println(); } // executa o pivoteamento em (p, q) usando Eliminacao Gauss-Jordan private static void pivota(int p, int q,int N, double a[][]) { // altera tudo, menos linha p e coluna q for (int i = 0; i < N; i++) {//n double alpha = a[i][q] / a[p][q]; for (int j = 0; j <= N + N; j++) {//n*n if (i != p && j != q) a[i][j] -= alpha * a[p][j];
  • 14. } } // zera a coluna q for (int i = 0; i < N; i++) if (i != p) a[i][q] = 0.0; // escala a linha p for (int j = 0; j <= N + N; j++) if (j != q) a[p][j] /= a[p][q]; a[p][q] = 1.0; } 3.4. M´etodo de Crout Este algoritmo consiste em fazer a fatorac¸˜ao da A em LU, sendo que L ´e triangular inferior e U ´e triangular superior unit´aria. Abaixo inclu´ımos o c´odigo utilizado para processar computacionalmente essa operac¸˜ao. public static void TransformaTraingularLU(Double[][] matriz, int numLin, int numCol, Double[][] matrizL,Double[][] matrizU) { /* * Decomposi o de A em L e U * * L * |R 0 0| * |R R 0| * |R R R| * * U * |1 R R| * |0 1 R| * |0 0 1| * * * */ int i, j, k; double sum = 0; for (int linha = 0; linha < numLin; linha++) { for (int coluna = 0; coluna < numCol; coluna++) { if (linha == coluna) { matrizU[linha][coluna] = 1.0;
  • 15. } else { matrizU[linha][coluna] = 0.0; } } } for (j = 0; j < numLin; j++) { for (i = j; i < numCol; i++) { sum = 0; for (k = 0; k < j; k++) { sum = sum + matrizL[i][k].floatValue() * matrizU[k][j].floatValue(); } matrizL[i][j] = matriz[i][j].floatValue() - sum; } for (i = j; i < numCol; i++) { sum = 0; for(k = 0; k < j; k++) { sum = sum + matrizL[j][k].floatValue() * matrizU[k][i].floatValue(); } if (matrizL[j][j] == 0) { System.out.printf("t Foi encontrada uma divizao por zero que impossibilita a e x e c u o desse metodo."); } else{ matrizU[j][i] = (matriz[j][i].floatValue() - sum) / matrizL[j][j].floatValue(); } } } } public static void DecompoeLemDL(Double[][] matriz, int numLin, int numCol, Double[][] matrizx) {
  • 16. /* * L*matrizy = b (matrizx) * Calcula L[m,n]/D[x,y] = L’ sendo que x=y * * L * |R 0 0| * |R R 0| * |R R R| * * <=> * * L’ * |1 0 0| * |R 1 0| * |R R 1| * * D * |R 0 0| * |0 R 0| * |0 0 R| * * */ for (int k = 0; k < numLin; k++) { for (int i = 0; i < numCol; i++) { matrizx[i][k] = 0.0; } } for (int p = numLin - 1; p >= 0; p--) { matrizx[p][p]=(double)matriz[p][p].floatValue(); for (int j = p; j >= 0; j--) { matriz[p][j]= (double)matriz[p][j].floatValue()/ matrizx[p][p].floatValue(); } } } 4. Conclus˜ao Podemos concluir que existem v´arias formas de processar e resolver sistemas lineares uti- lizando conceitos de ´Algebra Linear de forma computacional. O estudo visa alcanc¸ar a utilizac¸˜ao pr´atica de sistemas lineares e de matrizes, superando as limitac¸˜oes da resoluc¸˜ao manual de problemas reais e compreendendo os resultados obtidos atrav´es de sistemas computacionais. Com esse trabalho esperamos contribuir com o aprendizado da ´algebra linear computacional no curso de ciˆencias computacionais, possibilitando que esses algo- ritmos sejam utilizadas e que inspirem a elaborac¸˜ao de teses, n˜ao apenas no conte´udo de
  • 17. sistemas lineares, sua representac¸˜ao e soluc¸˜ao matricial mas tamb´em em outras situac¸˜oes onde seja poss´ıvel discutir a contribuic¸˜ao da matem´atica da soluc¸˜ao de problemas reais. 5. Apˆendice Nessa sess˜ao apresentamos os algoritmos que serviram de apoio para o desenvolvimento das operac¸˜oes com matrizes. S˜ao eles: 5.1. Impress˜ao de Matriz Essa func¸˜ao percorre todos os campos da matriz apresentando-os no log do console do programa. public static void imprimeMatriz(Double[][] matriz, int numLin, int numCol) { for (int linha = 0; linha < numLin; linha++) { for (int coluna = 0; coluna < numCol; coluna++) { System.out.printf("t %.2f t", matriz[linha][coluna]); } System.out.println(); } } 5.2. Carrega a Matriz Essa func¸˜ao carrega os campos de uma matriz que est˜ao armazenados em um arquivo texto para uma array de Double. Essa func¸˜ao foi desenvolvida para facilitar o processo de carga da matriz. public static String carregaMatriz(Double[][] matriz, String nomeArquivo) { Scanner arquivo; String linCol = ""; try { arquivo = new Scanner(new File(nomeArquivo)); int j = 0; int i = 0; while (arquivo.hasNextLine()) { String line = arquivo.nextLine(); Scanner scanner = new Scanner(line); scanner.useDelimiter(","); j = 0; while (scanner.hasNextDouble()) { matriz[i][j] = scanner.nextDouble(); j++; } scanner.close(); i++;
  • 18. } arquivo.close(); linCol = Integer.toString(i) + "," + Integer.toString(j); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } return linCol; } Referˆencias ANTON, H. & BUSBY, R. (2006). Algebra Linear Contemporˆanea. BOOKMAN COM- PANHIA EDITORA, 1th edition. RUGGIERO, M.G. & LOPES, V. (1996). C´alculo num´erico – aspectos computacionais.