Algoritmia - AYUDA POR FAVOR!!! (matriz inversa)

hola, necesito URGENTE un programa que defina la funcion de la matriz inversa, debe ser po metodo de gaus-jordan, no puede ser por determinantes.
El enunciado que debemos seguir (osea, la deficion de la matriz) es la que esta abajo, despues de eso, hay q ingresar la funcion de la matriz inversa.
Por favor!!! lo necesito URGENTE para hoy miercoles 30 de mayo del 2007 a mas tardar a las 23.00 hrs (horario santiago, chile)


#include <stdio.h>
#include <stdlib.h>

/* La funcion crea_matriz pide espacio en la memoria (a traves de
malloc) para almacenar una matriz de f filas por c columnas.
El retorno de la funcion crea_matriz es un puntero al espacio de
memoria pedido.
*/
float** crea_matriz(int f, int c);

/* La funcion destruye_matriz devuelve el espacio utilizado por una
matriz de f filas, pedido mediante la funcion crea_matriz,
utilizando free.
*/
void destruye_matriz(float** m, int f);

/* La funcion lee_matriz_desde_teclado obtiene desde el teclado los
datos para la matriz m de f filas y c columnas.
*/
void lee_matriz(float** m, int f, int c);

/* La funcion imprime matriz muestra en pantalla una matriz de f filas
y c columnas.
*/
void imprime_matriz(float** m, int f, int c);

/* La funcion matriz_inversa obtiene la inversa de la matriz m,
cuadrada de orden d, sin modificar la matriz m.
La funcion matriz_invertida retorna un puntero al espacio de
memoria que apunta a la matriz inversa de m. Si m no es invertible,
la funcion matriz_invertida retorna NULL.
*/
float** matriz_inversa(float** m, int d);


int main()
{
float** Mo; /* puntero para guardar la matriz original */
float** Mi; /* puntero para guardar la matriz inversa */
int D; /* orden de la matriz original (y de paso, de la inversa) */


printf("ingrese orden de la matriz: ");
scanf("%d", &D);

Mo = crea_matriz(D, D); /* creacion de la matriz */
lee_matriz(Mo, D, D); /* lectura de la matriz */

Mi = matriz_inversa(Mo, D); /* obtencion de la matriz inversa */

if( Mi == NULL ) /* esto significa que Mo no era invertible */
{
printf("la matriz dada no es invertible:\n");
imprime_matriz(Mo, D, D);
}
else /* la matriz Mo si era invertible */
{
printf("matriz original:\n");
imprime_matriz(Mo, D, D);
printf("matriz inversa:\n");
imprime_matriz(Mi, D, D);
}

destruye_matriz(Mo, D);

if( Mi != NULL )
{
destruye_matriz(Mi, D);
}

return 1;
}


float** crea_matriz(int f, int c)
{
int i;
float** r;

r = (float**)malloc(f*sizeof(float*));

for(i = 0; i < f; ++i)
r[i] = (float*)malloc(c*sizeof(float));

return r;
}

void destruye_matriz(float** m, int f)
{
int i;
if( m != NULL )
{
for(i = 0; i < f; ++i)
free( m[i] );

free( m );
}
}

void lee_matriz(float** m, int f, int c)
{
int i, j;

for(i = 0; i < f; ++i)
{
for(j = 0; j < c; ++j)
{
printf("m[%d][%d]? ", i, j);
scanf("%f", &m[i][j]);
}
}
}

void imprime_matriz(float** m, int f, int c)
{
int i, j;

printf(" ");
for(j = 0; j < c; ++j)
{
printf(" | %8d", j);
}
printf("\n");

printf("---");
for(j = 0; j < c; ++j)
{
printf("-+---------");
}
printf("\n");

for(i = 0; i < f; ++i)
{
printf("%3d", i);

for(j = 0; j < c; ++j)
{
printf(" | %8.3f", m[i][j]);
}
printf("\n");
}
}

float** matriz_inversa(float** m, int d)
{
return NULL;
}

Lilian, este código implementa el método de Gauss-Jordan para obtener la matriz inversa. Recuerda que este método puede no ser adecuado para todas las matrices, ya que la matriz original debe ser invertible.