SoloCodigo
Programación General => C/C++ => Mensaje iniciado por: Juliancho en Jueves 21 de Noviembre de 2002, 11:45
-
Hola....
Necesito que alguien me ayude con un programa en c++ que me calcule la inversa de una matriz n*n, si es posible que sea de más de 2*2.
Porfa, me lo pueden enviar a juliancho@hackemate.com.ar
Agradezco toda su colaboración.:o
-
Escribe la formula matematica...
Escribo el codigo...
Y vos me mandas la nota de la tarea...:D
-
Ese es el mayor problemibiris.
Aun no se nisiquera como hacerle.
Creo que primero hay que sacar la determinante de la matríz, luego sacar la matriz adjunta, a la adjunta sacarle la transpuesta y por último dividir la transpuesta por el determinante.
Lo que no c es como sacar el determinante y como sacar la adjunta.
Agradezco toda la ayuda.
-
Si resuelves el problema de calcular el determinante lo tienes todo hecho, porque para calcular la matriz adjunta necesitas calcular el determinante de submatrices de la susodicha matriz (¡vaya lio!).
Supongo que necesitas un algoritmo para matrices cuadradas invertibles de dimensión mayor o igual que cuatro, ¿no?
Si son de dimensión 2 ó 3 la cosa es mucho más sencilla. Por ejemplo, para n=3 el determinante sería:
det(A)=(a11+a22+a33)+(a12+a23+a31)+(a21+a32+a13)-(a13+a22+a31)-(a23+a32+a11)-(a12+a21+a33);
Bueno, supongo que eso ya lo sabrías.
A ver si encuentro algo, que parece interesante. Si lo resuelves pon la solución por aquí, ¿vale?
-
espero que te sirva leelo !/*
Calculo de la Iversa de una Matriz - Algoritmo de Gauss
*/
#include <iostream.h>
class matriz {
/*
Definicion del objeto matriz. Usare tabla para guardar los datos orginales
y sobre tabla2 se realizaran las operaciones.
*/
double **tabla,**tabla2;
int dim;
public:
enum tipo_tabla{coef,ampliada,inversa};
matriz(int);
~matriz();
void llenar();
void imprimir(int);
bool invertir(int,bool);
};
matriz::matriz(int n) {
int i;
dim=n;
tabla=new double *[dim];
for (i=0;i<dim;i++) *(tabla+i)=new double[dim*2];
}
matriz::~matriz() {
int i;
for (i=0;i<dim;i++) delete [] *(tabla+i);
delete [] tabla;
for (i=0;i<dim;i++) delete [] *(tabla2+i);
delete [] tabla2;
}
void matriz::llenar() {
int i,j;
double num;
for (i=0;i<dim;i++) {
for (j=0;j<dim;j++) {
cout<<"Ingresa coeficiente a["<<i+1<<","<<j+1<<"]: ";
cin>>num;
*(*(tabla+i)+j)=num;
}
for (j=dim;j<dim*2;j++) *(*(tabla+i)+j)=(i==(j-dim))?(double)1:(double)0;
}
tabla2=new double *[dim];
for (i=0;i<dim;i++) *(tabla2+i)=new double[dim*2];
for (i=0;i<dim;i++)
for (j=0;j<dim*2;j++) *(*(tabla2+i)+j)=*(*(tabla+i)+j);
}
void matriz::imprimir(int t_tabla) {
int i,j;
if (t_tabla==coef) {
for (i=0;i<dim;i++,cout<<endl)
for (j=0;j<dim;j++) cout<<*(*(tabla+i)+j)<<"t";
}
else if (t_tabla==ampliada) {
for (i=0;i<dim;i++,cout<<endl)
for (j=0;j<dim*2;j++) cout<<*(*(tabla+i)+j)<<"t";
}
else {
for (i=0;i<dim;i++,cout<<endl)
for (j=dim;j<dim*2;j++) cout<<*(*(tabla2+i)+j)<<"t";
}
}
bool matriz::invertir(int pivote=0,bool ida=true) {
/*
Invierte la matriz en tabla2. Retorna true si el proceso se realizo con exito, o sea
si la matriz en tabla es invertible o de lo contrario false.
Pivote es el elemento de la diagonal bajo, o sobre, el cual se anularan los coeficientes.
ida indica que paso se ejecuta, la formacion de:
i) triangular superior
ii) triangular inferior y simplificacion
Vea las hojas de respuesta para ver una explicacion detallada de los pasos y el algoritmo
*/
int i,j;
double k;
if (!*(*(tabla2+pivote)+pivote)) return false; // Matriz no invertible
else if (ida) {
// Fomacion trinagular superior
if (pivote==dim-1) return invertir(pivote,false); //Se llega al elemento a[n,n] y se llama a si misma pero con false, o sea pasa al paso ii
else {
for (i=pivote;i<dim-1;i++) {
k=*(*(tabla2+i+1)+pivote)/ *(*(tabla2+pivote)+pivote); // Calculo de k
for (j=0;j<dim*2;j++)
*(*(tabla2+i+1)+j)=*(*(tabla2+i+1)+j)-*(*(tabla2+pivote)+j)*k; // Operacion fila
}
return invertir(++pivote);
}
}
else {
// Fomacion trinagular inferior
if (pivote==0) { //Se llega al elemento a[1,1]
k=1/ *(*(tabla2+pivote)+pivote);
for (j=0;j<dim*2;j++)
*(*(tabla2+pivote)+j)*=k; //Se simplifica el elemento la fila por el elemento de la diagonal (paso iii)
return true;
}
else {
for (i=pivote;i>0;i--) {
k=*(*(tabla2+i-1)+pivote)/ *(*(tabla2+pivote)+pivote); // Calculo de k
for (j=0;j<dim*2;j++)
*(*(tabla2+i-1)+j)=*(*(tabla2+i-1)+j)-*(*(tabla2+pivote)+j)*k; // Operacion fila
k=1/ *(*(tabla2+pivote)+pivote);
for (j=0;j<dim*2;j++)
*(*(tabla2+pivote)+j)*=k; //Se simplifica el elemento la fila por el elemento de la diagonal (paso iii)
}
return invertir(--pivote,false);
}
}
}
int main() {
int dim;
matriz *tabla;
cout<<"Calculo de la Iversa de una Matriz - Algoritmo de Gauss"<<endl<<endl;
cout<<"Fase de Tarea Certamen 2 - Fundamentos de Informatica I"<<endl<<endl;
cout<<"Jorge Riquelme S. 2173090-4"<<endl;
cout<<"http://www.totex.cl - totex@totex.cl"<<endl<<endl<<endl;
cout<<"Dimension de la matriz? ";
cin>>dim;
tabla=new matriz(dim);
tabla->llenar();
cout<<endl<<"Matriz de coeficientes ingresados:"<<endl;
tabla->imprimir(matriz::coef);
cout<<endl<<"Matriz ampliada"<<endl;
tabla->imprimir(matriz::ampliada);
if (tabla->invertir()) {
// Si la matriz se pudo invertir la muestra
cout<<endl<<"Matriz Inversa"<<endl;
tabla->imprimir(matriz::inversa);
}
else cout<<endl<<"La matriz no tiene inversa!"<<endl;
return 0;
}
-
B)
Muchisisisimas Gracias.
Aunque ya lo había resuelto de una manera muy distinta, de todas formas te agradezco toda esta ayuda tan valiosa; este nuevo programa me ha funcionado de maravilla, mejor que el mio.
Además me ha servido para mejorar los conocientos en algebra lineal.
En verdad te agradezco mucho.
Good Bye.
B)
-
no se como ingrsar datos en una matriz dinamica como esta:
#include<stdio.h>
#include<stdlib.h>
/*declaracion matriz*/
int *matriz;
int a,b;
/* decalracion variables*/
int x,y,i,j,cont=0;
/*inicio*/
main()
{
matriz = (int *) malloc (sizeof(int)*a*B);
for(x=1;x<=2;x++)
{
for(y=1;y<=2;y++)
{
printf("[%d][%d]=>",x,y);scanf("%d",&matriz[x, y]);//aqui si le pongo matriz
}
}
for(i=1;i<=2;i++)
{
for(j=1;j<=2;j++)
{
printf("%d",matriz [i, j]);//solo imprime los 2 ultimos dos veses
}
}
}
-
tambien podias haber resuelto la matriz con gauss-jordan y todo lo que le hicieras a esa matriz se lo haces a una canonica, entonces el resultado que quede en la canonica es la adjunta.