El mexicano René Mario Montante Pardo desarrolló en 1973 un método numérico que resuelve un sistema de ecuaciones en álgebra lineal utilizando solamente enteros, a diferencia del método de Gauss. No sólo eso, sino que con el mismo método se obtiene el determinante y la inversa de la matriz. El método es el más exacto que hay para encontrar la solución de un sistema de ecuaciones, ya que las presenta al final en forma de fracción y no pierde información en el camino, lo cual sí pasa con el método de Gauss - Jordan.

El método consiste en formar la matriz  extendida C  con las entradas de la matriz de coeficientes del sistema, la matriz identidad y el vector  de las entradas independientes del sistema. Posteriormente es necesario ir cambiando las entradas de C por medio de la siguiente fórmula:

para k != i

C(k, l) = [(C(i,i)*C(k,l) - C(k,i)*C(i,l)]/pant;

Se utiliza un par de variables auxiliares llamadas pact (pivote actual) y pant ( pivote anterior). Al inicio pant = 1; y pact = C(i,i). Donde i corre desde 1 hasta N, N el número de ecuaciones del sistema. Los pivotes van tomando los valores de la diagonal principal. Al final, el número que queda en la diagonal principal es el determinante, lo que queda en lugar de la matriz identidad es la inversa y la última columna corresponde a la solución del sistema multiplicada por el último pivote actual (pact).Como ejemplo, sea el sistema de ecuaciones

2x - y + z = 2

x + 3z = 4

2y + 2z = 4

Al añadir la matriz unidad se obtiene:

2 -1 1 1 0 0 2

1 0 3 0 1 0 4

0 2 2 0 0 1 4

en el primer paso ( i = 1) pact = 2 y pant = 1. Después del primer ciclo se obtiene

2 -1 1 1 0 0 2

0 1 5 -1 2 0 6

0 4 4 0 0 2 8

Aquí i = 2, pact = 1 y pant = 2. Al terminar este ciclo la matriz es:

1 0 3 0 1 0 4

0 1 5 -1 2 0 6

0 0 -8 2 -4 1 -8

Aquí i = 3, pact = -8 y pant = 1. Después de éste ciclo finalmente se obtiene la matriz:

-8 0 0 -6 4 -3 -8

0 -8 0 -2 4 -5 -8

0 0 -8 2 -4 1 -8

En lugar de la matriz del sistema se obtuvo

-8 0 0

0 -8 0

0 0 -8

Lo cual indica que el determinante de la matriz

2 -1 1

1 0 3

0 2 2

es -8

En tanto que la inversa de esta matriz es:

-6 4 -3

(1/-8) -2 4 -5

2 -4 1

y la solución del sistema es 

-8 1

(-1/8) -8 = 1

-8 1

Lo cual indica que x = 1, y = 1, z = 1 es la solución.A continuación se presenta el algoritmo en C. Este programa es completo, en el sentido de que es, creo, bastante amable con el usuario. Se puede cambiar la variable Tamano para resolver sistemas de cualquier tamaño.

#include <stdio.h>#define Tamano 3// La variable Tamano controla el numero de ecuaciones del sistema// se puede cambiar facilmente para resolver sistemas de cualquier// tamano

// Prototipos de funcionesvoid Recibe(int Arreglo[][2*Tamano + 1]);void Imprime(int Array[][2*Tamano + 1]);void Calcula(int C[][2*Tamano + 1]);

int main(){ // Abre main

int i;int j;

printf("\nEste programa usa el metodo de Montante para calcular");printf(" el determinante, la matriz inversa y la solucion de un");printf(" sistema de %d ecuaciones lineales con %d incognitas.\n", Tamano, Tamano);

// Se define una matriz que incluye la matriz de coeficientes, la unidad de // Tamano X Tamano y los terminos independientes del sistemaint Matriz[Tamano][2*Tamano + 1] = { {0, 0} };

// Llamada a la funcion RecibeRecibe(Matriz);

// Llamada a la funcion ImprimeImprime(Matriz);

// Llamada a la funcion CalculaCalcula(Matriz); // Se llama a la funcion ImprimeImprime(Matriz);

// Se imprime el determinanteprintf("\n\nEl determinante de la matriz es: %d\n", Matriz[0][0]);

// Se imprime la matriz inversaprintf("\n\n\nEsta es la matriz inversa:\n \n"); for ( j = 0; j < Tamano; j++ ){ // Abre forfor ( i = Tamano; i < 2*Tamano; i++ ){ // Abre for anidadoprintf("\t%3d\t", Matriz[j][i]); } // cierra for anidado printf("\n");

if ( Tamano/2 - 1 == j )printf("(1/%d)", Matriz[0][0]); } // Cierra for

// Se imprime la solucion del sistemaprintf("\n\n\nA continuacion se presentan las soluciones del sistema.");printf(" Los numeros de la izquierda se refieren a la variable. \n"); for ( i = 0; i < Tamano; i++ ){ // Abre forprintf("%3d\t = %6d/%d\n", i + 1, Matriz[i][2*Tamano], Matriz[0][0]); } // Cierra forreturn 0;} // Cierra main

//////////////////////////////////////////////////////////////FUNCION RECIBE/////////////////////////////////////////////////////////////

void Recibe( int Arreglo[][2*Tamano + 1])

{ // Abre funcion Recibe

int i;int j;int k;int l;int m;

// Este par de ciclos reciben los coeficientes del sistemaprintf("\nSE RECIBEN LOS COEFICIENTES DEL SISTEMA: \n");for ( i = 0; i < Tamano; i++ )for ( j = 0; j < Tamano; j++ ) { // Abre forprintf("\nPor favor introduzca el coeficiente %d de la ecuacion %d: ", j + 1, i + 1);scanf("%d", &Arreglo[i][j]);} // Cierra for

// Este ciclo adiciona la matriz unidad de TamanoXTamano for ( k = 0; k < Tamano; k++ )Arreglo[k][Tamano + k] = 1;

// Este ciclo recibe los terminos independientes printf("\nSE RECIBEN LOS TERMINOS INDEPENDIENTES. \n");for ( m = 0; m < Tamano; m++ ){ // Abre forprintf("\nIntroduzca el termino independiente de la ecuacion %d: ", m + 1);scanf("%d", &Arreglo[m][2*Tamano ]); } // Cierra for } // Cierra funcion Recibe

////////////////////////////////////////////////////FUNCION IMPRIME//////////////////////////////////////////////////

void Imprime(int Array[][2*Tamano + 1])

{ // Abre la funcion Imprimeint i;int j; printf("\n\n");for ( i = 0; i < Tamano; i++ ){ // Abre for

for ( j = 0; j < 2*Tamano + 1; j++ ){ // Abre for anidadoprintf("%3d\t", Array[i][j]); } // Cierra for anidado printf("\n");} // Cierra for

} // Cierra la funcion Imprime

/////////////////////////////////////////////////////////FUNCION CALCULA///////////////////////////////////////////////////////

void Calcula(int C[][2*Tamano + 1])

{ // Abre funcion Calcula/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ El algoritmo requiere que se haga una copia de la matriz original ++ Solo debe alterarse la matriz C cuando i se incrementa, esto se ++ Introducir la sentencia + + B[k][l] = ( (C[i][i]*C[k][l]) - (C[k][i]*C[i][l]) )/pant; ++ ++ hace en la parte principal de la funcion ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

// Se definen las variables pact (pivote actual) y pant(pivote anterior) // ademas de variables controladoras de ciclos int B[Tamano][2*Tamano + 1]; int pant = 1; // Al principio pant = 1 int pact; int l; int k; int i = 0; int j; int s; int t;

// El pivote siempre va tomando valores consecutivos de la diagonal// principal, esto se controla con la variable i en el siguiente ciclo// forfor ( i = 0; i < Tamano; i++ ){ // Abre for// Se cambia el valor de pactpact = C[i][i];

/* Descomente estas lineas para ver la impresion de estas variables printf ("\npact = %d", pact); printf ("\npant = %d", pant); */

// Los siguientes ciclos controlan las columnas y las filas respectivamentefor ( l = 0; l < 2*Tamano + 1; l++)for ( k = 0; k < Tamano; k++ ){ // Abre for anidado // El renglon sobre el que se ha tomado el pivote actual se deja intacta // esto se logra con el siguiente condicionalif ( k != i ){ // Abre if // La asignacion de valores no se hace directamente sobre la matriz C sino sobre // una copia. Esto porque de lo contrario se estaria modificando la matriz con // la que se calcula cada vez que se asigna un nuevo valor

B[k][l] = ( (C[i][i]*C[k][l]) - (C[k][i]*C[i][l]) )/pant;

} // Cierra if} // Cierra for anidado

// Se asigna los valores de la matriz A a la matriz C for ( s = 0; s < Tamano; s++ ){ // Abre for anidadofor ( t = 0; t < 2*Tamano + 1; t++ ){ // Abre for anidado //Como el renglon del pivote actual (pact) no se modifico //entonces no se asigna en la variable originalif ( s != i)C[s][t] = B[s][t] ; } // Cierra for anidado }

/* Descomente estas lineas para ver la evolucion del algoritmo cada vez que cambia i printf("\n"); Imprime(C); */

// Se cambia el valor de pantpant = pact;

} // Cierra for } // Cierra funcion Calcula

Y el método Montante, este es un código que empecé el semestre pasado, hoy lo retomé y lo he podido concluir :D, este es el código:

?1234567891011121314151617181920212223242526272829303132333435363738

#include<stdio.h>#include <stdlib.h>#define R 3#define C 4

 int main (void){   int i, j, num[R][C], matriz[R][C], pivote, pivant = 1, iteracion = 0;   //Lectura  for(i=0;i<R;i++){     for(j=0;j<C - 1;j++){        printf("Los valores de la matriz [%d,%d]= ",i + 1, j + 1);        scanf("%d",&matriz[i][j]);     }     printf("El costo fue----------------> ");     scanf("%d",&matriz[i][j]);  }

   while(iteracion < R) {       pivote = matriz[iteracion][iteracion];       for(i=0;i<C;i++) {          num[iteracion][i] = matriz[iteracion][i];       }       for(i=0;i<R;i++) {          if(iteracion != i) {            num[i][iteracion] = 0;          }       }       for(i=0;i<R;i++){          for(j=0;j<C;j++){             if(i != iteracion) {                if( j!= iteracion) {                  num[i][j] = (((matriz[i][j] * pivote) - (matriz[iteracion][j] * matriz[i][iteracion])) / pivant);                }             }          }       }

        iteracion++;       pivant = pivote;       for(i=0;i<R;i++) {          for(j=0;j<C;j++) {              matriz[i][j] = num[i][j];

                   }

394041424344454647484950515253545556575859

       }  }  printf("\n\n\n\n");    for(i=0;i<R;i++){     printf("\t\t");     for(j=0;j<C - 1;j++){        printf("\t%d",matriz[i][j]);     }     printf("\t= %d\n", matriz[i][j]);  }  return 0;}