Algebra linear operações com matrizes

Álgebra Linear - Operações com Matrizes
Felipe Schimith Batista1
1
Instituto de Matemática e Estat´ısitica - Universidade Estadual do Rio de Janeiro
felipeschimith@gmail.com
Resumo. O trabalho visa contextualizar os teoremas e métodos da Álgebra Li-
near aplicados em soluções computacionais. Este trabalho apresenta o refe-
rencial teórico utilizado como base para resolver computacionalmente sistemas
lineares. Apresentaremos a ”Decomposição A=LU”fazendo uma comparação
com a decomposição de Gauss, a ”Decomposição A=LDU”comparando-a com
o método de Crout. Por fim apresentamos o ”Método de Gauss-Jordan”que
obtém a inversa de uma matriz. A implementação foi feita na linguagem de
programação Java e também será documentada e comentada.
1. Introdução
Na Matemática a teoria de sistemas lineares é a base e uma parte fundamental da álgebra
linear, um tema que é usado na maior parte da matemática moderna. Deve-se observar
que, em primeiro lugar, a equação linear é, necessariamente, uma equação polinomial.
Também na matemática aplicada, podemos encontrar vários usos de sistemas lineares.
Exemplos são a f´ısica, a economia, a engenharia, a biologia, a geografia, a navegação,
a aviação, a cartografia, a demografia e a astronomia.[RUGGIERO 1996] Um sistema
de equações lineares é um conjunto finito de equações lineares aplicadas num mesmo
conjunto, igualmente finito, de variáveis.[ANTON 2006]
Algoritmos computacionais são, por encontrar as soluções, uma parte importante
da álgebra linear numérica. Voltando na história da álgebra linear, uma versão preliminar
da eliminação gaussiana apareceu pela primeira vez no livro chinês “Nove Cap´ıtulos de
Arte Matemática”, em torno de 200 a.C.
O poder do método não tinha sido reconhecido até que o grande matemático Carl
Friedich Gauss no ano de 1801 utilizou o método para calcular a órbita do asteroide Ceres
com pouqu´ıssimas informações utilizando m´ınimos quadrados e o procedimento que hoje
denominamos eliminação gaussiana. O trabalho de Gauss causou sensação quando Ceres
reapareceu na constelação de Virgem, local aproximado aos seus cálculos.[ANTON 2006]
Mais tarde o método foi popularizado quando Willian Jordan (engenheiro alemão)
em 1888 publicou no seu livro de geodésia intitulado “Handbuch der Vermessungskunde”.
Embora as ideias tenham sido conhecidas antes, muitas vezes o crédito pela
popularização da decomposição LU é atribu´ıda ao lógico e matemático britânico Alan
Turing, pelo seu trabalho de 1948 nesse assunto.
Ao final dos anos 1970, a Fundação Nacional de Ciências e o Departamento de
Energia dos EUA financiaram o desenvolvimento de rotinas de computacionais para in-
verter matrizes e resolver sistemas de equações lineares. Aquela pesquisa levou a um
conjunto de programas Fortran chamado LINPAC que são uma referência para muitos
algoritmos computacionais de hoje, inclusive no MATLAB. As rotinas LIMPAC estão

organizadas em torno de quatro fatorações de matrizes, uma das quais é a decomposição
LU. C.B. Moler, J.J. Dongarra, G.W. Stewart e J.R. Brunch, os principais programadores
do LINPAC, basearam muitas de suas idéias no trabalho de Jemes Boyle e Kenneth Dritz,
do Laboratório Argonne (nos EUA).[ANTON 2006]
2. Teoria de Matrizes
Este cap´ıtulo tem como objetivo apresentar as propriedades, teoremas e métodos da
Álgebra Linear que foram usados como base para implementar soluções computacionais
para resolver equações lineares utilizando matrizes.
2.1. Resolução de Sistemas Lineares
Antes de nos aprofundarmos nas operações com matrizes, é necessário entender os con-
ceitos e métodos das operações elementares de um sistema linear que podemos imple-
mentar para encontrar as soluções computacionalmente. Por exemplo, um método para
resolver um sistema linear é substituir o sistema inicial por outro que tenha o mesmo con-
junto solução do primeiro, mas que seja muito mais fácil de resolver. O novo sistema é
obtido após a aplicação de uma série de operações que simplificam as equações do sistema
que têm a propriedade especial de não alterar o conjunto solução.
Estas operações são chamadas operações elementares e são de três tipos diferentes.
• Trocar duas equações do sistema de posição.
• Substituir uma equação pela mesma equação multiplicada por um escalar diferente
de 0.
• Substituir uma equação pela mesma equação somada a outra equação multiplicada
por um escalar.
Note que se multiplicarmos uma equação por 0, estaremos excluindo esta equação
do sistema, o que tem o efeito provável de aumentar o conjunto solução, por isso,
esta não é uma operação elementar. É fácil ver que ao efetuarmos qualquer uma das
operações acima sobre as equações do sistema, não estaremos acrescentando nem dimi-
nuindo soluções.
Somente os coeficientes do sistema são alterados através das operações elemen-
tares, as variáveis permanecem inalteradas. Portanto, na hora de efetuar os cálculos, ao
invés 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 operações elementares serão efetuadas sobre as linhas desta matriz.
Definição. Operações Elementares sobre as linhas de uma matriz:
• a troca da posição relativa de duas linhas
Li ← Lj

• a multiplicação de uma linha por uma constante
Li ← cLj ⇔ c = 0
• a substituição de uma linha pela sua soma com outra linha qualquer
Li ← Li + Lj
Teorema. Se dois sistemas lineares Ax = B e Cx = D são tais que a matriz aumentada
[C|D] é obtida de [A|B] aplicando-se operações elementares, então os dois sistemas pos-
suem as mesmas soluções. Sistemas que possuem as mesmas soluções são chamados
sistemas equivalentes.
2.2. Decomposição A=LU
A decomposição 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é sua forma
escalonada reduzida mas, computacionalmente, o escalonamento é 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é sua forma
reduzida sem trocar linhas, a Álgebra Linear nos diz que ela pode ser escrita na forma A
= LU, onde L Lower é uma matriz triangular inferior mxm cuja diagonal principal possui
apenas 1’s e U Upper é uma matriz triangular superior mxm que nada mais é do que a
própria 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ância de escrevermos uma matriz como o produto de duas outras matrizes
triangulares, uma inferior e a outra superior, se dá pelo fato de que, ao assumirmos que
A = LU, podemos reescrever a equação 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 equação para y e a segunda para x, obteremos a resposta procurada de uma
maneira bem mais simples do que fazer pelo método tradicional, visto que as matrizes
são triangulares.
Vale lembrar que quando um pivô nulo é encontrado temos um caso onde pode ou
não existir uma decomposição LU.
2.2.1. Comparando eliminação gaussiana com decomposição LU
Para determinação das incógnitas, o método da eliminação de Gauss desenvolve duas fa-
ses: a primeira é a eliminação progressiva, onde reduz o número de variáveis ao longo
da execução para, então, aplicar a segunda fase, chamada de substituição regressiva, onde
utiliza o resultado da primeira para determinar a solução geral do sistema. Dois passos
descritos, o primeiro é o que consome mais tempo de cálculo, uma vez que é nesta fase
que consiste o maior número de operações aritméticas e de trocas dedados.
Por isso, encontrar um método que minimize esta fase cr´ıtica implica em aumentar o

desempenho para realizar a tarefa de resolução de sistemas lineares. Os métodos de
decomposição LU consistem em separar a fase de eliminação da matriz dos coeficien-
tes, que consomem maior tempo, das manipulações envolvidas com o vetor dos termos
independentes.
Portanto, devemos deixar claro que, ao contrário da eliminação de Gauss, uma
decomposição de LU é uma estratégia de melhoria na resolução de sistemas lineares.
Sendo assim, não existe “o método” de decomposição LU, mas sim algumas abordagens
a serem tomadas que permitem decompor o sistema. Uma implicação interessante disso
é que a própria eliminação de Gauss pode ser descrita como uma decomposição LU.
O custo de processamento do algoritmo de decomposição LU pode ser visto pelo
número de estruturas de repetição utilizados no código. No código implementado, o custo
é da Ordem(n3
) para a decomposição 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
eliminação Gaussiana pode ser visto pelo número de estruturas de repetição utilizados no
código. No código implementado no trabalho anterior, o custo é 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 decomposição LU é idêntico
ao custo da Eliminação Gaussiana.
2.3. Decomposição A=LDU
A Decomposição A=LDU também é utilizada para solução de sistemas lineares, que con-
siste em efetuar a decomposição da matriz A em três componentes L Lower, D Diagonal
e U Upper a soma dos elementos correspondentes.
A decomposição A = LDU permite resolver um sistema Ax = b em três passos:
• achar c de Lc = b
• achar z de Dz = c
• achar x de Ux = z
A decomposição LDU é única e permite flexibilidade para o cálculo prático das
matrizes L e U. Por exemplo, isto acontece com a redução de Crout, na qual considera-se
LD como sendo uma matriz triangular inferior L (sem elementos unitários na sua diago-
nal) de modo que A = LU com U triangular superior e elementos unitários na sua diagonal.
Esta redução permite calcular alternadamente as colunas de L e de U.
O processo consiste em obter primeiramente a fatoração LU, e depois decom-
pondo a matriz U no produto de uma matriz D, com uma matriz que também se designa
por U, onde:
• D é uma matriz m x m diagonal cujos elementos da diagonal principal são os pivos
da eliminação de Gauss ou zero no caso de não haver pivô;
• U é uma matriz m x m obtida apos eliminação 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ô nulo é encontrado temos um caso onde pode ou não existir uma
decomposição LU. A decomposição LU não é única, já a decomposição LDU por sua vez
é única.
2.3.1. Comparação da decomposição LDU e Crout
Para compararmos LDU com Crout primeiro precisamos de fazer uma pequena
apresentação de Crout que é uma variante da fatoração triangular da matriz A. Toma-se a
matriz U como triangular de diagonal unitária 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 decomposição LDU consiste numa pequena alteração da
fatoração de Crout e tem a vantagem de atribuir às matrizes triangulares L e U um papel
totalmente idêntico. Consiste em considerar que estas são ambas matrizes triangulares
com diagonal unitária e tomar a fatoração na seguinte forma A = LDU em que D é uma
matriz diagonal.
O custo de processamento do algoritmo de decomposição LDU pode ser visto pelo
é da Ordem (n3
) para a decomposição de A em LU e n2
para decomposição de U em DU’.
Resumindo podemos concluir que a decomposição LDU tem o custo é da Ordem(n3
).
public static void TransformaTraingularLU(Double[][]
matriz, int numLin,
int numCol, Double[][] matrizL) {
/*
* */
matriz[i][k] = 0.0;
{//n*n*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*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ém pode ser visto pelo
é n3
para a decomposição de A em LU e n2
para decomposição de L em DL’.
matriz, int numLin,
int numCol, Double[][] matrizL,Double[][] matrizU)
{
/*
* */
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 {
}
}
}

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 i = 0; i < numCol; i++) {//n*n

}
}
for (int p = numLin - 1; p >= 0; p--) {//n
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êntico ao algoritmo de
decomposição LDU o custo é da Ordem(n3
).
2.4. Método de Gauss-Jordan
O método de Gauss-Jordan é um método de escalonamento que consiste em aplicar
operações elementares à matriz aumentada de um sistema, até que ela esteja na forma
escalonada reduzida. A vantagem deste processo é que um sistema cuja matriz aumentada
é uma matriz na forma escalonada reduzida tem solução imediata, enquanto que para
resolver um sistema que está apenas na forma escalonada ainda é necessário fazer uma
série de substituições para obter a solução final.
• O primeiro elemento não-nulo de cada linha não-nula (chamado o pivô da linha)
é igual a 1.
• O pivô da linha i + 1 ocorre à direita do pivô da linha i.
• Se uma coluna contém um pivô, então todas os outros elementos desta coluna são
iguais a 0.
• Todas as linhas nulas ocorrem abaixo das linhas não-nulas.
As etapas para resolver um sistemas de equações utilizando a eliminação de
Gauss-Jordan é descrito a seguir.
1. Escreva a matriz aumentada do sistema.
2. Use as operações lineares para transformar a matriz aumentada na forma descrita
abaixo, que é chamado de forma escalonada reduzida de linha.
(a) Em cada linha que não consiste inteiramente em zeros, o elemento dife-
rente de zero mais à esquerda é o pivô.
(b) Cada coluna que contém um pivô tem zeros em todas as outras entradas.
(c) O pivô em qualquer linha está à esquerda de qualquer pivô nas linhas
abaixo dele.
(d) ) Caso existam linhas que consistem inteiramente de zeros, elas são agru-
padas em conjunto na parte inferior da matriz.
3. Ao atingir o resultado descrito no processo 2, se você obter uma linha cujos ele-
mentos são todos os zeros, exceto a última à direita. Nesse caso, o sistema é
inconsistente e não tem soluções. Caso contrário, as soluções do sistema estão 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êntico ao custo do
algoritmo de decomposição LDU e ao custo do Método de Crout avaliados nesse artigo.
3. Algoritmos
Este cap´ıtulo apresenta os algoritmos desenvolvidos utilizando como base os conheci-
mentos adquiridos na álgebra linear. Algumas funções secundárias como obtenção das
matrizes a partir de arquivos textos e função de impressão de matrizes foram omitidas dos
programas. Focarmos a apresentação nas partes essenciais de processamento de matrizes.
3.1. Decomposição A=LU
Este algoritmo consiste em fazer a fatoração da A em LU. Abaixo inclu´ımos o código
utilizado para processar computacionalmente essa operação.
matriz, int numLin,
/*
*
* L
* |1 0 0|
* |R 1 0|
* |R R 1|
*
* U
* |R R R|
* |0 R R|
* |0 0 R|
*
* */
matriz[i][k] = 0.0;
{//n*n*n
}
}
}

}
3.2. Decomposição A=LDU
Este algoritmo consiste em fazer a fatoração da A em LU, depois fatorar U para obter DU’.
Abaixo inclu´ımos o código utilizado para processar computacionalmente essa operação.
matriz, int numLin,
/*
*
* L
* |1 0 0|
* |R 1 0|
* |R R 1|
*
* U
* |R R R|
* |0 R R|
* |0 0 R|
*
* */
matriz[i][k] = 0.0;
{//n*n*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*n
}
}
for (int p = numLin - 1; p >= 0; p--) {n
for (int j = p; j < numCol; j++) {n*n
matriz[p][j]=(double)matriz[p][j].floatValue()/matrizx[p][p].flo
}
}
}
3.3. Método de Gauss-Jordan
Este algoritmo consiste em aplicar operações elementares à matriz aumentada de um sis-
tema, até que ela esteja na forma escalonada reduzida. Abaixo inclu´ımos o código utili-
zado para processar computacionalmente essa operação.
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étodo de Crout
Este algoritmo consiste em fazer a fatoração da A em LU, sendo que L é triangular
inferior e U é triangular superior unitária. Abaixo inclu´ımos o código utilizado para
processar computacionalmente essa operação.
matriz, int numLin,
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) {

} else {
}
}
}
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++) {
}
}
for (int p = numLin - 1; p >= 0; p--) {
for (int j = p; j >= 0; j--) {
matriz[p][j]=
(double)matriz[p][j].floatValue()/
matrizx[p][p].floatValue();
}
}
}
4. Conclusão
Podemos concluir que existem várias formas de processar e resolver sistemas lineares uti-
lizando conceitos de Álgebra Linear de forma computacional. O estudo visa alcançar a
utilização prática de sistemas lineares e de matrizes, superando as limitações da resolução
manual de problemas reais e compreendendo os resultados obtidos através de sistemas
computacionais. Com esse trabalho esperamos contribuir com o aprendizado da álgebra
linear computacional no curso de ciências computacionais, possibilitando que esses algo-
ritmos sejam utilizadas e que inspirem a elaboração de teses, não apenas no conteúdo de

sistemas lineares, sua representação e solução matricial mas também em outras situações
onde seja poss´ıvel discutir a contribuição da matemática da solução de problemas reais.
5. Apêndice
Nessa sessão apresentamos os algoritmos que serviram de apoio para o desenvolvimento
das operações com matrizes. São eles:
5.1. Impressão de Matriz
Essa função 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 função carrega os campos de uma matriz que estão armazenados em um arquivo
texto para uma array de Double. Essa função 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ências
ANTON, H. & BUSBY, R. (2006). Algebra Linear Contemporânea. BOOKMAN COM-
PANHIA EDITORA, 1th edition.
RUGGIERO, M.G. & LOPES, V. (1996). Cálculo numérico – aspectos computacionais.

Algebra linear operações com matrizes

Mais conteúdo relacionado

Mais procurados (18)

Destaque (20)

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

Último (6)

Algebra linear operações com matrizes