Algorytmy: Wyznacznik macierzy i Macierz odwrotna

[Kristofer]

Potrzebuję jakiś algorytm na wyliczanie wyznacznika macierzy, oraz na wyświetlanie macierzy odwrotnej ze zdeklarowanej przezemnie macierzy.
Nie musi być to oczywiście macierz dynamiczna, tylko np. 3x3, ale tak aby nie stosować metody Sarusa.
Obojątny jest język programowania (C++, C, Pascal, Delphi,...), może być nawet zwykły pseudo kod.
Za wszelką pomoc bardzo dziękuję.

[maurice_chavez]

Prosze bardzo ... jest to gauss pomijajacy problem zera na przekatnej.
Jezeli nie znasz zasady dzialania algorytmu gaussa, to polega on na doprowadzeniu macierzy do postaci diagonalnej (przez manipulacje wierszami) i wyznacznik bedzie rowny wtedy iloczynowi wyrazow na przekatnej.

Jedyny minus tego algorytmu to gdy macierz jest osobliwa zamiast zera zwraca smieci. Kod w pare sekund przerobilem z programu do rozwiazywania ukladu rownan liniowych, ktory zrobilem na Metody numeryczne.

Kod: Zaznacz cały

/*******************************************************}
{                                                       }
{       == Metody numeryczne ==                         }
{                                                       }
{       Wyznaczenie wyznacznika macierzy                }
{       metodą Gaussa                                   }
{                                                       }
{       Autor: maurice_chavez                           }
{                                                       }
{*******************************************************/


/*******************************************************}
{  find_maximum_l - znajduje maksymalny wiersz z dolnej }
{                   połówki macierzy                    }
{*******************************************************/

short find_maximum_l(double ** A, short col, short size)
{
short i, max_index;
double max_value;

max_value = A[col][col];
max_index = col;

for(i = col; i < size; i++)
if(max_value < fabs(A[i][col]))
{
max_value = fabs(A[i][col]);
max_index = i;
}

return max_index;
}

/*******************************************************}
{  find_maximum_u - znajduje maksymalny wiersz z górnej }
{                   połówki macierzy                    }
{*******************************************************/

short find_maximum_u(double ** A, short col, short size)
{
short i, max_index;
double max_value;

max_value = A[0][col];
max_index = 0;

for(i = 0; i < col + 1; i++)
if(max_value < fabs(A[i][col]))
{
max_value = fabs(A[i][col]);
max_index = i;
}

return max_index;
}

/*******************************************************}
{  change_row - zmienia dwa wiersze ze sobą.            }
{                                                       }
{*******************************************************/

void change_row(double ** A, short row_1, short row_2, short size)
{
short i;
double temp_value;

for(i = 0; i < size ; i++)
{
temp_value = A[row_1][i];
A[row_1][i] = A[row_2][i];
A[row_2][i] = temp_value;
}
}

/*******************************************************}
{  change_to_max_l - zmienia aktualny wiersz na         }
{                    maksymalny z dolnej połówki.       }
{*******************************************************/

void change_to_max_l(double ** A, short row, short size)
{
short max_index;

max_index = find_maximum_l(A, row, size);
change_row(A, row, max_index, size);
}

/*******************************************************}
{  change_to_max_u - zmienia aktualny wiersz na         }
{                    maksymalny z górnej połówki.       }
{*******************************************************/

void change_to_max_u(double ** A, short row, short size)
{
short max_index;

max_index = find_maximum_l(A, row, size);
change_row(A, row, max_index, size);
}

/*******************************************************}
{  make_zero_l - zeruje dolną połówkę macierzy.         }
{                                                       }
{*******************************************************/

void make_zero_l(double ** A, short size)
{
short i, j, k;
double temp_value;

for(k = 0; k < size - 1; k++)
{
change_to_max_l(A, k, size);

for(i = k + 1; i < size; i++)
{
temp_value = A[i][k];
for(j = 0; j < size ; j++)
{
A[i][j] = A[i][j] - (A[k][j] * temp_value) / A[k][k];
}
}
}
}

/*******************************************************}
{  make_zero_u - zeruje górną połówkę macierzy.         }
{                                                       }
{*******************************************************/

void make_zero_u(double ** A, short size)
{
short i, j, k;
double temp_value;

for(k = size - 1; k > 0; k--)
{
change_to_max_u(A, k, size);

for(i = k - 1; i >= 0; i--)
{
temp_value = A[i][k];
for(j = 0; j < size; j++)
{
A[i][j] = A[i][j] - (A[k][j] * temp_value) / A[k][k];
}
}
}
}


/*******************************************************}
{  det_gauss - oblicza wyznacznik metodą Gaussa         }
{                                                       }
{*******************************************************/

double det_gauss(double ** A, short size)
{
int i;
double det = 1;

make_zero_l(A, size);
make_zero_u(A, size);

for(i = 0; i < size; i++)
{
det *= A[i][i];
}

return det;
}


int main()
{
double ** A;
char c;

A = (double **) malloc(SIZE * sizeof(double *));

for(int i = 0; i < SIZE; i++)
{
A[i] = (double *) malloc(SIZE * sizeof(double));
}

A[0][0] = 1;
A[0][1] = A[1][0] = 1;
A[0][2] = A[2][0] = -1;
A[1][2] = A[2][1] = -4;
A[1][1] = 2;
A[2][2] = 3;

printf("Wyznacznik: %lf
", det_gauss(A, SIZE));
scanf("%c", &c);
}

[Mifczu]

Brak deklaracji funkcji fabs :/ albo jest ona w jakiejs niestandardowej bibliorece.

[kadiii]

Fabs to oczywiście biblioteka math.h.