include<iostream>

using namespace std;

main()
{
int i,j,k,l,m,n ;
float a[100][100];
float det;
cout << "Introducir el ORDEN DE LA MATRIZ : N = " << endl;
cin >> n;
m=n-1;
/* Vamos a introducir la matriz por teclado*/

cout << "Introducir los elementos" << endl;
cout << "------------------------" << endl;;
for(i=1;i<=n;i++)
{ for(j=1;j<=n;j++)
{cin >> a[i][j];}}
/* SI QUEREMOS LEER LOS ELEMENTOS DE LA MATRIZ LISTADOS */

/*for(i=1;i<=n;i++)
{ for(j=1;j<=n;j++)
printf("\t\t\tA(%d,%d) =%8.4f\n",i,j,a[i][j] ); }*/

/*****Calculo del DETERMINANTE*****/
det=a[1][1];
for(k=1;k<=m;k++)
{ l=k+1;
for(i=l;i<=n;i++)
{ for(j=l;j<=n;j++)
a[i][j] = ( a[k][k]*a[i][j]-a[k][j]*a[i][k] )/a[k][k]; }
det=det*a[k+1][k+1];
}
cout << endl;
cout << "DETERMINANTE = " << det << endl;
cout << "------------------------" << endl;

system("PAUSE");

return 0;
}








/***********DET1.C*********/

/**************CALCULO DE DETERMINANTES****************/
# include <stdio.h>

main()
{
int i,j,k,l,m,n ;
float a[100][100];
float det;
printf("\t\tIntroducir el ORDEN DE LA MATRIZ : N = ");
scanf("%d",&n);
printf("\n");
m=n-1;
/* Vamos a introducir la matriz por teclado*/

printf("\t\tIntroducir los elementos por FILAS \n");
printf("\t\t---------------------------------- \n");
for(i=1;i<=n;i++)
{ for(j=1;j<=n;j++)
{ printf("A(%d,%d) =",i,j);
scanf("%f",&a[i][j]); } }

/* SI QUEREMOS LEER LOS ELEMENTOS DE LA MATRIZ LISTADOS */
for(i=1;i<=n;i++)
{ for(j=1;j<=n;j++)
printf("\t\t\tA(%d,%d) =%8.4f\n",i,j,a[i][j] ); }




/*****Calculo del DETERMINANTE*****/
det=a[1][1];
for(k=1;k<=m;k++)
{ l=k+1;
for(i=l;i<=n;i++)
{ for(j=l;j<=n;j++)
a[i][j] = ( a[k][k]*a[i][j]-a[k][j]*a[i][k] )/a[k][k]; }
det=det*a[k+1][k+1];
}
printf("\n\n");
printf("\t\t\tDETERMINANTE = %f\n", det);
printf("\t\t\t-------------------------\n");
}





Bueno aca funciona ese programita k tenias vos, anda hermoso =P
Espero que te sirva SALUDOS!

#include<iostream>
using namespace std;

main()
{
int i,j,k,l,m,n ;
float a[100][100];
float det;
cout << "Introducir el ORDEN DE LA MATRIZ : N = " << endl;
cin >> n;
m=n-1;
/* Vamos a introducir la matriz por teclado*/

cout << "Introducir los elementos" << endl;
cout << "------------------------" << endl;;
for(i=1;i<=n;i++)
{ for(j=1;j<=n;j++)
{cin >> a[i][j];}}
/* SI QUEREMOS LEER LOS ELEMENTOS DE LA MATRIZ LISTADOS */

/*for(i=1;i<=n;i++)
{ for(j=1;j<=n;j++)
printf("\t\t\tA(%d,%d) =%8.4f\n",i,j,a[i][j] ); }*/

/*****Calculo del DETERMINANTE*****/
det=a[1][1];
for(k=1;k<=m;k++)
{ l=k+1;
for(i=l;i<=n;i++)
{ for(j=l;j<=n;j++)
a[i][j] = ( a[k][k]*a[i][j]-a[k][j]*a[i][k] )/a[k][k]; }
det=det*a[k+1][k+1];
}
cout << endl;
cout << "DETERMINANTE = " << det << endl;
cout << "------------------------" << endl;

system("PAUSE");

return 0;
}







Invesa y determinante
1.

#include <iostream>
2.

#include <iomanip> //La utilizo para setw(int)
3.

#include <gsl/gsl_linalg.h> //Librera gsl para calcular lo que
queremos
4.


5.

using namespace std; //Instruccin para no tener que escribir std::cin
6.


7.

int main (int argc, char **argv)
8.

{
9.

size_t i,j,m; //size_t es un tipo especfico de GSL, de tipo entero
10.

// i,j son variables contador, m es el tamao u orden de la matriz
11.

int s; // s es la variable signum de las permutaciones
12.

cout<<"\nIntroduce el orden de la matriz: ";
13.

cin>>m;
14.

// Declaramos las matrices A, p y invA de forma dinmica para as
poder destruirlas
15.

// cuando acabemos con ellas y as; liberar memoria. invA es la
inversa y p es
16.

// la permutacin
17.

gsl_matrix * A = gsl_matrix_alloc(m,m);
18.

gsl_permutation * p = gsl_permutation_alloc(m);
19.

gsl_matrix *invA = gsl_matrix_alloc(m,m);
20.

cout<<"\nIntroduce los elementos de la matriz:"<<endl;
21.

for(i=0; i<m*m; i++)
22.

{
23.

cout<<"A("<<i+1<<")"<<"=";
24.

cin>>A->data[i];
25.

}
26.

gsl_linalg_LU_decomp (A, p, &s); //Calculo la descomposicin LU
27.

gsl_linalg_LU_invert(A,p,invA); // Calculo la inversa de A y la
guardo en invA
28.

// Calculamos y visualizamos por terminal el determinante de A
29.

cout<<"\ndet(A) = "<<gsl_linalg_LU_det(A, s)<<endl;
30.

// Visualizamos por terminal la inversa de A
31.

cout<<"\nLa inversa de A es:"<<endl;
32.

for(i=0; i<m; i++)
33.

{
34.

for(j=0;j<m; j++)
35.

{
36.

cout<<gsl_matrix_get(invA,i,j)<<setw(10);
37.

}
38.

cout<<endl;
39.

}
40.

// Liberamos memoria destruyendo la que ocupan A, p e invA
41.

gsl_matrix_free(A);
42.

gsl_matrix_free(invA);
43.

gsl_permutation_free(p);
44.

return(0);
45.

}


Traspuesta
#include<iostream.h>

void main()
{
int original[100][100],M,N,i,k;

cout<<"\n Numero de Columnas de la matriz: ";
cin>>M;
cout<<"\n Numero de Filas de la matriz: ";
cin>>N;

/*** LLENANDO LA MATRIZ ORIGINAL ***/
for(i=0;i<N;i++)
{
for(k=0;k<M;k++)
{
cout<<"\t Valor de la Matriz en la fila "<<i<<" columna "<<k<<": ";
cin>>original[i][k];
}
}
/*** IMPRIMIENDO LA ORIGINAL ***/
cout<<"\n\n ESTA ES LA MATRIZ ORIGINAL ->\n";
for(i=0;i<N;i++)
{
cout<<"\n";
for(k=0;k<M;k++)
{
if(original[i][k]<10)
cout<<" "<<original[i][k];
else
cout<<" "<<original[i][k];
}
}
/*** IMPRIMIENDO LA TRANSPUESTA ***/
cout<<"\n\n ESTA ES LA TRASPUESTA DE LA MATRIZ ORIGINAL ->\n";
for(i=0;i<M;i++)
{
cout<<"\n";
for(k=0;k<N;k++)
{
if(original[k][i]<10)
cout<<" "<<original[k][i];
else
cout<<" "<<original[k][i];
}
}
cin.get();cin.get();cin.get();

# include <iostream.h>
# include <conio.h>
# include <iomanip.h>
# include <dos.h>
main()
{
int k,j,f=17,c;
int mat[100][100];
long mat_res[100][100];
clrscr();
gotoxy(26,5);cout<<"digite tamao de la matriz
[__]";gotoxy(54,5);cin>>c;
gotoxy(26,9);cout<<"ASIGNAR VALORES A LA MATRIZ";
for(k=0;k<c;k++)
{
for(j=0;j<c;j++)
{
gotoxy(10,15);cout<<"introduzca un valor entero [ ]"<<" fila
"<< k <<" columna " << j;
gotoxy(39,15);cin>>mat[k][j];
}
}
gotoxy(26,16);cout<<"traspuesta de la matriz";
for(k=0;k<c;k++)
{
gotoxy(25,f);
for(j=0;j<c;j++)
{
mat_res[k][j]=mat[j][k];
cout<<setw(5)<<mat_res[k][j]<<" ";
getch();
}
f++;
}
}


men espero que este programilla dea lo que estas buscando
Metodo Gauss-Jordan
Este programa calcula la inversa de una matriz por medio del metodo
del espejo, es decir se aplica la reduccion de Gauss-Jordan en
una matriz de nxn y se aplican las mismas operaciones de fila a una
matriz identidad de nxn
#include <stdio.h>
#include <conio.h>
#include <math.h>

/*********** VARIABLES GLOBALES **********************/

double matriz[50][50];
double identidad[50][50];
int N; //N contiene el tamao de la matriz cuadrada
/*********** PROTOTIPOS DE FUNCIONES *****************/

void hallar_inversa(void);
void escalonar_matriz(void);
void permutar_filas(int fila1, int fila2);
void multip_fila(int fila,double factor);
void sumar_fila_multip(int fila1,int fila2, double factor);
void ceros_abajo(int fila_pivote, int columna_pivote);
void ceros_arriba(int fila_pivote, int columna_pivote);
void generar_matriz_identidad(void);

/*****************************************************/
int main()
{
int fi, co;

clrscr();

do{
printf("Ingrese el tamao de la matriz cuadrada: ");
scanf("%i",&N);
if(N>50 || N<2) {clrscr(); printf("El numero debe estar entre 2 y 50n");}
}while(N>50 || N<2);

for(fi=0;fi<N;fi++)
{
for(co=0;co<N;co++)
{
printf("Ingrese el valor de matriz[%i][%i]",fi+1,co+1);
scanf("%lf",&matriz[fi][co]);
}
}

hallar_inversa();

return 0;
}

/*-------------------------------------------------------------------------*/

void hallar_inversa(void)
{
int cont,cont2, flag=0;

escalonar_matriz();
generar_matriz_identidad(); //rellena la matriz identidad
for(cont=0;cont<N;cont++) //recorre filas
{
for(cont2=0;cont2<N;cont2++) //recorre columnas
{
if(matriz[cont][cont2]!=0) //busca pivote (elemento ditinto de 0)
{
if(matriz[cont][cont2]!=1) //si pivote no es 1, se lo multiplica
{
multip_fila(cont,pow(matriz[cont][cont2],-1));
}

ceros_arriba(cont,cont2); // se hacen 0's por arriba
ceros_abajo(cont,cont2); // y por debajo del pivote

break;
}
}
}

/*--------------------------------------------------------------*/
/* Una vez terminada esta operacion, la matriz identidad estara */
/* transformada en la inversa */
/* */
/* Ahora se comprueba que la matriz original este transformada */
/* en la matriz identidad, de no ser asi la inversa obtenida */
/* no es valida y la matriz no tiena inversa */
/*--------------------------------------------------------------*/
for(cont=0;cont<N;cont++)
{
for(cont2=0;cont2<N;cont2++)
{
if(cont==cont2)
{
if(matriz[cont][cont2]!=1) flag=1;
}
else
{
if(matriz[cont][cont2]!=0) flag=1;
}
}
}

if(flag==1)
{
printf("nnLa matriz no tiene inversann");
}
else
{
printf("nnLa Matriz Inversa es :nn");

for(cont=0;cont<N;cont++)
{
for(cont2=0;cont2<N;cont2++)
{
printf("%+#0.3f ",identidad[cont][cont2]);

}
printf("n");
}
}
printf("nPresione una tecla para continuar...");
getch();
}

/*-----------------------------------------------------------------------*/
/* */
/* Ordena la matriz de forma que quede en su forma escalonada por */
/* renglones */
/* */
/*-----------------------------------------------------------------------*/

void escalonar_matriz(void)
{
int cont, col, ceros, vec[10];
int flag, aux;

for(cont=0;cont<N;cont++)
{
col=0,ceros=0;

if(matriz[cont][col]==0)
{
do{
ceros++;
col++;
}while(matriz[cont][col]==0);
}
vec[cont]=ceros;
}
do
{
flag=0;
for(cont=0;cont<N-1;cont++)
{
if(vec[cont]>vec[cont+1])
{
aux=vec[cont];
vec[cont]=vec[cont+1];
vec[cont+1]=aux;

permutar_filas(cont,cont+1);

flag=1;
}
}
}while(flag==1);

}

/*----------------------------------------------------------------------*/
/* SE DEFINEN LAS 3 OPERACIONES ELEMENTALES DE FILA */
/* */
/* Las operaciones que se le realizen a la matriz para reducirla */
/* tambien deberan realizarsele a la matriz identidad para obtener */
/* la matriz inversa */
/*----------------------------------------------------------------------*/
void permutar_filas(int fila1,int fila2)
{
float auxval;
int cont;

for(cont=0;cont<N;cont++)
{
auxval=matriz[fila1][cont];
matriz[fila1][cont]=matriz[fila2][cont];
matriz[fila2][cont]=auxval;

auxval=identidad[fila1][cont];
identidad[fila1][cont]=identidad[fila2][cont];
identidad[fila2][cont]=auxval;
}
}

/*----------------------------------------------------------------------*/

void multip_fila(int fila,double factor)
{
int cont;

for(cont=0;cont<N;cont++)
{
matriz[fila][cont]=(matriz[fila][cont])*factor;
identidad[fila][cont]=(identidad[fila][cont])*factor;
}
}

/*----------------------------------------------------------------------*/

void sumar_fila_multip(int fila1,int fila2, double factor)
{
int cont;
for(cont=0;cont<N;cont++)
{
matriz[fila1][cont]=(matriz[fila1][cont])+((matriz[fila2][cont])*factor);
identidad[fila1][cont]=(identidad[fila1][cont])+((identidad[fila2][cont])*factor
);
}
}
void ceros_arriba(int fila_pivote, int columna_pivote)
{
int cont;

for(cont=0;cont<fila_pivote;cont++)
{
sumar_fila_multip(cont,fila_pivote,((matriz[cont][columna_pivote])*(-1)));

}
}

/*-------------------------------------------------------------------------*/
void ceros_abajo(int fila_pivote, int columna_pivote)
{
int cont;

for(cont=columna_pivote+1;cont<N;cont++)
{
sumar_fila_multip(cont,fila_pivote,((matriz[cont][columna_pivote])*(-1)));
}

}
/*-------------------------------------------------------------------------*/
void generar_matriz_identidad(void)
{
int i,j;
for(i=0;i<50;i++)
{
for(j=0;j<50;j++)
{
if(i==j) identidad[i][j]=1;
else identidad[i][j]=0;
}
}
}



si alguien puede tomarse la molestia de verificar este codigo se lo agradesco, tengo un error pero no se en
que se gun yo el algoritmo deve funcionar correctamente:

1- se tirangula la matriz, y el producto de la diagonal principal es el determinante de la matriz a, lo de mas
biene de regalo pa en contrar los valores de x:

importante: EL CODIGO ESTA ECHO EN DEV-C++ POR SI LAS DUDAS

#include <cstdlib>
#include <iostream>
#include <conio.h>
#include <math.h>
#include <stdlib.h>
using namespace std;
int main(int argc, char *argv[])
{
int n,i,j,k;
float a[10][10],b[10],x[10],det;
cout<<endl<<endl<<" METODO DE ELIMINACION DE GAUSS "<<endl;
cout<<" ========================================================="<<endl<<endl<<endl;
cout<<"Introduce el numero de ecuaciones => ";
cin>>n;cout<<endl;
cout<<"Introduce los coeficientes dela matriz A => "<<endl;
for(i=1;i<=n;i++) // carga los coefientes de a
{
for(j=1;j<=n;j++)
{
cout<<"A["<<i<<"]["<<j<<"]"<<"=>";
cin>>a[i][j];
}
cout<<endl;
}
cout<<"Introduce el vector independiente b => "<<endl;
for(j=1;j<=n;j++) //carga vector independiente
{
cout<<"b["<<i<<"]["<<j<<"]"<<"=>";
cin>>b[j];
}
//muestra la matriz a
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
cout<<a[i][j]<<" ";
}
cout<<endl;
}
//calcula el determinante de a // <<<<< INICIA EL METODO DE GAUSS >>>>>
j=0;
i=0;
det=1; //paso uno
for(i=1;1<=n-1;i=i+1) //paso tres
{
det=det*a[i][i]; //paso cuatro
if(det==0) //paso cinco
{
cout<<"Hay un cero en la diagonal principal...";
goto salir;
}
for(k=i+1;k<=n;k=k+1) //paso siete
{
for(j=i+i;j<=n;j=j+1) //paso nueve
{
a[k][j]=a[k][j]-(a[k][i]*a[i][j])/a[i][i];
}
b[k]=b[k]-(a[k][i]*b[i])/a[i][i]; //paso doce
}
} //fin del for paso tres
det=det*a[n][n];
if(det==0) //paso 16
{
cout<<"Hay un cero en la diagonal principal...";
goto salir;
}
x[n]=b[n]/a[n][n];
for(i=n-1;i>=1;i=i-1) //paso 19
{
x[i]=b[i];
for(j=i+1;j<=n;j=j+1) //paso 20
{
x[i]=x[i]-a[i][j]*x[j];
}
x[i]=x[i]/a[i][i];
}
cout<<"El determinante de a es => "<<det;
cout<<"Los valores de x => "<<endl;
for(j=1;j<=n;j++)
{
cout<<"x["<<i<<"]"<<"=>"<<x[j];cout<<endl;
}
salir:
system("PAUSE");
return EXIT_SUCCESS;
}

#include <iostream>

#include <fstream>
#include <iomanip>

using namespace std;

void gaussjordan (int n, double **A);

int main(){

ifstream label1 ("datos//datos.dat");

ofstream label2 ("salida//salida.dat");

int i, j, k;

cout << "Resolucion de sistemas lineales por el metodo de Gauss-Jordan\n\n";

label2 << "Resolucion de sistemas lineales por el metodo de Gauss-Jordan\n\n";

int n;

label1 >> n;

cout << "Numero de incognitas = " << n;

cout << "\n\n";

double **A;

A = new double *[n+1];

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

A[j] = new double [n+1];

cout.setf(ios::fixed);

cout.precision(4);

label2.setf(ios::fixed);

label2.precision(4);

// Introduccin de datos a partir del archivo correspondiente

for (i = 0; i < n; i++) {

for (j = 0; j < n + 1; j++) {

label1 >> A[i][j];

}

}

// Aplicacin del mtodo de Gauss-Jordan

gaussjordan (n, A);

// Impresin de valores de las incgnitas

for (i = 0; i < n; i++) {

cout << "X[" << i+1 << "] = " << setw(10) << setiosflags(ios::right) << A[i][n]
<< " ";

label2 << "X[" << i+1 << "] = " << setw(10) << setiosflags(ios::right) <<
A[i][n] << " ";

cout << endl;

label2 << endl;

}

cout << endl;

return 0;

}

void gaussjordan (int n, double **A) {

// Aplicacin del mtodo de Gauss-Jordan

int i, j, k;

// Normalizacin de la fila pivote

double factor;

for (k = 0; k < n; k++) {

factor = A[k][k];

for (j = k; j < n + 1; j++) {

A[k][j] = A[k][j]/factor;

}

// Eliminacin de variables por fila

for (i = 0; i < n + 1; i++) {

if (i != k) {

factor = A[i][k];

for (j = 0; j < n + 1; j++) {

A[i][j] = A[i][j] - factor * A[k][j];

}

}

}

}

}


Grbenlo como gaussjordan.c++ y coloqunlo en una carpeta llamada GAUSSJORDAN.
En GAUSSJORDAN, creen un directorio llamado datos y otro llamado salida. En datos, copien el
siguiente datos.dat:

Cdigo:
5
4 2 3 -1 1 16
1 1 1 1 1 3
1 -1 1 -1 1 1
1 1 2 1 1 6
1 1 -1 1 2 -5


Compilen con:

g++ gaussjordan.c++ -o gaussjordan

y ejecuten con:

./gaussjordan

El resultado ser:

Cdigo:
Resolucion de sistemas lineales por el metodo de Gauss-Jordan

Numero de incognitas = 5

X[1] = 1.0000
X[2] = 2.0000
X[3] = 3.0000
X[4] = -1.0000
X[5] = -2.0000


//METODO DE GAUSS

#include<iostream.h>
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int i,j,k,n;
double m[20][20],aux;

void main()
{

cout<<" <<<<Metodo de Gauss >>>> ";
cout<<"\n Matriz cuadrada de orden N= ";
cin>>n;
cout<<"\n Digite los elementos de la matriz en la posicion ";
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
cout<<"\n M=["<<i<<","<<j<<"]= ";
cin>>m[i][j];
}
cout<<"\n Termino independiente de X"<<i<<" ";
cin>>m[i][n+1];

}

for(i=1;i<=n;i++)
{
if(m[i][i]!=0)
{
aux=1/m[i][i];
for(j=1;j<=n+1;j++)
{
m[i][j]=aux*m[i][j];
}

for(j=1;j<=n;j++)
{
if(j!=i)
{
aux=-m[j][i];
for(k=1;k<=n+1;k++)
{
m[j][k]=m[j][k]+aux*m[i][k];
}
}
}
}
}

cout<<"\n";
cout<<"la matriz identidad es";
cout<<"\n\n";
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
cout<<m[i][j]<<"\t";
}
cout<<"\n\n";
}

cout<<"El valor de las incognitas es : ";
for(i=1;i<=n;i++)
{

cout<<"\nX"<<i<<" = "<<m[i][n+1]<<"\n";
}
getchar();
}