Matriz Inversa
Juliancho
22 de Octubre del 2008
HOLA.
Necesito que alguien me ayude con un programa en c++ que me calcule la inversa de una matriz n*n, si es posible de más de 2*2.
Agradezco la colaboración.
Necesito que alguien me ayude con un programa en c++ que me calcule la inversa de una matriz n*n, si es posible de más de 2*2.
Agradezco la colaboración.
alan
22 de Octubre del 2008
oye quiero saber si pudiste encontrar el programa para calculra la matriz inversa de ser asi te agradeceria si me lo puedes mandar por favor
alan
22 de Octubre del 2008
alannnn
lisbita
22 de Octubre del 2008
encontraste algo
yo necesito eso tambien. serias tan amable de enviame una respuesta.
por favor
gracias
yo necesito eso tambien. serias tan amable de enviame una respuesta.
por favor
gracias
lukass
22 de Octubre del 2008
bueno una ves yo pedi este tipo de ayuda y literalmente me mandaron por el caño, en cierta parte es verdad, no debemos abocarnos a pedir el programa sino una ayuda, pero en fin te dejo este programa que espero que lo entiendas pues es usando clases pero devuelve la inversa que es lo que te interesa chao
#include<iostream.h>
#include<stdlib.h>
#include<conio.h>
class matrix{
long float A[50][50];
public:
float leer(int n);
float detter(int n);
float inversa(int n, int dett);
float vermat(int n);
};
matrix objeto;
float matrix::leer(int n)
{ float i,j;
for(i=0; i<n;i++)
for(j=0; j<n;j++)
cin>>A[i][j];
return 0;
}
float matrix::vermat(int n)
{
float i,j;
for(i=0; i<n;i++)
for(j=0; j<n; j++)
{
cout<<" "<<A[i][j];
if(j==n-1) cout<<"n";
}
return 0;
}
float matrix::detter(int n)
{
int i,k,j,p,b,q,d;
if(n>2){
k=0; b=1; p=0; q=0;
for(k=0;k<n;k++)
{
i=k;b=1;
for(j=0;j<n; j++)
{
b=b*A[i][j];
i++;
if(i==n) i=0;
}
p+=b;
}
k=0; b=1;
for(k=0;k<n;k++)
{b=1;
i=k;
for(j=n-1;j>=0;j--)
{
b*=A[i][j];
i++;
if(i==n) i=0;
}
q+=b;
}
}
else{
p=A[0][0]*A[1][1];
q=A[0][1]*A[1][0];
}
d=p-q;
return d;
}
float matrix::inversa(int n, int det)
{
int h, k,j,i;
float b[50][50];
float c[50][50];
for(i=0;i<n;i++)
for(j=0;j<n;j++)
c[i][j]=A[i][j];
h=n-1;
for(i=0; i<n; i++)
{
k=n-1;
for(j=0; j<n; j++)
{
b[i][j]=c[h][k];
if((i+j)% 2!=0) b[i][j]*=(-1);
k--;
}
h--;
}
for(i=0; i<n;i++)
for(j=0; j<n;j++)
c[i][j]=b[j][i]/det;
for(i=0;i<n;i++)
{for(j=0;j<n;j++)
cout<<" "<<c[i][j];
cout<<"n";
}
return 0;
}
void main()
{
int op,grado;
cout<<"n*******************nprograma que trabaja con una matriz cuadradandevuelve el determinate de la matriz,";
cout<<"ny la inversa de la matrizn**********************nn";
cout<<"ingrese el grado de la matriz con la que desea trabajar: ";
cin>>grado;
cout<<"ingrese los "<<grado*grado<<" elementos de la matrizn";
objeto.leer(grado);
cout<<"n la matriz es: n";
objeto.vermat(grado);
cout<<"n";
cout<<"el determinante de la matriz es: ";
op=objeto.detter(grado);
cout<<op;
cout<<"";
cout<<"nla inversa de la matriz es:nn";
objeto.inversa(grado, op);
}
#include<iostream.h>
#include<stdlib.h>
#include<conio.h>
class matrix{
long float A[50][50];
public:
float leer(int n);
float detter(int n);
float inversa(int n, int dett);
float vermat(int n);
};
matrix objeto;
float matrix::leer(int n)
{ float i,j;
for(i=0; i<n;i++)
for(j=0; j<n;j++)
cin>>A[i][j];
return 0;
}
float matrix::vermat(int n)
{
float i,j;
for(i=0; i<n;i++)
for(j=0; j<n; j++)
{
cout<<" "<<A[i][j];
if(j==n-1) cout<<"n";
}
return 0;
}
float matrix::detter(int n)
{
int i,k,j,p,b,q,d;
if(n>2){
k=0; b=1; p=0; q=0;
for(k=0;k<n;k++)
{
i=k;b=1;
for(j=0;j<n; j++)
{
b=b*A[i][j];
i++;
if(i==n) i=0;
}
p+=b;
}
k=0; b=1;
for(k=0;k<n;k++)
{b=1;
i=k;
for(j=n-1;j>=0;j--)
{
b*=A[i][j];
i++;
if(i==n) i=0;
}
q+=b;
}
}
else{
p=A[0][0]*A[1][1];
q=A[0][1]*A[1][0];
}
d=p-q;
return d;
}
float matrix::inversa(int n, int det)
{
int h, k,j,i;
float b[50][50];
float c[50][50];
for(i=0;i<n;i++)
for(j=0;j<n;j++)
c[i][j]=A[i][j];
h=n-1;
for(i=0; i<n; i++)
{
k=n-1;
for(j=0; j<n; j++)
{
b[i][j]=c[h][k];
if((i+j)% 2!=0) b[i][j]*=(-1);
k--;
}
h--;
}
for(i=0; i<n;i++)
for(j=0; j<n;j++)
c[i][j]=b[j][i]/det;
for(i=0;i<n;i++)
{for(j=0;j<n;j++)
cout<<" "<<c[i][j];
cout<<"n";
}
return 0;
}
void main()
{
int op,grado;
cout<<"n*******************nprograma que trabaja con una matriz cuadradandevuelve el determinate de la matriz,";
cout<<"ny la inversa de la matrizn**********************nn";
cout<<"ingrese el grado de la matriz con la que desea trabajar: ";
cin>>grado;
cout<<"ingrese los "<<grado*grado<<" elementos de la matrizn";
objeto.leer(grado);
cout<<"n la matriz es: n";
objeto.vermat(grado);
cout<<"n";
cout<<"el determinante de la matriz es: ";
op=objeto.detter(grado);
cout<<op;
cout<<"";
cout<<"nla inversa de la matriz es:nn";
objeto.inversa(grado, op);
}
azteca
22 de Octubre del 2008
un favorzote, en caso de que si hayas conseguido el programa de la inversa de la matriz podrÃas pasarmelo mi vida depende de eso, por favor.
BLANCA AURORA GALDAMEZ HERNAND
22 de Octubre del 2008
necesito un programa en C++ que calcule la matriz inversa de 3*3
Mardoqueo
22 de Octubre del 2008
Si ya la conseguiste haceme el favor de enviarmela me super [email protected]
patt
22 de Octubre del 2008
Yo tambien necesito el codigo de la matriz inversa, a poder ser con el metodo de gauss-jordan. Os lo agradeceria mucho
Pablo Abratte
22 de Octubre del 2008
// 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
//
// [email protected]
#include <stdio.h>
#include <conio.h>
#include <math.h>
/*********** VARIABLES GLOBALES **********************/
double matriz[50][50];
double identidad[50][50];
int N; //N contiene el tama¤o 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 tama¤o 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;
}
}
}
// 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
//
// [email protected]
#include <stdio.h>
#include <conio.h>
#include <math.h>
/*********** VARIABLES GLOBALES **********************/
double matriz[50][50];
double identidad[50][50];
int N; //N contiene el tama¤o 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 tama¤o 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;
}
}
}
Matriz Inversa
22 de Octubre del 2008
No encuentro por ningun lado el metodo de shipley para encotrar matrices inversas por favo si alguien lo conoce envienmelo.
nayeli
22 de Octubre del 2008
oye me gustaria saber si te mandaron el programa y si me lo puedes enviar, me urge. Agradezco tu atencion, gracias
gato_loko
22 de Octubre del 2008
HOLA, NECESITO QUE ME HAGAN UN FAVOR, ME URGE EL CODIGO DE LA MATRIZ MULTIDIMENCIONAL POR FAVOR SI ALGUIEN LO TIENE SI ME LOPUEDE ENVIAR Y COMPARTIR CODIGO OJO CODIGOS EN JAVA
Norberto
22 de Octubre del 2008
hola la podeis conseguir en:
http://zap.iespana.es/zap/c/punteros.php ahi encontraras todo tipo de informacion. responder si es necesario
Norberto
Santa Cruz Bolivia
http://zap.iespana.es/zap/c/punteros.php ahi encontraras todo tipo de informacion. responder si es necesario
Norberto
Santa Cruz Bolivia
linuro
22 de Octubre del 2008
#include <iostream>
#include <iomanip> //La utilizo para setw(int)
#include <gsl/gsl_linalg.h> //LibrerÃa gsl para calcular lo que queremos
using namespace std; //Instrucción para no tener que escribir std::cin
int main (int argc, char **argv)
{
size_t i,j,m; //size_t es un tipo especÃfico de GSL, de tipo entero
// i,j son variables contador, m es el tamaño u orden de la matriz
int s; // s es la variable signum de las permutaciones
cout<<"\nIntroduce el orden de la matriz: ";
cin>>m;
// Declaramos las matrices A, p y invA de forma dinámica para asà poder destruirlas
// cuando acabemos con ellas y asÃ; liberar memoria. invA es la inversa y p es
// la permutación
gsl_matrix * A = gsl_matrix_alloc(m,m);
gsl_permutation * p = gsl_permutation_alloc(m);
gsl_matrix *invA = gsl_matrix_alloc(m,m);
cout<<"\nIntroduce los elementos de la matriz:"<<endl;
for(i=0; i<m*m; i++)
{
cout<<"A("<<i+1<<")"<<"=";
cin>>A->data[i];
}
gsl_linalg_LU_decomp (A, p, &s); //Calculo la descomposición LU
gsl_linalg_LU_invert(A,p,invA); // Calculo la inversa de A y la guardo en invA
// Calculamos y visualizamos por terminal el determinante de A
cout<<"\ndet(A) = "<<gsl_linalg_LU_det(A, s)<<endl;
// Visualizamos por terminal la inversa de A
cout<<"\nLa inversa de A es:"<<endl;
for(i=0; i<m; i++)
{
for(j=0;j<m; j++)
{
cout<<gsl_matrix_get(invA,i,j)<<setw(10);
}
cout<<endl;
}
// Liberamos memoria destruyendo la que ocupan A, p e invA
gsl_matrix_free(A);
gsl_matrix_free(invA);
gsl_permutation_free(p);
return(0);
}
#include <iomanip> //La utilizo para setw(int)
#include <gsl/gsl_linalg.h> //LibrerÃa gsl para calcular lo que queremos
using namespace std; //Instrucción para no tener que escribir std::cin
int main (int argc, char **argv)
{
size_t i,j,m; //size_t es un tipo especÃfico de GSL, de tipo entero
// i,j son variables contador, m es el tamaño u orden de la matriz
int s; // s es la variable signum de las permutaciones
cout<<"\nIntroduce el orden de la matriz: ";
cin>>m;
// Declaramos las matrices A, p y invA de forma dinámica para asà poder destruirlas
// cuando acabemos con ellas y asÃ; liberar memoria. invA es la inversa y p es
// la permutación
gsl_matrix * A = gsl_matrix_alloc(m,m);
gsl_permutation * p = gsl_permutation_alloc(m);
gsl_matrix *invA = gsl_matrix_alloc(m,m);
cout<<"\nIntroduce los elementos de la matriz:"<<endl;
for(i=0; i<m*m; i++)
{
cout<<"A("<<i+1<<")"<<"=";
cin>>A->data[i];
}
gsl_linalg_LU_decomp (A, p, &s); //Calculo la descomposición LU
gsl_linalg_LU_invert(A,p,invA); // Calculo la inversa de A y la guardo en invA
// Calculamos y visualizamos por terminal el determinante de A
cout<<"\ndet(A) = "<<gsl_linalg_LU_det(A, s)<<endl;
// Visualizamos por terminal la inversa de A
cout<<"\nLa inversa de A es:"<<endl;
for(i=0; i<m; i++)
{
for(j=0;j<m; j++)
{
cout<<gsl_matrix_get(invA,i,j)<<setw(10);
}
cout<<endl;
}
// Liberamos memoria destruyendo la que ocupan A, p e invA
gsl_matrix_free(A);
gsl_matrix_free(invA);
gsl_permutation_free(p);
return(0);
}
lina
22 de Octubre del 2008
hola desearia saber si pudiste conseguir el programa en c para calcular la matriz inversa lo necesito con urgencia gracias
Sefkah
22 de Octubre del 2008
Hola, yo también necesito un programa que te calcule la matriz inversa (más concretamente una de 9*9, xo en fin...). Si me lo pudierais enviar a [email protected] os lo agradeceria infinitamente
isolo
22 de Octubre del 2008
Pues yo tengo el código pa resolverlo. En cuanto lo encuentre lo pincho akÃ. Creo q no era mucho código, si no te lo envio por correo.
JHONY A CARDONA
22 de Octubre del 2008
si me puedes ayudar con el codigo para la inversa de una matriz te lo agradeceria. soy de Medellin Colombia y lo necesito para mi trabajo final de c++
gracias
gracias
oscar
22 de Octubre del 2008
Esto te puede ayudar, es el algoritmo que calcula la inversa de una matriz.
/*-----
Función que calcula la inversa de una matriz cuadrada.
Parámetros :
vfMtriz : Recibe la dirección de la matriz Inicial a la que se le calculará la Inversa.
bError : Recibe la dirección de una variable donde se indicará sà fue posible o no calcular la matriz Inversa, asignándole un valor de TRUE o FALSE respectivamente.
-----*/
void MtrizInvrsa(float vfMtriz[][], BOOL &bError)
{
int i, j, k;
float fPbte1 = 0.0f, fPbte2 = 0.0f;
float vfInvrsa[20][20];
// Asignar unos (1) a su Diagonal - Matriz Identidad.
for (i = 0; i < 20; i++) // Asignar unos.
vfInvrsa[i][i] = 1.0f;
// Calcular la Inversa de la matriz.
for (j = 0; j < 20; j++) // Para cada Columna.
for (i = 0; i < 20; i++) // Para cada Fila.
{
if (i == j || vfMtriz[i][j] == 0)
continue;
fPbte1 = vfMtriz[j][j];
fPbte2 = vfMtriz[i][j];
for (k = 0; k < 20; k++)
{
vfInvrsa[i][k] = vfInvrsa[i][k] * fPbte1 - vfInvrsa[j][k] * fPbte2;
vfMtriz[i][k] = vfMtriz[i][k] * fPbte1 - vfMtriz[j][k] * fPbte2;
}
}
/*-----
Función que calcula la inversa de una matriz cuadrada.
Parámetros :
vfMtriz : Recibe la dirección de la matriz Inicial a la que se le calculará la Inversa.
bError : Recibe la dirección de una variable donde se indicará sà fue posible o no calcular la matriz Inversa, asignándole un valor de TRUE o FALSE respectivamente.
-----*/
void MtrizInvrsa(float vfMtriz[][], BOOL &bError)
{
int i, j, k;
float fPbte1 = 0.0f, fPbte2 = 0.0f;
float vfInvrsa[20][20];
// Asignar unos (1) a su Diagonal - Matriz Identidad.
for (i = 0; i < 20; i++) // Asignar unos.
vfInvrsa[i][i] = 1.0f;
// Calcular la Inversa de la matriz.
for (j = 0; j < 20; j++) // Para cada Columna.
for (i = 0; i < 20; i++) // Para cada Fila.
{
if (i == j || vfMtriz[i][j] == 0)
continue;
fPbte1 = vfMtriz[j][j];
fPbte2 = vfMtriz[i][j];
for (k = 0; k < 20; k++)
{
vfInvrsa[i][k] = vfInvrsa[i][k] * fPbte1 - vfInvrsa[j][k] * fPbte2;
vfMtriz[i][k] = vfMtriz[i][k] * fPbte1 - vfMtriz[j][k] * fPbte2;
}
}
raul zeferino
22 de Octubre del 2008
necesito un programa en c de la mtriz inversa
Karla
22 de Octubre del 2008
yo necesito ese programa, si lo conseguiste, por favor, lo necesito para ayer!!!