El mexicano Ren Mario Montante Pardo desarroll en 1973 un mtodo numrico que

resuelve un sistema de ecuaciones en lgebra lineal utilizando solamente enteros, a

diferencia del mtodo de Gauss. No slo eso, sino que con el mismo mtodo se obtiene
el determinante y la inversa de la matriz. El mtodo es el ms exacto que hay para
encontrar la solucin de un sistema de ecuaciones, ya que las presenta al final en
forma de fraccin y no pierde informacin en el camino, lo cual s pasa con el mtodo
de Gauss - Jordan.
El mtodo 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 frmula:
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 nmero
de ecuaciones del sistema. Los pivotes van tomando los valores de la diagonal
principal. Al final, el nmero 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 solucin del sistema multiplicada por el ltimo pivote actual (pact).
Como ejemplo, sea el sistema de ecuaciones

2x - y +
x

= 2

+ 3z

= 4

2y + 2z

= 4

Al aadir la matriz unidad se obtiene:

-1

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

-1

-1

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

-1

-8

-4

-8

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

-8

-6

-3

-8

-8

-2

-5

-8

-8

-4

-8

En lugar de la matriz del sistema se obtuvo

-8

-8

-8

Lo cual indica que el determinante de la matriz

-1

es -8
En tanto que la inversa de esta matriz es:

-3

-2

-5

-4

(1/-8)

-6

y la solucin del sistema es

-8
(-1/8) -8

1
=

-8

1
1

Lo cual indica que x = 1, y = 1, z = 1 es la solucin.

A continuacin 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 tamao.

#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 funciones
void 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 sistema
int Matriz[Tamano][2*Tamano + 1] = { {0, 0} };
// Llamada a la funcion Recibe
Recibe(Matriz);
// Llamada a la funcion Imprime
Imprime(Matriz);
// Llamada a la funcion Calcula
Calcula(Matriz);
// Se llama a la funcion Imprime
Imprime(Matriz);
// Se imprime el determinante
printf("\n\nEl determinante de la matriz es: %d\n", Matriz[0][0]);
// Se imprime la matriz inversa
printf("\n\n\nEsta es la matriz inversa:\n \n");
for ( j = 0; j < Tamano; j++ )
{
// Abre for
for ( i = Tamano; i < 2*Tamano; i++ )
{
// Abre for anidado
printf("\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 sistema

printf("\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 for
printf("%3d\t = %6d/%d\n", i + 1, Matriz[i][2*Tamano], Matriz[0][0]);
}
// Cierra for
return 0;
} // Cierra main

////////////////////////////////////////////////////////////

//FUNCION RECIBE
/////////////////////////////////////////////////////////////
void Recibe( int Arreglo[][2*Tamano + 1])
{
int
int
int
int
int

// Abre funcion Recibe

i;
j;
k;
l;
m;

// Este par de ciclos reciben los coeficientes del sistema

printf("\nSE RECIBEN LOS COEFICIENTES DEL SISTEMA: \n");
for ( i = 0; i < Tamano; i++ )
for ( j = 0; j < Tamano; j++ )
{ // Abre for
printf("\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 for
printf("\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])
{
int i;
int j;

// Abre la funcion Imprime

printf("\n\n");
for ( i = 0; i < Tamano; i++ )
{
// Abre for
for ( j = 0; j < 2*Tamano + 1; j++ )
{
// Abre for anidado
printf("%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
int
int
int
int
int
int
int
int

B[Tamano][2*Tamano + 1];
pant = 1; // Al principio pant = 1
pact;
l;
k;
i = 0;
j;
s;
t;

// El pivote siempre va tomando valores consecutivos de la diagonal

// principal, esto se controla con la variable i en el siguiente ciclo
// for
for ( i = 0; i < Tamano; i++ )
{
// Abre for
// Se cambia el valor de pact
pact = 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 respectivamente
for ( 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 condicional
if ( 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 anidado
for ( 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 original
if ( 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 pant
pant = pact;
}
}

// Cierra for
// Cierra funcion Calcula

Y el mtodo Montante, este es un cdigo que empec el semestre pasado, hoy lo retom y lo
he podido concluir :D, este es el cdigo:
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#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] * m
}
}
}
}
iteracion++;
pivant = pivote;
for(i=0;i<R;i++) {
for(j=0;j<C;j++) {
matriz[i][j] = num[i][j];

}
}

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

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;