//archivos de cabezera

#include<stdio.h>
#include <math.h>
#include <stdlib.h>
// prototipo de funciones
void imprimir(int filas, int columnas, double * );
void pivotear(int filas, int columnas, double *, double*,double*,int j);
void mensaje ();
main()
{
// Declracion de varables locales de la funcion main
int m,n;
printf("ingrese el tamaño de la matriz de coeficientes \n");
printf("Ingresa el numero de filas de la matriz de coeficientes: ");
scanf("%d",&m);
printf("\nIngresa el numero de columanas de la matriz de coeficientes: ");
scanf("%d",&n);
n+=1;
//declarmos una arreglo bidimencional que almacenara los coeficientes reales
de las variables
double MatrizA[m][n];

printf("\nIngresa los valores de la matriz A en la posicion indicada:");

printf("\n por convencion un elemento arbitrario de de una matriz se denota
A(i,j)\n ");
printf("de i es la i-esima fila y j la j-esima columna\n ");
for(int j=0; j<n;j++)
{
for(int i = 0; i<m; i++)
{
if (n- 1 == j)
{
printf("\nIngresa los datos del vector de resultados");
}
printf("\n A(%d,%d)= ",i+1,j+1);
scanf("%lg",&MatrizA[i][j]);
}
}
//limpiamos pantalla
system("cls");
// Impresion de la matriz inicial
printf("Matriz inicial\n");
imprimir(m,n,&MatrizA[0][0]);
printf("\n");

//Metodo de gauss-jordan
printf("\n reducciones por pivote \n");
double pivoteaux = 0.0;
double vectorPivote[n];
double vectorPivoteaux[n];
double s = 0.0;

for(int j =0; j<n-1;j++)

{
// Se necesita la posicion j, el vector pivote
pivotear(m, n,&MatrizA[0][0], &vectorPivote[0], &vectorPivoteaux[0],
j);
 for(int i = 0; i<m; i++)
{

//Cuando i sea diferente de j se asigna el valor n, y se

restringe para evitar que tome el valor de columna de resultados
if (i != j && j < n-1)
{
s = MatrizA[i][j];

// Opera sobre toda la fila sin importar que esta contenga ya un

pivote
for(int k = 0; k < n; k++)
{
MatrizA[i][k] = (-1*s*vectorPivote[k]) + MatrizA[i][k];

if(i == j )
{
// Para evitar que se altere la fila pivote se realizan las
siguientes asignaciones.
for(int l = 0; l < n; l++)
{
MatrizA[i][l] = vectorPivoteaux[l];
if(MatrizA[i][l] == -0)
{
MatrizA[i][l] = 0;
}

}
}
imprimir(m,n,&MatrizA[0][0]);

// Se limpia la fila pivote para evitar arrastrar basura al igual que n

s = 0.0;
for(int k = 0; k < n; k++)
{
vectorPivote[k] = 0.0;
}

}
// defincion de funciones
void imprimir(int m, int n, double * MatrizA)
{ // variables locales
printf("\n\n");
int contar = 0;
 for(int i = 0; i<m*n; i++)
{
if(contar < n)
{
printf(" %.2lg ",MatrizA[i]);
contar++;
}
else
{
contar = 0;
printf("\n");
printf(" %.2lg ",MatrizA[i]);
contar++;
}

void pivotear(int m, int n, double *MatrizA, double *vectorPivote, double

*vectorPivoteaux, int j)
{
double pivoteaux = 0.0;
double matrizTemporal[m][n];
int sum = 0;
//Copiamos los datos de la MatrizA a una matriz temporal porque al enviarla
como apuntador esta se convierte en un vector.

for (int i = 0; i < m; i++)

{
for( int k = 0; k < n; k++)
{
matrizTemporal[i][k] = MatrizA[sum];
sum ++;
}
}

//Una vez copiados los datos en una matriz temporal operamos para obtener el
pivote y su fila asociada

for(int i = 0; i<m;i++)
{
if(i == j )
{
// Suponemos que el pivote esta en la posicion (i,j) y lo
calculamos dividiendo el numero en esa posicion entre si mismo.
pivoteaux = matrizTemporal[i][j];
printf("\nPivote: %.2lg\n",pivoteaux);
if (pivoteaux==0) printf("\nel sistema es inconsistnete (no tiene solucion o
tiene un numero infinito de soluciones)\n");
// En la matriz temporal realizamos la divicion de toda la
fila donde se encuentra el pivote y la guardamos en la matriz temporal y en dos
vectores que usaremos mas tarde.
for(int l = 0; l < n; l++)
{
matrizTemporal[i][l] = matrizTemporal[i][l] /
pivoteaux;
vectorPivote[l] = matrizTemporal[i][l];
 vectorPivoteaux[l] = matrizTemporal[i][l];

}
}
}

//Luego pasamos los datos de la matriz temporal a nuestra matriz de trabajo

MA.
sum = 0;

for (int i = 0; i < m; i++)

{
for( int k = 0; k < n; k++)
{
MatrizA[sum] = matrizTemporal[i][k];
sum++;
}
}

}
void mensaje () {
printf("\nsistema inconsistente\n");
}