Necesitamos ayuda con este programa

[paco_francisco*]

.

[Peregring-lk]

Primera cosa. Añadid las etiquetas de "código" en el código para que se vea bien (como lo tengo yo abajo). Escribid "[ code=c]" (sin el espacio detrás de `[`) al principio de vuestro código, y "[ /code]" al final (sin el espacio también).

Segundo, ni idea de qué hace vuestro algoritmo, pero os comento un par de fallos que he visto.

Por otro lado, en vuestro relleno de columnas. En vuestro código teníais "columnas * sizeof(double*)", pero cada fila se rellena con una matriz de `double`s y no con punteros. Aunque `sizeof(double) == sizeof(double*)` normalmente, es casualidad. Si una arquitectura tiene palabras de 64 bits pero solo direcciona hasta 32 bits de memoria, `sizeof(double) == 8` pero `sizeof(double*) == 4`. Así que:

Código (c) [Seleccionar] Expandir


for(i = 0; i < filas; ++i) { // Preincremento (++i) siempre mejor que postdecremento (i++).
   matriz = (double*)malloc(columnas * sizeof(double));

   if(matriz == NULL) {
      printf("No se ha podido reservar espacio de memoria.\n");
      // getchar(); Para que necesitas `getchar`?
      exit(EXIT_FAILURE); // `EXIT_FAILURE` (= 1, pero mas sano). Necesitas <stdlib.h> para usarlo.
   }
}


Al comienzo del algoritmo puede haber un riesgo con la memoria (te lo pongo en comentarios). Por otro lado, acostumbraos a quitad llaves cuando no son necesarias (si una estructura de control -if/else, for, while, do-while, solo contiene una sentencia, las llaves no son necesarias), y a utilizar preincrementos en vez de postincrementos (y a poner espacios entre operadores por cuestiones de legibilidad). Comparadad como queda el código (mucho más legible y corto):

Código (c) [Seleccionar] Expandir


// Cuidado con la linea (1): aqui asumes que el numero de filas y de columnas coinciden, sin embargo
// al inicio del `main` has permitido que el usuario inicialice ambas. Y si el numero de filas es mayor
// que el de columnas? Que cuando `iteracion >= filas`, la linea (1) provocara un `segmentation fault`.
// Si necesitas que la matriz sea cuadrada, pide al usuario solo las filas e inicializa columnas con el
// mismo valor.
while(iteracion < filas) {

   pivote = matriz[iteracion][iteracion]; // (1)

   for(i = 0; i < columnas; ++i) // Aqui no necesitas llaves. Este `for` solamente tiene una sentencia.
      num[iteracion] = matriz[iteracion];

   for(i = 0; i < filas; ++i) // Igual, fuera llaves. Y preincremento de nuevo.
      if(iteracion != i) // Fuera llaves.
         num[iteracion] = 0;

   for(i = 0; i < filas; ++i) // Fuera llaves. Preincremento.
      for(j = 0; j < columnas; ++j)  // Idem.
         if(i != iteracion && j != iteracion) // Union de ifs.
            num[j] = (((matriz[j] * pivote) - (matriz[iteracion][j] * matriz[iteracion])) / pivant);

   ++iteracion; // Preincremento.
   pivant = pivote; // Algo de espacio entre `for`s y sentencias normales, para que no haya claustrofobia.

   for(i = 0; i < filas; ++i) // Preincremento. Llaves
      for(j = 0; j < columnas; ++j) // Preincremento. Llaves.
         matriz[j] = num[j];
}