SELA Mtodo da Eliminao de Gauss.

Tutorial Clculo Numrico

Tutorial 6, Rev. 1
Data: 4/9/2012

Pgina 1 de 9

SELA Me todo da Eliminaa o de

Gauss
Na Aula 4, vimos a teoria dos Sistemas de Equaes Lineares Algbricas SELA e
abordamos o primeiro mtodo direto para sua soluo. Neste Tutorial, vamos ver uma
implementao desse mtodo em C++, usando a nossa ferramenta: o Dev C++.
Para instalar o Dev C++, veja o Tutorial 1. Para criar um novo projeto, nome-lo, editlo e salv-lo, veja o Tutorial 2.

Primeiros Passos
Crie uma pasta dentro da pasta que voc reservou para a disciplina e chame-a de
EliminacaoGauss. Dentro dela crie um novo projeto do tipo console application e
tambm chame esse projeto de EliminacaoGauss. O Dev C++ vai criar para voc um
arquivo main.cpp, com uma funo main bsica dentro. Salve esse arquivo junto do
arquivo do projeto.
Vamos agora construir passo a passo o que necessrio para implementar o algoritmo
do mtodo da eliminao de Gauss para resolver o sistema visto como exemplo na
Aula 4:

a partir do seguinte pseudocdigo:

+3

+4

=5

=3

= 1

Tutorial Clculo Numrico

SELA Mtodo da Eliminao de Gauss.

Tutorial 6, Rev. 1
Data: 4/9/2012

Pgina 2 de 9

Parte A: Eliminao
FAA k=1,n-1
FAA i=k+1,n
fator = a(i,k)/a(k,k)
FAA j=k+1,n
a(i,j) = a(i,j) fator a(k,j)
FIM FAA
b(i) = b(i)- fator b(k)
a(i,k) = 0.0
FIM FAA
Algoritmo 1

FIM FAA
Parte B: Substituio retrgrada
x(n)=b(n)/a(n,n)
FAA i=n-1,1
sum = 0,0
FAA j=i+1,n
sum = sum + a(i,j) x(j)
FIM FAA
x(i) = (b(i) - sum)/a(i,i)
FIM FAA

Mo na Massa!
Vamos construir o cdigo pouco a pouco, explicando as partes.
#include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
int i, j, k, n;
int o, p;
double fator, sum;
//Declarando e inicializando a matriz do problema a ser resolvido
// | 2.0 3.0 -1.0 |
| x1 |
| 5.0 |
// | 4.0 4.0 -3.0 | x | x2 | = | 3.0 |

SELA Mtodo da Eliminao de Gauss.

Tutorial Clculo Numrico

Tutorial 6, Rev. 1
Data: 4/9/2012
// | 2.0 -3.0
double
{2.0,
double
double

Pgina 3 de 9
1.0 |

| x3 |

| -1.0 |

a[3][3]= {{2.0, 3.0, -1.0}, {4.0, 4.0, -3.0},

-3.0, 1.0}};
b[3]= {5.0, 3.0, -1.0};
x[3];

// Dimensao do problema (cuidado para aumentar/diminir aqui!)

n = 3;

Logo no comeo da funo main, declaramos as nossas variveis todas: i, j, k, n, o, p

so os inteiros que vamos usar como ndices de nossas matrizes e vetores, bem como
seus dimensionais. fator e sum so do tipo double (float de dupla preciso), usados
como auxiliares do mtodo para guardar valores intermedirios. J a, b e x so as
variveis para a matriz e os vetores do tipo real.
Note primeiro a forma como declaramos matrizes no C++: [m][n] para m linhas e n
colunas e os vetores apenas com uma dimenso [m]. Perceba tambm que a matriz A
e o vetor B foram declarados e inicializados com os valores do problema considerado
em uma nica expresso. Veja que no caso da matriz, so inicializados blocos de linhas
agrupadas, at completar a matriz inteira.
No fim, a varivel n tambm inicializada com a dimenso do problema: 3. Lembre-se
de alterar esse valor quando lidar com problemas de dimenses diferentes.
Prosseguindo...

//
//
//
//
//
//
//

Parte A: Eliminacao -----------------------------------------Nessa secao do algoritmo, fazemos uma serie de operacoes

lineares sobre a matriz (troca da ordem das equacoes,
multiplicacao de uma equacao por uma constante nao nula,
adicao de equacoes, etc.) de modo sistematico, ate que
o sistema "triangularize" e o sistema resultante possa ser
resolvido por substituicoes retroativas

for(k=0; k<=n-2; k++) // os indices comecam em zero no C++

{
for(i=k+1; i<=n-1; i++)
{
fator = a[i][k]/a[k][k];
for(j=k+1;j<=n-1;j++)

Tutorial Clculo Numrico

SELA Mtodo da Eliminao de Gauss.

Tutorial 6, Rev. 1
Data: 4/9/2012

Pgina 4 de 9

{
// transformando "A"
a[i][j] = a[i][j] - (fator * a[k][j]);
}
// transformando "b" (matriz aumentada)
b[i] = b[i] - (fator * b[k]);
//zerando antes da diagonal para formar um triang. sup.
a[i][k] = 0.0f;
}

Nessa parte A do algoritmo fazemos a eliminao. Essa eliminao consiste em

transformar a matriz aumentada (A|B) original em uma matriz equivalente triangular
superior1. Dizemos que o sistema equivalente porque essa matriz vai ser resultado
apenas de operaes lineares. como se tivssemos a mesma matriz, s que em uma
apresentao mais conveniente para depois acharmos os valores da resposta.
Se s operarmos transformaes lineares sobre a matriz aumentada, o problema
continua o mesmo e a resposta do sistema transformado igual resposta do sistema
original.
Para fazer essa transformao, esse bloco composto por trs laos aninhados: k, o
mais externo vai de 0 at n-2, ou seja, o penltimo elemento da matriz2.
Dentro do lao de k, h o lao das linhas, i, que vai de k+1 at n-1. Ou seja,
comeamos sempre na linha seguinte (quando k for 0, comeamos na linha 1, quando
k

for 1, comeamos na linha 2 e assim por diante) e vai at o fim das linhas da matriz.

Finalmente, para cada linha, h o lao das colunas, j, que vai tambm de k+1 at n-1
(da coluna seguinte at o fim da matriz).
Essa talvez seja a parte mais complexa do cdigo. Precisamos de um lao mais
externo, o k, porque queremos zerar os elementos abaixo do piv (queremos uma
matriz triangular superior). Ento esse lao mais externo, em k, d o ponto de partida

Uma matriz triangular superior da forma

, ou seja, abaixo da diagonal, todos

0
0
os elementos so nulos (pode ser que algum elemento acima da diagonal tambm seja nulo).
2
Note que em C++ as matrizes e vetores so indexados comeando em 0 (zero) e vo at n-1, sendo n a
dimenso da matriz ou vetor.
1

Tutorial Clculo Numrico

SELA Mtodo da Eliminao de Gauss.

Tutorial 6, Rev. 1
Data: 4/9/2012

Pgina 5 de 9

no piv, que um elemento da diagonal, e os laos mais internos, das linhas i e

colunas j varrem o que sobrou da matriz abaixo do piv.
Para cada linha i, calculado o fator multiplicativo baseado no piv da linha anterior
fator = a[i][k]/a[k][k] que vai ser usado para eliminar, nessa linha, os elementos

abaixo da diagonal.
Note o complemento para fazer isso em a[i][k] = 0.0f, onde foramos que seja
zerado o elemento da coluna abaixo do piv, pois o lao comea depois dele.
A parte abaixo, no fim do bloco da eliminao, apenas imprime na tela cada passada
da transformao da matriz aumentada original em um sistema equivalente que vai
ser tratado no bloco seguinte: a substituio retroativa.

// Esse bloco imprime na tela as matrizes aumentadas ---------// intermediarias a cada passo das transformacoes lineares
for(o=0; o<=n-1; o++) // varre todas as linhas
{
printf("|");
for(p=0; p<=n-1; p++) // varre todas as colunas
{
printf(" %+g ",a[o][p]) ;
}
printf ("%+g | \n", b[o]);
}
printf("\n");
//------------------------------------------------------------}

//
//
//
//

Parte B: Retrossubstituicao ---------------------------------Nessa secao do algoritmo ja temos um sistema triangular, agora

vamos do fim para o comeco trocando os valores de x ate
resolver o sistema completo

// o primeiro (que eh o ultimo elemento) fazemos fora do laco

x[n-1]=b[n-1]/a[n-1][n-1];
// dentro do laco fazemos agora do penultimo ate o primeiro
for(i=n-2; i>=0; i--)
{
sum = 0.0f;
for(j=i+1; j<=n-1; j++)
{
sum = sum + a[i][j] * x[j];

Tutorial Clculo Numrico

SELA Mtodo da Eliminao de Gauss.

Tutorial 6, Rev. 1
Data: 4/9/2012

Pgina 6 de 9

}
// passando para o outro lado e achando x(i)
x[i] = (b[i] - sum)/a[i][i];
}
for(i=0; i<=n-1; i++) // imprimindo na tela os resultados
{
printf("x(%i) = %+g \n", i, x[i]);
}
system("PAUSE");
return EXIT_SUCCESS;
}

Nessa parte, resolvemos primeiro o ltimo valor de x fora do lao. Esse valor nosso
ponto de partida para, da por diante, calcular todos os demais, do fim para o comeo.
Dentro do lao, estamos fazendo a operao que quando feita mo, chamamos de
isolar o valor de x ou mesmo o popular colocar o resto para o outro lado.
Dentro desse bloco, na ltima parte, imprimimos na tela os valores de x. Observe bem
como ficou a funo printf.
Veja agora o cdigo completo;
#include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
int i, j, k, n;
int o, p;
double fator, sum;
//Declarando e inicializando a matriz do problema a ser resolvido
// | 2.0 3.0 -1.0 |
| x1 |
| 5.0 |
// | 4.0 4.0 -3.0 | x | x2 | = | 3.0 |
// | 2.0 -3.0 1.0 |
| x3 |
| -1.0 |
double
{2.0,
double
double

a[3][3]= {{2.0, 3.0, -1.0}, {4.0, 4.0, -3.0},

-3.0, 1.0}};
b[3]= {5.0, 3.0, -1.0};
x[3];

// Dimensao do problema (cuidado para aumentar/diminir aqui!)

n = 3;

Tutorial Clculo Numrico

SELA Mtodo da Eliminao de Gauss.

Tutorial 6, Rev. 1
Data: 4/9/2012
//
//
//
//
//
//
//

Pgina 7 de 9

Parte A: Eliminacao -----------------------------------------Nessa secao do algoritmo, fazemos uma serie de operacoes

lineares sobre a matriz (troca da ordem das equacoes,
multiplicacao de uma equacao por uma constante nao nula,
adicao de equacoes, etc.) de modo sistematico, ate que
o sistema "triangularize" e o sistema resultante possa ser
resolvido por substituicoes retroativas

for(k=0; k<=n-2; k++) // os ices comecam em zero no C++

{
for(i=k+1; i<=n-1; i++)
{
fator = a[i][k]/a[k][k];
for(j=k+1;j<=n-1;j++)
{
// transformando "A"
a[i][j] = a[i][j] - (fator * a[k][j]);
}
// transformando "b" (matriz aumentada)
b[i] = b[i] - (fator * b[k]);
//zerando antes da diagonal para formar um triang. sup.
a[i][k] = 0.0f;
}
// Esse bloco imprime na tela as matrizes aumentadas ---------// intermediarias a cada passo das transformacoes lineares
for(o=0; o<=n-1; o++) // varre todas as linhas
{
printf("|");
for(p=0; p<=n-1; p++) // varre todas as colunas
{
printf(" %+g ",a[o][p]) ;
}
printf ("%+g | \n", b[o]);
}
printf("\n");
//------------------------------------------------------------}

//
//
//
//

Parte B: Retrossubstituicao ---------------------------------Nessa secao do algoritmo ja temos um sistema triangular, agora

vamos do fim para o comeco trocando os valores de x ate
resolver o sistema completo

// o primeiro (que eh o ultimo) fazemos fora do laco

x[n-1]=b[n-1]/a[n-1][n-1];
// dentro do laco fazemos agora do penultimo ate o prim.
for(i=n-2; i>=0; i--)
{
sum = 0.0f;
for(j=i+1; j<=n-1; j++)
{

SELA Mtodo da Eliminao de Gauss.

Tutorial Clculo Numrico

Tutorial 6, Rev. 1
Data: 4/9/2012

Pgina 8 de 9

sum = sum + a[i][j] * x[j];

}
// passando para o outro lado e achando x(i)
x[i] = (b[i] - sum)/a[i][i];
}
for(i=0; i<=n-1; i++) // imprimindo na tela os resultados
{
printf("x(%i) = %+g \n", i, x[i]);
}
system("PAUSE");
return EXIT_SUCCESS;
}

Quando esse cdigo completo compilado e executado, o resultado deve ser igual ao
mostrado na Figura 1.

Figura 1 Sada do programa do Mtodo da Eliminao de Gauss

Exerccios
Agora teste a resoluo do sistema
3

4
2
2

1
2
3

Tutorial Clculo Numrico

SELA Mtodo da Eliminao de Gauss.

Tutorial 6, Rev. 1
Data: 4/9/2012

Pgina 9 de 9

Veja se a resposta exatamente

3
5
0

Preste muita ateno aos sinais da matriz dos coeficientes na hora de trocar.