Algebra linear operações com matrizes

Algebra Linear - Operacoes com MatrizesFelipe Schimith Batista1

1Instituto de Matematica e Estatısitica - Universidade Estadual do Rio de Janeiro

[email protected]

Resumo. O trabalho visa contextualizar os teoremas e metodos da Algebra Li-near aplicados em solucoes computacionais. Este trabalho apresenta o refe-rencial teorico utilizado como base para resolver computacionalmente sistemaslineares. Apresentaremos a ”Decomposicao A=LU”fazendo uma comparacaocom a decomposicao de Gauss, a ”Decomposicao A=LDU”comparando-a como metodo de Crout. Por fim apresentamos o ”Metodo de Gauss-Jordan”queobtem a inversa de uma matriz. A implementacao foi feita na linguagem deprogramacao Java e tambem sera documentada e comentada.

1. IntroducaoNa Matematica a teoria de sistemas lineares e a base e uma parte fundamental da algebralinear, um tema que e usado na maior parte da matematica moderna. Deve-se observarque, em primeiro lugar, a equacao linear e, necessariamente, uma equacao polinomial.Tambem na matematica aplicada, podemos encontrar varios usos de sistemas lineares.Exemplos sao a fısica, a economia, a engenharia, a biologia, a geografia, a navegacao,a aviacao, a cartografia, a demografia e a astronomia.[RUGGIERO 1996] Um sistemade equacoes lineares e um conjunto finito de equacoes lineares aplicadas num mesmoconjunto, igualmente finito, de variaveis.[ANTON 2006]

Algoritmos computacionais sao, por encontrar as solucoes, uma parte importanteda algebra linear numerica. Voltando na historia da algebra linear, uma versao preliminarda eliminacao gaussiana apareceu pela primeira vez no livro chines “Nove Capıtulos deArte Matematica”, em torno de 200 a.C.

O poder do metodo nao tinha sido reconhecido ate que o grande matematico CarlFriedich Gauss no ano de 1801 utilizou o metodo para calcular a orbita do asteroide Cerescom pouquıssimas informacoes utilizando mınimos quadrados e o procedimento que hojedenominamos eliminacao gaussiana. O trabalho de Gauss causou sensacao quando Ceresreapareceu na constelacao de Virgem, local aproximado aos seus calculos.[ANTON 2006]

Mais tarde o metodo foi popularizado quando Willian Jordan (engenheiro alemao)em 1888 publicou no seu livro de geodesia intitulado “Handbuch der Vermessungskunde”.

Embora as ideias tenham sido conhecidas antes, muitas vezes o credito pelapopularizacao da decomposicao LU e atribuıda ao logico e matematico britanico AlanTuring, pelo seu trabalho de 1948 nesse assunto.

Ao final dos anos 1970, a Fundacao Nacional de Ciencias e o Departamento deEnergia dos EUA financiaram o desenvolvimento de rotinas de computacionais para in-verter matrizes e resolver sistemas de equacoes lineares. Aquela pesquisa levou a umconjunto de programas Fortran chamado LINPAC que sao uma referencia para muitosalgoritmos computacionais de hoje, inclusive no MATLAB. As rotinas LIMPAC estao

organizadas em torno de quatro fatoracoes de matrizes, uma das quais e a decomposicaoLU. C.B. Moler, J.J. Dongarra, G.W. Stewart e J.R. Brunch, os principais programadoresdo LINPAC, basearam muitas de suas ideias no trabalho de Jemes Boyle e Kenneth Dritz,do Laboratorio Argonne (nos EUA).[ANTON 2006]

2. Teoria de MatrizesEste capıtulo tem como objetivo apresentar as propriedades, teoremas e metodos daAlgebra Linear que foram usados como base para implementar solucoes computacionaispara resolver equacoes lineares utilizando matrizes.

2.1. Resolucao de Sistemas Lineares

Antes de nos aprofundarmos nas operacoes com matrizes, e necessario entender os con-ceitos e metodos das operacoes elementares de um sistema linear que podemos imple-mentar para encontrar as solucoes computacionalmente. Por exemplo, um metodo pararesolver um sistema linear e substituir o sistema inicial por outro que tenha o mesmo con-junto solucao do primeiro, mas que seja muito mais facil de resolver. O novo sistema eobtido apos a aplicacao de uma serie de operacoes que simplificam as equacoes do sistemaque tem a propriedade especial de nao alterar o conjunto solucao.

Estas operacoes sao chamadas operacoes elementares e sao de tres tipos diferentes.

• Trocar duas equacoes do sistema de posicao.• Substituir uma equacao pela mesma equacao multiplicada por um escalar diferente

de 0.• Substituir uma equacao pela mesma equacao somada a outra equacao multiplicada

por um escalar.

Note que se multiplicarmos uma equacao por 0, estaremos excluindo esta equacaodo sistema, o que tem o efeito provavel de aumentar o conjunto solucao, por isso,esta nao e uma operacao elementar. E facil ver que ao efetuarmos qualquer uma dasoperacoes acima sobre as equacoes do sistema, nao estaremos acrescentando nem dimi-nuindo solucoes.

Somente os coeficientes do sistema sao alterados atraves das operacoes elemen-tares, as variaveis permanecem inalteradas. Portanto, na hora de efetuar os calculos, aoinves de considerar todo o sistema, podemos considerar apenas a matriz de coeficientesdo sistema, chamada matriz aumentada:

[A|B] =

∣∣∣∣∣∣∣∣∣∣α11 α12 ... α1n β1α21 α22 ... α2n β2α31 α32 ... α3n β3... ... ... ...αm1 αm2 ... αmn βm

∣∣∣∣∣∣∣∣∣∣As operacoes elementares serao efetuadas sobre as linhas desta matriz.

Definicao. Operacoes Elementares sobre as linhas de uma matriz:

• a troca da posicao relativa de duas linhasLi ← Lj

• a multiplicacao de uma linha por uma constanteLi ← cLj ⇔ c 6= 0• a substituicao de uma linha pela sua soma com outra linha qualquerLi ← Li + Lj

Teorema. Se dois sistemas lineares Ax = B e Cx = D sao tais que a matriz aumentada[C|D] e obtida de [A|B] aplicando-se operacoes elementares, entao os dois sistemas pos-suem as mesmas solucoes. Sistemas que possuem as mesmas solucoes sao chamadossistemas equivalentes.

2.2. Decomposicao A=LU

A decomposicao LU de uma matriz A surge da necessidade de resolver um conjunto desistemas do tipo Ax = b1, Ax = b2, Ax = b3 e assim por diante. Poderıamos resolver cadaum desses sistemas escalonando a matriz completa [A b] correspondente ate sua formaescalonada reduzida mas, computacionalmente, o escalonamento e um processo muitodemorado e poderıamos ter centenas de b’s para resolver.

Supondo-se que A seja uma matriz mxm que pode ser escalonada ate sua formareduzida 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 possuiapenas 1’s e U Upper e uma matriz triangular superior mxm que nada mais e do que apropria forma escalonada reduzida de A.

Para uma matriz 3x3: A = L*Ua11 a12 a13a21 a22 a23a31 a32 a33

=

1 0 0l21 1 0l31 l32 1

∗u11 u12 u13

0 u22 u230 0 u33

A importancia de escrevermos uma matriz como o produto de duas outras matrizes

triangulares, uma inferior e a outra superior, se da pelo fato de que, ao assumirmos queA = LU, podemos reescrever a equacao Ax = b como LUx = B ou, pela propriedadeassociativa, L(Ux) = B. Tomando-se Ux = y, temos Ly = b e Ux = y. Resolvendo-sea primeira equacao para y e a segunda para x, obteremos a resposta procurada de umamaneira bem mais simples do que fazer pelo metodo tradicional, visto que as matrizessao triangulares.

Vale lembrar que quando um pivo nulo e encontrado temos um caso onde pode ounao existir uma decomposicao LU.

2.2.1. Comparando eliminacao gaussiana com decomposicao LU

Para determinacao das incognitas, o metodo da eliminacao de Gauss desenvolve duas fa-ses: a primeira e a eliminacao progressiva, onde reduz o numero de variaveis ao longoda execucao para, entao, aplicar a segunda fase, chamada de substituicao regressiva, ondeutiliza o resultado da primeira para determinar a solucao geral do sistema. Dois passosdescritos, o primeiro e o que consome mais tempo de calculo, uma vez que e nesta faseque consiste o maior numero de operacoes aritmeticas e de trocas dedados.Por isso, encontrar um metodo que minimize esta fase crıtica implica em aumentar o

desempenho para realizar a tarefa de resolucao de sistemas lineares. Os metodos dedecomposicao LU consistem em separar a fase de eliminacao da matriz dos coeficien-tes, que consomem maior tempo, das manipulacoes envolvidas com o vetor dos termosindependentes.Portanto, devemos deixar claro que, ao contrario da eliminacao de Gauss, umadecomposicao de LU e uma estrategia de melhoria na resolucao de sistemas lineares.Sendo assim, nao existe “o metodo” de decomposicao LU, mas sim algumas abordagensa serem tomadas que permitem decompor o sistema. Uma implicacao interessante dissoe que a propria eliminacao de Gauss pode ser descrita como uma decomposicao LU.

O custo de processamento do algoritmo de decomposicao LU pode ser visto pelonumero de estruturas de repeticao utilizados no codigo. No codigo implementado, o custoe da Ordem(n3) para a decomposicao 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*nmatrizL[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*nmatriz[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 deeliminacao Gaussiana pode ser visto pelo numero de estruturas de repeticao utilizados nocodigo. No codigo 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, intnumLin2, int numCol2,Double[][] matrizx) {

double calculo;for (int coluna = 0; coluna < numLin2; coluna++) {\\n

for (int linha = coluna + 1; linha < numLin2;

linha++) {\\n*ncalculo =

(matriz[linha][coluna].floatValue() /matriz[coluna][coluna].floatValue());

matriz[linha][coluna]=0.0;for(int s=coluna+1; s <numLin2;

s++){\\n*n*nmatriz[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 decomposicao LU e identicoao custo da Eliminacao Gaussiana.

2.3. Decomposicao A=LDU

A Decomposicao A=LDU tambem e utilizada para solucao de sistemas lineares, que con-siste em efetuar a decomposicao da matriz A em tres componentes L Lower, D Diagonale U Upper a soma dos elementos correspondentes.

A decomposicao A = LDU permite resolver um sistema Ax = b em tres passos:

• achar c de Lc = b• achar z de Dz = c• achar x de Ux = z

A decomposicao LDU e unica e permite flexibilidade para o calculo pratico dasmatrizes L e U. Por exemplo, isto acontece com a reducao de Crout, na qual considera-seLD como sendo uma matriz triangular inferior L (sem elementos unitarios na sua diago-nal) de modo que A = LU com U triangular superior e elementos unitarios na sua diagonal.Esta reducao permite calcular alternadamente as colunas de L e de U.

O processo consiste em obter primeiramente a fatoracao LU, e depois decom-pondo a matriz U no produto de uma matriz D, com uma matriz que tambem se designapor U, onde:

• D e uma matriz m x m diagonal cujos elementos da diagonal principal sao os pivosda eliminacao de Gauss ou zero no caso de nao haver pivo;• U e uma matriz m x m obtida apos eliminacao de Gauss, dividindo cada linha pelo

respectivo pivo.

Para uma matriz 3x3: A=LDU

a11 a12 a13a21 a22 a23a31 a32 a33

=

1 0 0l21 1 0l31 l32 1

∗d11 0 0

0 d22 00 0 d33

∗1 u12 u130 1 u230 0 1

Quando um pivo nulo e encontrado temos um caso onde pode ou nao existir uma

decomposicao LU. A decomposicao LU nao e unica, ja a decomposicao LDU por sua veze unica.

2.3.1. Comparacao da decomposicao LDU e Crout

Para compararmos LDU com Crout primeiro precisamos de fazer uma pequenaapresentacao de Crout que e uma variante da fatoracao triangular da matriz A. Toma-se amatriz U como triangular de diagonal unitaria e L como triangular inferior.a11 a12 a13

a21 a22 a23a31 a32 a33

=

l11 0 0l21 l22 0l31 l32 l33

∗1 u12 u130 1 u230 0 1

Como falado anteriormente a decomposicao LDU consiste numa pequena alteracao dafatoracao de Crout e tem a vantagem de atribuir as matrizes triangulares L e U um papeltotalmente identico. Consiste em considerar que estas sao ambas matrizes triangularescom diagonal unitaria e tomar a fatoracao na seguinte forma A = LDU em que D e umamatriz diagonal.

O custo de processamento do algoritmo de decomposicao LDU pode ser visto pelonumero de estruturas de repeticao utilizados no codigo. No codigo implementado, o custoe da Ordem (n3) para a decomposicao de A em LU e n2 para decomposicao de U em DU’.Resumindo podemos concluir que a decomposicao 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





}}

}}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*nmatrizx[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 tambem pode ser visto pelonumero de estruturas de repeticao utilizados no codigo. No codigo implementado, o custoe n3 para a decomposicao de A em LU e n2 para decomposicao de L em DL’.


int numCol, Double[][] matrizL,Double[][] matrizU){


* */int i, j, k;double sum = 0;

for (int linha = 0; linha < numLin; linha++) {//nfor (int coluna = 0; coluna < numCol; coluna++)

{//n*nif (linha == coluna) {

matrizU[linha][coluna] = 1.0;} else {

matrizU[linha][coluna] = 0.0;}

}}

for (j = 0; j < numLin; j++) {//nfor (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*nsum = 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 Foiencontrada uma divizao por zeroque impossibilita a execucaodesse metodo.");

}else{

matrizU[j][i] =(matriz[j][i].floatValue() -sum) /matrizL[j][j].floatValue();

}}

}}

public static void DecompoeLemDL(Double[][] matriz, intnumLin,

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++) { //nfor (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


}}}

Avaliando os algoritmos implementados podemos concluir que o algoritmode Crout tem o custo O(n3) o que o torna praticamente identico ao algoritmo dedecomposicao LDU o custo e da Ordem(n3).

2.4. Metodo de Gauss-Jordan

O metodo de Gauss-Jordan e um metodo de escalonamento que consiste em aplicaroperacoes elementares a matriz aumentada de um sistema, ate que ela esteja na formaescalonada reduzida. A vantagem deste processo e que um sistema cuja matriz aumentadae uma matriz na forma escalonada reduzida tem solucao imediata, enquanto que pararesolver um sistema que esta apenas na forma escalonada ainda e necessario fazer umaserie de substituicoes para obter a solucao final.

• O primeiro elemento nao-nulo de cada linha nao-nula (chamado o pivo da linha)e igual a 1.• O pivo da linha i + 1 ocorre a direita do pivo da linha i.• Se uma coluna contem um pivo, entao todas os outros elementos desta coluna sao

iguais a 0.• Todas as linhas nulas ocorrem abaixo das linhas nao-nulas.

As etapas para resolver um sistemas de equacoes utilizando a eliminacao deGauss-Jordan e descrito a seguir.

1. Escreva a matriz aumentada do sistema.2. Use as operacoes lineares para transformar a matriz aumentada na forma descrita

abaixo, que e chamado de forma escalonada reduzida de linha.(a) Em cada linha que nao consiste inteiramente em zeros, o elemento dife-

rente de zero mais a esquerda e o pivo.(b) Cada coluna que contem um pivo tem zeros em todas as outras entradas.(c) O pivo em qualquer linha esta a esquerda de qualquer pivo nas linhas

abaixo dele.(d) ) Caso existam linhas que consistem inteiramente de zeros, elas sao agru-

padas em conjunto na parte inferior da matriz.3. Ao atingir o resultado descrito no processo 2, se voce obter uma linha cujos ele-

mentos sao todos os zeros, exceto a ultima a direita. Nesse caso, o sistema einconsistente e nao tem solucoes. Caso contrario, as solucoes do sistema estao namatriz final.

Avaliando os algoritmos implementados podemos concluir que o algoritmo deGauss-Jordan tem o custo na Ordem(n3) o que o torna praticamente identico ao custo doalgoritmo de decomposicao LDU e ao custo do Metodo de Crout avaliados nesse artigo.

3. AlgoritmosEste capıtulo apresenta os algoritmos desenvolvidos utilizando como base os conheci-mentos adquiridos na algebra linear. Algumas funcoes secundarias como obtencao dasmatrizes a partir de arquivos textos e funcao de impressao de matrizes foram omitidas dosprogramas. Focarmos a apresentacao nas partes essenciais de processamento de matrizes.

3.1. Decomposicao A=LU

Este algoritmo consiste em fazer a fatoracao da A em LU. Abaixo incluımos o codigoutilizado para processar computacionalmente essa operacao.



** 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





}}

}

}

3.2. Decomposicao A=LDU

Este algoritmo consiste em fazer a fatoracao da A em LU, depois fatorar U para obter DU’.Abaixo incluımos o codigo utilizado para processar computacionalmente essa operacao.



** 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





}}

}}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*nmatrizx[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();}

}}

3.3. Metodo de Gauss-Jordan

Este algoritmo consiste em aplicar operacoes elementares a matriz aumentada de um sis-tema, ate que ela esteja na forma escalonada reduzida. Abaixo incluımos o codigo utili-zado para processar computacionalmente essa operacao.

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 matriza = new double[numCol2][numCol2 + numCol2 + 1];for (int i = 0; i < numCol2; i++)//n

for (int j = 0; j < numCol2; j++)//n*na[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];

// Elimina o de Gauss-Jordanfor (int p = 0; p < numCol2; p++) {//n

// busca a linha do pivo usando pivoteamentoparcial

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 maxswap(p, max,a);

// singular ou quase singularif (Math.abs(a[p][p]) <= EPSILON) {

continue;// throw new// RuntimeException("A Matriz e singular

ou quase singular");}

// pivotapivota(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 EliminacaoGauss-Jordan

private static void pivota(int p, int q,int N, doublea[][]) {

// altera tudo, menos linha p e coluna qfor (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 qfor (int i = 0; i < N; i++)

if (i != p)a[i][q] = 0.0;

// escala a linha pfor (int j = 0; j <= N + N; j++)

if (j != q)a[p][j] /= a[p][q];

a[p][q] = 1.0;}

3.4. Metodo de Crout

Este algoritmo consiste em fazer a fatoracao da A em LU, sendo que L e triangularinferior e U e triangular superior unitaria. Abaixo incluımos o codigo utilizado paraprocessar computacionalmente essa operacao.


int numCol, Double[][] matrizL,Double[][] matrizU){


** 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 Foiencontrada uma divizao por zeroque impossibilita a e x e c u odesse metodo.");

}else{

matrizU[j][i] =(matriz[j][i].floatValue() -sum) /matrizL[j][j].floatValue();

}}

}}

public static void DecompoeLemDL(Double[][] matriz, intnumLin,

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--) {


}}}

4. Conclusao

Podemos concluir que existem varias formas de processar e resolver sistemas lineares uti-lizando conceitos de Algebra Linear de forma computacional. O estudo visa alcancar autilizacao pratica de sistemas lineares e de matrizes, superando as limitacoes da resolucaomanual de problemas reais e compreendendo os resultados obtidos atraves de sistemascomputacionais. Com esse trabalho esperamos contribuir com o aprendizado da algebralinear computacional no curso de ciencias computacionais, possibilitando que esses algo-ritmos sejam utilizadas e que inspirem a elaboracao de teses, nao apenas no conteudo de

sistemas lineares, sua representacao e solucao matricial mas tambem em outras situacoesonde seja possıvel discutir a contribuicao da matematica da solucao de problemas reais.

5. ApendiceNessa sessao apresentamos os algoritmos que serviram de apoio para o desenvolvimentodas operacoes com matrizes. Sao eles:

5.1. Impressao de Matriz

Essa funcao percorre todos os campos da matriz apresentando-os no log do console doprograma.

public static void imprimeMatriz(Double[][] matriz, intnumLin, 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 funcao carrega os campos de uma matriz que estao armazenados em um arquivotexto para uma array de Double. Essa funcao foi desenvolvida para facilitar o processo decarga 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 blocke.printStackTrace();

}return linCol;}

ReferenciasANTON, H. & BUSBY, R. (2006). Algebra Linear Contemporanea. BOOKMAN COM-

PANHIA EDITORA, 1th edition.

RUGGIERO, M.G. & LOPES, V. (1996). Calculo numerico – aspectos computacionais.

Software

Algebra linear operações com matrizes