typedef double T;

typedef struct {
    int row, col;
    T** mtr;
} matrix_frm;

typedef matrix_frm* Matrix;

Nel file che contiene il main implementiamo le funzioni i cui proptotipi sono:

void RowSwap(Matrix m, int r1, int r2);
// pre:  r1 ed r2 sono righe di m
// post: la matrice m ha le righe r1 ed r2 scambiate tra loro

void MultRowScalar(Matrix m, int r, T sc);
// pre:  r e' una riga di m
// post: la matrice m ha la riga r moltiplicata per lo scalare sc:
//       m[r] := m[r] * sc

void SumRowMultScalar(Matrix m, int r1, int r2, T sc);
// pre:  r1 ed r2 sono righe di m
// post: la matrice m ha la riga r1 sommata alla
//       riga r2 moltiplicata per lo scalare sc:
//       m[r1] := m[r1] + (m[r2] * sc)

void GaussJordan(Matrix m);
// pre:  m e' la matrice aumentata di un sistema di equazioni
//       lineari
// post: m e' la matrice aumentata con la parte dei coefficienti
//       ridotta all'identita', se quadrata.

function GaussJordan (m: matrix): boolean;
// pre: m e' la matrice aumentata dei coefficienti e dei
//      termini noti di un sistema di equazioni lineari
// post: ritorna true se la matrice dei cofficienti puo'
//      essere diagonalizzata; false altrimenti
var d, k, i: integer;
begin
   d := il minimo tra il numero delle righe ed il
        numero delle colonne - 1 di m;
   // se m e' ottenuta aumentando una matrice quadrata n*n, d = n

   for k := 1 to d do begin
       if esiste i in [k..righe] t.c. m[i,k] != 0
       then begin
                scambia(m[k],m[i]);
                m[k] := m[k] * 1/m[k,k]
       // post: la riga k avra' 1 sulla diagonale
       end else return false
       // la matrice dei coefficienti (se quadrata) e' singolare;
       // in ogni caso il sistema non ha un'unica soluzione

       for i := 1 to righe do
          if i != k and m[i,k] != 0 then
               m[i] := m[i] + m[k]*(-m[i,k]);
       // post: la colonna k ha 0 in ogni riga salvo k
   end return true
end;