Mètode de reducció de Gauss
El mètode de reducció de Gauss és un procediment sistemàtic de substitució matemàtica de vectors d'una certa base de pels vectors de independents, per tal d'aconseguir una nova base de i les expressions dels vectors que queden a en aquesta nova base. El fet que tal substitució sigui possible en tots els casos està garantida pel teorema de substitució de Steinitz.
Sigui:
|
un conjunt de vectors no nuls d'un espai vectorial de dimensió . Aquest conjunt conté un subconjunt maximal de () vectors independents.
Les transformacions elementals i la seva justificació
[modifica]Sigui
|
una base de i siguin
|
Les expressions dels vectors del conjunt en aquesta base. Hom sol disposar les components d'aquests vectors en una matriu de columnes, en què cada columna conté les components d'un dels vectors:
|
Naturalment, permutar dues columnes d'aquesta matriu és permutar els corresponents vectors del conjunt , mentre que permutar-ne dues files correspon a permutar els corresponents vectors de la base . A part d'aquestes dues transformacions trivials, el mètode de reducció consisteix en l'aplicació sistemàtica i ordenada d'aquestes altres dues transformacions, dites transformacions elementals:
Normalització d'una fila
[modifica]Considerem el vector , pel qual la component , que és a la fila i a la columna , no és nul·la. La fila , que conté totes les components dels vectors corresponents al vector de la base, s'anomena la fila pivot després de dividir tots els seus elements per :
|
Aleshores, els vectors de , és a dir, les columnes de la matriu, queden expressats en la nova base
|
que és la base
|
resultat de substituir el vector pel vector .
Reducció de les altres files amb la fila pivot
[modifica]Es tracta ara de substituir cadascuna de les files per la suma de la fila pivot multiplicada per l'oposat de l'element de la fila que s'està substituint que és a la columna on hi ha l' obtingut en el pas anterior amb la fila que s'està substituint: si la fila pivot era la fila i volem reduir la fila (, naturalment!) les operacions a fer sobre aquesta fila són:
|
i, just en la columna , el resultat és un zero:
|
perquè, a la fila , la fila pivot, .
Després de fer això amb les files que no són la fila pivot, la matriu queda amb aquest aspecte:
|
Si s'analitza quin vector hi ha ara a una columna qualsevol: la columna :
|
però, com que,
|
resulta
|
i, finalment,
|
és a dir, el mateix vector que ja hi havia en aquesta columna, però ara expressat en la base
|
que és la base
|
resultat de substituir el vector pel vector .
Així, doncs, escollir una fila, , normalitzar-la tot dividint-la per l'element (que ha de ser no nul) de la seva columna per usar-la com a fila pivot i després reduir les altres files té com a resultat que tots els vectors (les columnes) quedin expressats en una nova base, obtinguda de l'antiga per substitució del seu vector -èsim pel vector representat a la columna .
![](http://upload.wikimedia.org/wikipedia/commons/thumb/d/d5/M%C3%A8tode_de_Gauss.jpg/220px-M%C3%A8tode_de_Gauss.jpg)
Exemple pràctic
[modifica]A la pràctica no cal amoinar-se per quins canvis de base s'estan produint. Només cal saber que, després del procés complet, tindrem ben distingits els vectors linealment independents del conjunt i l'expressió dels que queden com a combinació lineal dels vectors independents. Vegem-ne un exemple:
Considerem els cinc vectors
|
que disposarem en la matriu de quatre files (la dimensió de l'espai al qual pertanyen) i cinc columnes (el nombre de vectors que hi ha):
|
Comencem per la primera columna (pel vector ) i podem escollir per normalitzar i ser fila pivot qualsevol de les files en les que en la primera columna no hi hagi un zero. En el nostre cas, podem escollir-ne qualsevol, però agafarem la quarta, perquè l'element de la fila 4 i columna 1 ja val 1 i no cal normalitzar.
Com que estem en la primera de les reduccions, posem aquesta fila, la fila pivot, com a primera fila, permutant-la amb la primera:
|
i ara reduim les altres tres files. Per reduir la segona, cal sumar-li la fila pivot multiplicada per , que és l'oposat de l'element d'aquesta segona fila a la columna 1:
|
Per reduir la tercera, cal sumar-li la fila pivot multiplicada per , que és l'oposat de l'element d'aquesta tercera fila a la columna 1:
|
I, per reduir la quarta, cal sumar-li la fila pivot multiplicada per , que és l'oposat de l'element d'aquesta quarta fila a la columna 1:
|
i la matriu, després d'aquesta primera reducció, queda
|
Ara anem per la segona reducció. Prenem la segona columna (la del vector ) i podem escollir per normalitzar i ser fila pivot qualsevol de les tres files que encara no han actuat com a pivot (això n'exclou la primera) en les que en la segona columna no hi hagi un zero. En el nostre cas, podem escollir-ne qualsevol, però agafarem la quarta, perquè la normalització, que és dividir-la per serà senzilla.
Com que estem en la segona de les reduccions, posem aquesta fila, la fila pivot, ja normalitzada, com a segona fila, permutant-la amb la segona:
|
i ara reduim les altres tres. Per reduir la primera fila, cal sumar-li la fila pivot multiplicada per , que és l'oposat de l'element d'aquesta primera fila a la columna 2:
|
Per reduir la tercera, cal sumar-li la fila pivot multiplicada per , que és l'oposat de l'element d'aquesta tercera fila a la columna 2:
|
I, per reduir la quarta, cal sumar-li la fila pivot multiplicada per , que és l'oposat de l'element d'aquesta quarta fila a la columna 2:
|
i, acabada la segona reducció, la matriu queda
|
Comencem la tercera reducció: ens fixem en la tercera columna (la del vector ) i podem escollir per normalitzar i ser fila pivot qualsevol de les dues files que encara no han actuat com a pivot (això n'exclou la primera i la segona) en les que en la tercera columna no hi hagi un zero. Però no podem fer-ho, perquè en aquesta tercera columna, després de la segona fila ja tot són zeros. Aleshores, cal passar a la quarta columna i escollir una fila per a esdevenir el nou pivot. Com que l'element de la quarta columna (la del vector ) i fila tercera no és zero, podem prendre aquesta tercera fila com a pivot. La normalitzem i, com que estem a la tercera reducció i ja està al tercer lloc no cal fer permutacions de files ara. La matriu ha quedat així:
|
i, després de, amb el mateix mètode que les reduccions anteriors, reduir les altres tres files, obtenim
|
Ara ja no hi ha cas per a una quarta reducció, perquè a totes les columnes que queden, després de la tercera fila ja tot són zeros: el procés, doncs, ha acabat.
El que n'hem obtingut és l'expressió dels vectors , , , i en una nova base, i és aquesta:
|
on ara és clar que els vectors , i són linealment independents, i que
|
l'objectiu a aconseguir.
Usos principals del mètode
[modifica]A part la determinació de quins vectors d'un conjunt són linealment independents i com s'expressen els altres en funció d'aquests que ja s'ha descrit, el mètode de reducció de Gauss es fa servir per a:
- Determinar l'existència i unicitat de la solució d'un sistema d'equacions.[1]
- Càlcul del rang d'un conjunt de vectors o d'una matriu.
- Càlcul de les solucions de sistemes d'equacions lineals.
- Càlcul de la matriu inversa, si en té, d'una matriu donada.
- Càlcul del determinant d'una matriu.
Variants: Gauss vs. Gauss-Jordan
[modifica]Si només cal calcular el rang d'un conjunt de vectors o d'una matriu, aleshores es pot seguir el procés tot ometent la reducció de les files que són per damunt de la fila pivot. El resultat és, aleshores, una matriu triangular superior. Per exemple, la reducció de la matriu
|
de l'exemple feta així donaria com a matriu reduïda
|
en la qual, segueix ben manifesta la independència lineal dels vectors , i , però les relacions
|
no són evidents a cop d'ull. El procés, fet així, en els països de parla anglesa, se sol conèixer com a Gauss elimination, mentre que el procediment complet, en aquests ambients, és Gauss-Jordan elimination.
La classe següent implementa el mètode de reducció de Gauss per a matrius de nombres reals, quadrades o no. Els comentaris n'il·lustren la funcionalitat.
/**
* La classe ReduccioDeGauss conté els mètodes
* necessaris per reduir pel mètode de Gauss
* qualsevol matriu, quadrada o no, de nombres
* reals.
*
* L'únic mètode accessible és
* <code>imprimeixLaMatriu</code> que, ajudat dels
* altres mètodes, fa tot el procés.
*
* @author Brill
* @version 2007/08/28
*/
public final class ReduccioDeGauss {
/**
* Reducció pel mètode de Gauss
* qualsevol matriu, quadrada o no, de nombres
* reals.
*
* @param matriu la matriu a reduir. Les submatrius són les files.
* @param tolerancia el mínim valor més avall del qual es considera igual a zero.
*/
public static double[][] redueixLaMatriu (double[][] matriu,double tolerancia) {
// Càlcul del nombre de files i de columnes
int numFiles=matriu.length;
int numColumnes=matriu[0].length;
// Inicialització del comptador de reduccions
int columnaPivot=0;
for (int i=0;i<numFiles;i++) {
// Ja no queden més columnes?
if (!(i+columnaPivot<numColumnes)) {
break;
}
// Cerca del la següent columna per fer la següent reducció
while (aLaColumnaTotsSonZero(matriu,i,i+columnaPivot,tolerancia)) {
columnaPivot++;
// Ja no queden més columnes?
if (!(i+columnaPivot<numColumnes)) {
break;
}
}
// Encara queden columnes?
if (i+columnaPivot<numColumnes) {
// Sí. Busca l'entrada a la columna amb el valor més gran
// per agafar la fila corresponent com a pivot. Això es fa
// per minimitzar l'error d'arrodoniment.
int maximValorALaFila=buscaElMaximValorALaColumna(matriu,i,i+columnaPivot);
// Si la fila actual no és la que conté aquesta entrada
// de valor màxim, permutar-la amb la que sí el conté
if (i!=maximValorALaFila) {
matriu=permutaFiles(matriu,i,maximValorALaFila);
}
// Normalització de la fila pivot
matriu=normalitzaElPivot(matriu,i,i+columnaPivot);
// Reduccio de les altres files
matriu=redueixLesAltres(matriu,i,i+columnaPivot);
} else {
break;
}
}
// Arrodoniment de les entrades més petites que la tolerància
// al valor zero i resultat
return arrodoneixLaMatriu(matriu,tolerancia);
}
/**
* Pemutació de dues files
*
* @param matriu la matriu a la que se le permuten dues files.
* @param filaU l'índex d'una de les files a permutar
* @param filaDos l'índex de l'altra fila a permutar
*/
private static double[][] permutaFiles (double[][] matriu,int filaU,int filaDos) {
// Càlcul del nombre de columnes
int numColumnes=matriu[0].length;
// El dipòsit intermedi
double[] diposit=new double[numColumnes];
// Intercanvi columna a columna
for (int j=0;j<numColumnes;j++) {
diposit[j]=matriu[filaU][j];
matriu[filaU][j]=matriu[filaDos][j];
matriu[filaDos][j]=diposit[j];
}
// Resultat
return matriu;
}
/**
* Cerca d'elements no nuls en una columna a partir d'una fila fins al final
*
* @param matriu la matriu on es fa la cerca
* @param filaInicial la fila on es comença la cerca
* @param columna la columna on es fa la cerca
* @param tolerancia el mínim valor més avall del qual es considera igual a zero.
*/
private static boolean aLaColumnaTotsSonZero (double[][] matriu,int filaInicial,int columna,double tolerancia) {
// Inicialització
boolean aAquestaColumnaTotsSonZero=true;
// Càlcul del nombre de files
int numFiles=matriu.length;
// Comprovació que tots els elements són zero
for (int i=filaInicial;i<numFiles;i++) {
aAquestaColumnaTotsSonZero=aAquestaColumnaTotsSonZero&&(Math.abs(matriu[i][columna])<tolerancia);
}
// Resultat
return aAquestaColumnaTotsSonZero;
}
/**
* Cerca de l'element més gran en una columna a partir d'una certa fila fins al final
*
* @param matriu la matriu on es fa la cerca
* @param filaInicial la fila on es comença la cerca
* @param columna la columna on es fa la cerca
*/
private static int buscaElMaximValorALaColumna (double[][] matriu,int filaInicial,int columna) {
// Càlcul del nombre de files
int numFiles=matriu.length;
// Valor inicial de comparació
int valorMaxim=filaInicial;
// Cerca dins la columna
for (int i=filaInicial;i<numFiles;i++) {
// Valor per a comparació
double _value=Math.abs(matriu[i][columna]);
// És més gran que el que ja tenia?
if (_value>Math.abs(matriu[valorMaxim][columna])) {
// Sí: nou valor per a comparació
valorMaxim=i;
}
}
// Resultat
return valorMaxim;
}
/**
* Normalització de la fila pivot.
*
* @param matriu la matriu on es fa la normalització
* @param filaPivot la fila que es normalitza
* @param columnaPivot la columna de la qual es treu el valor per normalitzar
*/
private static double[][] normalitzaElPivot (double[][] matriu,int filaPivot,int columnaPivot) {
// Càlcul del nombre de columnes
int numColumnes=matriu[0].length;
// El valor normalitzador
double normalitzador=matriu[filaPivot][columnaPivot];
// El valor normalitzat
matriu[filaPivot][columnaPivot]=1.0;
// Normalització dels altres valors
for (int j=columnaPivot+1;j<numColumnes;j++) {
matriu[filaPivot][j]=matriu[filaPivot][j]/normalitzador;
}
// Resultat
return matriu;
}
/**
* Reducció de les altres files.
*
* @param matriu la matriu on es fa la reducció
* @param filaPivot la fila pivot que es fa servir
* @param columnaPivot la columna de la qual, de cada fila, es treuen els valors per reduir-les
*/
private static double[][] redueixLesAltres (double[][] matriu,int filaPivot,int columnaPivot) {
// Càlcul del nombre de files i de columnes
int numFiles=matriu.length;
int numColumnes=matriu[0].length;
// Reducció files
for (int i=0;i<numFiles;i++) {
// No és la fila pivot
if (i!=filaPivot) {
// El valor per fer la reducció
double _value=matriu[i][columnaPivot];
// El primer valor reduït
matriu[i][columnaPivot]=0.0;
// Reducció de la fila
for (int j=columnaPivot+1;j<numColumnes;j++) {
matriu[i][j]=matriu[i][j]-_value*matriu[filaPivot][j];
}
}
}
// Resultat
return matriu;
}
/**
* Arrodoniment a zero dels valors massa petits.
*
* @param matriu la matriu a arrodonir
* @param tolerancia el mínim valor més avall del qual es fa igual a zero.
*/
private static double[][] arrodoneixLaMatriu (double[][] matriu,double tolerancia) {
// Càlcul del nombre de files i de columnes
int numFiles=matriu.length;
int numColumnes=matriu[0].length;
// Examen de cadascun dels elements de la matriu
for (int i=0;i<numFiles;i++) {
for (int j=0;j<numColumnes;j++) {
// Aquest valor és més petit que la tolerància?
if (Math.abs(matriu[i][j])<tolerancia) {
// Sí: fes-lo igual a zero
matriu[i][j]=0.0;
}
}
}
// Resultat
return matriu;
}
}
Implementacions externes
[modifica]- LinearEquations.c Algorisme de reducció de Gauss en llenguatge C Arxivat 2011-10-22 a Wayback Machine.
- Algorisme de reducció de Gauss en llenguatge Matlab
- Algorisme de reducció de Gauss en llenguatge Python
Referències
[modifica]- ↑ Greenberg, Michael D. Advanced Engineering Mathematics (en anglès). 2a. Upper Saddle River, Nova Jersey: Prentice Hall, 1998, p. 401. ISBN 0-13-321431-1.