Mètode de reducció de Gauss

El mètode de reducció de Gauss és un procediment sistemàtic de substitució matemàtica de $r$ vectors d'una certa base de $E$ pels $r$ vectors de $𝒞$ independents, per tal d'aconseguir una nova base de $E$ i les expressions dels $k-r$ 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:

$𝒞=\{u_1,u_2,\dots ,u_k\},j>k,j\ne r$

un conjunt de $k$ vectors no nuls d'un espai vectorial $E$ de dimensió $n$. Aquest conjunt conté un subconjunt maximal de $r$ ($0<r\le k$) vectors independents.

Les transformacions elementals i la seva justificació

Sigui

$ℬ=\{e_1,\dots ,e_n\},j>k,j\ne r$

una base de $E$ i siguin

$\begin{array}{cc}{u}_1& ={\lambda }_1^1{e}_1+{\lambda }_1^2{e}_2+\cdots +{\lambda }_1^n{e}_n\\ u_2& ={\lambda }_2^1{e}_1+{\lambda }_2^2{e}_2+\cdots +{\lambda }_2^n{e}_n\\ ⋮& ⋮\\ u_k& ={\lambda }_k^1{e}_1+{\lambda }_k^2{e}_2+\cdots +{\lambda }_k^n{e}_n\\ \end{array}$

Les expressions dels vectors del conjunt $𝒞$ en aquesta base. Hom sol disposar les components d'aquests vectors en una matriu de $k$ columnes, en què cada columna conté les components d'un dels vectors:

$\left(\begin{array}{cccc}{\lambda }_1^1& {\lambda }_2^1& \dots & {\lambda }_k^1\\ {\lambda }_1^2& {\lambda }_2^2& \dots & {\lambda }_k^2\\ ⋮& ⋮& ⋮⋮⋮& ⋮\\ {\lambda }_1^n& {\lambda }_2^n& \dots & {\lambda }_k^n\end{array}\right)$

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

Considerem el vector $u_i$, pel qual la component ${\lambda }_i^j$, que és a la fila $j$ i a la columna $i$, no és nul·la. La fila $j$, que conté totes les components dels vectors corresponents al vector $e_j$ de la base, s'anomena la fila pivot després de dividir tots els seus elements per ${\lambda }_i^j$:

$\left(\begin{array}{cccccccc}{\lambda }_1^1& {\lambda }_2^1& \dots & {\lambda }_{i-1}^1& {\lambda }_i^1& {\lambda }_{i+1}^1& \dots & {\lambda }_k^1\\ {\lambda }_1^2& {\lambda }_2^2& \dots & {\lambda }_{i-1}^2& {\lambda }_i^2& {\lambda }_{i+1}^2& \dots & {\lambda }_k^2\\ ⋮& ⋮& ⋮⋮⋮& ⋮& ⋮& ⋮& ⋮⋮⋮& ⋮\\ {\lambda }_1^{j-1}& {\lambda }_2^{j-1}& \dots & {\lambda }_{i-1}^{j-1}& {\lambda }_i^{j-1}& {\lambda }_{i+1}^{j-1}& \dots & {\lambda }_k^{j-1}\\ \frac{{\lambda }_1^j}{{\lambda }_i^j}& \frac{{\lambda }_2^j}{{\lambda }_i^j}& \dots & \frac{{\lambda }_{i-1}^j}{{\lambda }_i^j}& \frac{{\lambda }_i^j}{{\lambda }_i^j}& \frac{{\lambda }_{i+1}^j}{{\lambda }_i^j}& \dots & \frac{{\lambda }_k^j}{{\lambda }_i^j}\\ {\lambda }_1^{j+1}& {\lambda }_2^{j+1}& \dots & {\lambda }_{i-1}^{j+1}& {\lambda }_i^{j+1}& {\lambda }_{i+1}^{j+1}& \dots & {\lambda }_k^{j+1}\\ ⋮& ⋮& ⋮⋮⋮& ⋮& ⋮& ⋮& ⋮⋮⋮& ⋮\\ {\lambda }_1^n& {\lambda }_2^n& \dots & {\lambda }_{i-1}^n& {\lambda }_i^n& {\lambda }_{i+1}^n& \dots & {\lambda }_k^n\end{array}\right)=\left(\begin{array}{cccccccc}{\lambda }_1^1& {\lambda }_2^1& \dots & {\lambda }_{i-1}^1& {\lambda }_i^1& {\lambda }_{i+1}^1& \dots & {\lambda }_k^1\\ {\lambda }_1^2& {\lambda }_2^2& \dots & {\lambda }_{i-1}^2& {\lambda }_i^2& {\lambda }_{i+1}^2& \dots & {\lambda }_k^2\\ ⋮& ⋮& ⋮⋮⋮& ⋮& ⋮& ⋮& ⋮⋮⋮& ⋮\\ {\lambda }_1^{j-1}& {\lambda }_2^{j-1}& \dots & {\lambda }_{i-1}^{j-1}& {\lambda }_i^{j-1}& {\lambda }_{i+1}^{j-1}& \dots & {\lambda }_k^{j-1}\\ {\mu }_1^j& {\mu }_2^j& \dots & {\mu }_{i-1}^j& 1& {\mu }_{i+1}^j& \dots & {\mu }_k^j\\ {\lambda }_1^{j+1}& {\lambda }_2^{j+1}& \dots & {\lambda }_{i-1}^{j+1}& {\lambda }_i^{j+1}& {\lambda }_{i+1}^{j+1}& \dots & {\lambda }_k^{j+1}\\ ⋮& ⋮& ⋮⋮⋮& ⋮& ⋮& ⋮& ⋮⋮⋮& ⋮\\ {\lambda }_1^n& {\lambda }_2^n& \dots & {\lambda }_{i-1}^n& {\lambda }_i^n& {\lambda }_{i+1}^n& \dots & {\lambda }_k^n\end{array}\right)$

Aleshores, els vectors de $𝒞$, és a dir, les columnes de la matriu, queden expressats en la nova base

${ℬ}_i^j=\{e_1,\dots ,e_{j-1},{\lambda }_i^j{e}_j,e_{j+1},\dots ,e_n\}$

que és la base

${ℬ}_i^j=ℬ\mathrm{\setminus }\left\{e_j\right\}\cup \left\{{\lambda }_i^j{e}_j\right\}$

resultat de substituir el vector $e_j$ pel vector ${\lambda }_i^j{e}_j$.

Reducció de les altres files amb la fila pivot

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'$1$ obtingut en el pas anterior amb la fila que s'està substituint: si la fila pivot era la fila $j$ i volem reduir la fila $s$ ($s\ne j$, naturalment!) les operacions a fer sobre aquesta fila $s$ són:

${\lambda }_1^s-{\lambda }_i^s{\mu }_1^j,{\lambda }_2^s-{\lambda }_i^s{\mu }_2^j,\dots ,{\lambda }_k^s-{\lambda }_i^s{\mu }_k^j$

i, just en la columna $i$, el resultat és un zero:

${\lambda }_i^s-{\lambda }_i^s{\mu }_i^j={\lambda }_i^s-{\lambda }_i^s\cdot 1=0$

perquè, a la fila $i$, la fila pivot, ${\mu }_i^j=\frac{{\lambda }_i^j}{{\lambda }_i^j}=1$.

Després de fer això amb les $n-1$ files que no són la fila pivot, la matriu queda amb aquest aspecte:

$\left(\begin{array}{cccccccc}{\mu }_1^1& {\mu }_2^1& \dots & {\mu }_{i-1}^1& 0& {\mu }_{i+1}^1& \dots & {\mu }_k^1\\ {\mu }_1^2& {\mu }_2^2& \dots & {\mu }_{i-1}^2& 0& {\mu }_{i+1}^2& \dots & {\mu }_k^2\\ ⋮& ⋮& ⋮⋮⋮& ⋮& ⋮& ⋮& ⋮⋮⋮& ⋮\\ {\mu }_1^{j-1}& {\mu }_2^{j-1}& \dots & {\mu }_{i-1}^{j-1}& 0& {\mu }_{i+1}^{j-1}& \dots & {\mu }_k^{j-1}\\ {\mu }_1^j& {\mu }_2^j& \dots & {\mu }_{i-1}^j& 1& {\mu }_{i+1}^j& \dots & {\mu }_k^j\\ {\mu }_1^{j+1}& {\mu }_2^{j+1}& \dots & {\mu }_{i-1}^{j+1}& 0& {\mu }_{i+1}^{j+1}& \dots & {\mu }_k^{j+1}\\ ⋮& ⋮& ⋮⋮⋮& ⋮& ⋮& ⋮& ⋮⋮⋮& ⋮\\ {\mu }_1^n& {\mu }_2^n& \dots & {\mu }_{i-1}^n& 0& {\mu }_{i+1}^n& \dots & {\mu }_k^n\end{array}\right)$

Si s'analitza quin vector hi ha ara a una columna qualsevol: la columna $t$:

$\begin{array}{cc}{\mu }_t^1{e}_1+& {\mu }_t^2{e}_2+\cdots +{\mu }_t^{j-1}{e}_{j-1}+{\mu }_t^j{u}_i+{\mu }_t^{j+1}{e}_{j+1}+\cdots +{\mu }_t^n{e}_n=\\ & =({\lambda }_t^1-{\lambda }_i^1{\mu }_t^j)e_1+({\lambda }_t^2-{\lambda }_i^2{\mu }_t^j)e_2+\cdots +({\lambda }_t^{j-1}-{\lambda }_i^{j-1}{\mu }_t^j)e_{j-1}+\\ & +{\mu }_t^j{u}_i+({\lambda }_t^{j+1}-{\lambda }_i^{j+1}{\mu }_t^j)e_{j+1}+\cdots +({\lambda }_t^n-{\lambda }_i^n{\mu }_t^j)e_n=\\ & ={\lambda }_t^1{e}_1+{\lambda }_t^2{e}_2+\cdots +{\lambda }_t^{j-1}{e}_{j-1}+{\lambda }_t^{j+1}{e}_{j+1}+\cdots +{\lambda }_t^n{e}_n+\\ & +{\mu }_t^j{u}_i-{\lambda }_i^1{\mu }_t^j{e}_1-{\lambda }_i^2{\mu }_t^j{e}_2-\cdots -{\lambda }_i^{j-1}{\mu }_t^j{e}_{j-1}-{\lambda }_i^{j+1}{\mu }_t^j{e}_{j+1}-\cdots -{\lambda }_i^n{\mu }_t^j{e}_n\\ \end{array}$

però, com que,

$u_i={\lambda }_i^1{e}_1+{\lambda }_i^2{e}_2+\cdots +{\lambda }_i^{j-1}{e}_{j-1}+{\lambda }_i^j{e}_j+{\lambda }_i^{j+1}{e}_{j+1}+\cdots +{\lambda }_i^n{e}_n$

resulta

$\begin{array}{cc}{\mu }_t^j{u}_i-{\lambda }_i^1{\mu }_t^j{e}_1-& {\lambda }_i^2{\mu }_t^j{e}_2-\cdots -{\lambda }_i^{j-1}{\mu }_t^j{e}_{j-1}-{\lambda }_i^{j+1}{\mu }_t^j{e}_{j+1}-\cdots -{\lambda }_i^n{\mu }_t^j{e}_n=\\ & ={\mu }_t^j{\lambda }_i^j{e}_j=\frac{{\lambda }_t^j}{{\lambda }_i^j}{\lambda }_i^j{e}_j={\lambda }_t^j{e}_j\end{array}$

i, finalment,

$\begin{array}{cc}{\mu }_t^1{e}_1& +{\mu }_t^2{e}_2+\cdots +{\mu }_t^{j-1}{e}_{j-1}+{\mu }_t^j{u}_i+{\mu }_t^{j+1}{e}_{j+1}+\cdots +{\mu }_t^n{e}_n=\\ & ={\lambda }_t^1{e}_1+{\lambda }_t^2{e}_2+\cdots +{\lambda }_t^{j-1}{e}_{j-1}+{\lambda }_t^j{e}_j+{\lambda }_t^{j+1}{e}_{j+1}+\cdots +{\lambda }_t^n{e}_n=u_t\end{array}$

és a dir, el mateix vector que ja hi havia en aquesta columna, però ara expressat en la base

${ℬℛ}_i^j=\{e_1,\dots ,e_{j-1},u_i,e_{j+1},\dots ,e_n\}$

que és la base

${ℬℛ}_i^j=ℬ\mathrm{\setminus }\left\{e_j\right\}\cup \left\{u_i\right\}$

resultat de substituir el vector $e_j$ pel vector $u_i$.

Així, doncs, escollir una fila, $j$, normalitzar-la tot dividint-la per l'element (que ha de ser no nul) de la seva columna $i$ 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 $j$-èssim pel vector representat a la columna $i$.

Mètode de Gauss.

Exemple pràctic

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 $r$ vectors linealment independents del conjunt $𝒞$ i l'expressió dels $k-r$ que queden com a combinació lineal dels $r$ vectors independents. Vegem-ne un exemple:

Considerem els cinc vectors

$u_1=\left(\begin{array}{c}5\\ 3\\ 2\\ 1\end{array}\right),u_2=\left(\begin{array}{c}-1\\ 4\\ 1\\ 3\end{array}\right),u_3=\left(\begin{array}{c}11\\ 2\\ 3\\ -1\end{array}\right),u_4=\left(\begin{array}{c}6\\ 2\\ -1\\ -2\end{array}\right),u_5=\left(\begin{array}{c}3\\ 8\\ 6\\ 7\end{array}\right)$

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

$\left(\begin{array}{ccccc}5& -1& 11& 6& 3\\ 3& 4& 2& 2& 8\\ 2& 1& 3& -1& 6\\ 1& 3& -1& -2& 7\end{array}\right)$

Comencem per la primera columna (pel vector $u_1$) 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, pero 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:

$\left(\begin{array}{ccccc}1& 3& -1& -2& 7\\ 3& 4& 2& 2& 8\\ 2& 1& 3& -1& 6\\ 5& -1& 11& 6& 3\end{array}\right)$

i ara reduim les altres tres files. Per reduir la segona, cal sumar-li la fila pivot multiplicada per $-3$, que és l'oposat de l'element d'aquesta segona fila a la columna 1:

$\begin{array}{c}+\\ \end{array}\begin{array}{ccccccccc}3& & 4& & 2& & 2& & 8\\ -3\cdot 1& & -3\cdot 3& & -3\cdot (-1)& & -3\cdot (-2)& & -3\cdot 7\\ 0& & -5& & 5& & 8& & -13\end{array}$

Per reduir la tercera, cal sumar-li la fila pivot multiplicada per $-2$, que és l'oposat de l'element d'aquesta tercera fila a la columna 1:

$\begin{array}{c}+\\ \end{array}\begin{array}{ccccccccc}2& & 1& & 3& & -1& & 6\\ -2\cdot 1& & -2\cdot 3& & -2\cdot (-1)& & -2\cdot (-2)& & -2\cdot 7\\ 0& & -5& & 5& & 3& & -8\end{array}$

I, per reduir la quarta, cal sumar-li la fila pivot multiplicada per $-5$, que és l'oposat de l'element d'aquesta quarta fila a la columna 1:

$\begin{array}{c}+\\ \end{array}\begin{array}{ccccccccc}5& & -1& & 11& & 6& & 3\\ -5\cdot 1& & -5\cdot 3& & -5\cdot (-1)& & -5\cdot (-2)& & -5\cdot 7\\ 0& & -16& & 16& & 16& & -32\end{array}$

i la matriu, després d'aquesta primera reducció, queda

$\left(\begin{array}{ccccc}1& 3& -1& -2& 7\\ 0& -5& 5& 8& -13\\ 0& -5& 5& 3& -8\\ 0& -16& 16& 16& -32\end{array}\right)$

Ara anem per la segona reducció. Prenem la segona columna (la del vector $u_2$) 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, pero agafarem la quarta, perquè la normalització, que és dividir-la per $-16$ 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:

$\left(\begin{array}{ccccc}1& 3& -1& -2& 7\\ 0& 1& -1& -1& 2\\ 0& -5& 5& 3& -8\\ 0& -5& 5& 8& -13\end{array}\right)$

i ara reduim les altres tres. Per reduir la primera fila, cal sumar-li la fila pivot multiplicada per $-3$, que és l'oposat de l'element d'aquesta primera fila a la columna 2:

$\begin{array}{c}+\\ \end{array}\begin{array}{ccccccccc}1& & 3& & -1& & -2& & 7\\ -3\cdot 0& & -3\cdot 1& & -3\cdot (-1)& & -3\cdot (-1)& & -3\cdot 2\\ 1& & 0& & 2& & 1& & 1\end{array}$

Per reduir la tercera, cal sumar-li la fila pivot multiplicada per $5$, que és l'oposat de l'element d'aquesta tercera fila a la columna 2:

$\begin{array}{c}+\\ \end{array}\begin{array}{ccccccccc}0& & -5& & 5& & 3& & -8\\ 5\cdot 0& & 5\cdot 1& & 5\cdot (-1)& & 5\cdot (-1)& & 5\cdot 2\\ 0& & 0& & 0& & -2& & 2\end{array}$

I, per reduir la quarta, cal sumar-li la fila pivot multiplicada per $5$, que és l'oposat de l'element d'aquesta quarta fila a la columna 2:

$\begin{array}{c}+\\ \end{array}\begin{array}{ccccccccc}0& & -5& & 5& & 8& & -13\\ 5\cdot 0& & 5\cdot 1& & 5\cdot (-1)& & 5\cdot (-1)& & 5\cdot 2\\ 0& & 0& & 0& & 3& & -3\end{array}$

i, acabada la segona reducció, la matriu queda

$\left(\begin{array}{ccccc}1& 0& 2& 1& 1\\ 0& 1& -1& -1& 2\\ 0& 0& 0& -2& 2\\ 0& 0& 0& 3& -3\end{array}\right)$

Comencem la tercera reducció: ens fixem en la tercera columna (la del vector $u_3$) 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 $u_4$) 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í:

$\left(\begin{array}{ccccc}1& 0& 2& 1& 1\\ 0& 1& -1& -1& 2\\ 0& 0& 0& 1& -1\\ 0& 0& 0& 3& -3\end{array}\right)$

i, després de, amb el mateix mètode que les reduccions anteriors, reduir les altres tres files, obtenim

$\left(\begin{array}{ccccc}1& 0& 2& 0& 2\\ 0& 1& -1& 0& 1\\ 0& 0& 0& 1& -1\\ 0& 0& 0& 0& 0\end{array}\right)$

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 $u_1$, $u_2$, $u_3$, $u_4$ i $u_5$ en una nova base, i és aquesta:

$u_1=\left(\begin{array}{c}1\\ 0\\ 0\\ 0\end{array}\right),u_2=\left(\begin{array}{c}0\\ 1\\ 0\\ 0\end{array}\right),u_3=\left(\begin{array}{c}2\\ -1\\ 0\\ 0\end{array}\right),u_4=\left(\begin{array}{c}0\\ 0\\ 1\\ 0\end{array}\right),u_5=\left(\begin{array}{c}2\\ 1\\ -1\\ 0\end{array}\right)$

on ara és clar que els vectors $u_1$, $u_2$ i $u_4$ són linealment independents, i que

$u_3=2u_1-u_2,u_5=2u_1+u_2-u_4$

que era l'objectiu a aconseguir.

Usos principals del mètode

A part la determinació de quins vectors d'un conjunt són linealment independents i com s'espressen els altres en funció d'aquests que ja s'ha descrit, el mètode de reducció de Gauss es fa servir per a

• 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

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

$\left(\begin{array}{ccccc}5& -1& 11& 6& 3\\ 3& 4& 2& 2& 8\\ 2& 1& 3& -1& 6\\ 1& 3& -1& -2& 7\end{array}\right)$

de l'exemple feta així donaria com a matriu reduïda

$\left(\begin{array}{ccccc}1& 3& -1& -2& 7\\ 0& 1& -1& -1& 2\\ 0& 0& 0& 1& -1\\ 0& 0& 0& 0& 0\end{array}\right)$

en la qual, segueix ben manifesta la independència lineal dels vectors $u_1$, $u_2$ i $u_4$, però les relacions

$u_3=2u_1-u_2,u_5=2u_1+u_2-u_4$

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.

Implementació en codi Java

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

• LinearEquations.c Algorisme de reducció de Gauss en en llenguatge C
• Algorisme de reducció de Gauss en llenguatge Matlab
• Algorisme de reducció de Gauss en llenguatge Python

Enllaços externs

• Exercicis interactius, pas a a pas, del mètode de reducció de Gauss per a matrius i sistemes d'equacions lineals, en cossos diversos
• El mètode de Gauss a l'Holistic Numerical Methods Institute