Foros aprenderaprogramar.com
Aprender a programar => Aprender a programar desde cero => Mensaje iniciado por: juan0754 en 29 de Mayo 2018, 19:42
-
Hola a todos ... quisiera que me ayudaran a plantear como podría hacer para Hallar la matriz Inversa de una Matriz nxn, pero usando el método de Gauss Jordan.
Esto es lo que llegue avanzar(solo introducir datos :'()... en verdad no se me ocurre como hacerlo...
package GaussJordan;
import java.util.*;
//Solucion para hallar la inversa de una Matriz nxn
public class InversaDeUnaMatriz {
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
//El ususrio establece el tamaño de la matriz
int a,b;
System.out.println("Ingrese orden que tendra su matriz: ");
a=Scan.nextInt();
int [][]matriz=new int[a][a];
//El usurio define los elementos de la matriz
for(int i=0;i<a;i++){
for(int j=0;j<a;j++){
System.out.print("Ingrese un valor para la posicion A["+i+"]["+j+"]:");
matriz[i][j]=Scan.nextInt();
}
}
System.out.println();
// Se muestra por pantalla la matriz establecida por el usuario
System.out.println("Matriz A");
for(int i=0;i<a;i++){
for(int j=0;j<a;j++){
System.out.print(matriz[i][j]+" ");
}
System.out.println();
}
//Hallar la determinante de la Matriz
int MT[][]=new int[a][a];
System.out.println();
for(int i=0;i<a;i++){
for(int j=0;j<a;j++){
if(matriz[0][0]==1){
}
else{
if(matriz[0][0]==0){
}
}
}
}
int diagonal=0;
for(int i=0;i<a;i++){
for(int j=0;j<a;j++){
if(matriz[i][j]==matriz[i][i]&&i==j){
}
}
}
}
}
-
Hola, para quien consulte este hilo, dejo un código para calcular la inversa de una matriz cuadrada invertible. Este problema no es nada sencillo de programar. En primer lugar hay que tener claros los conceptos y métodos matemáticos. Y luego hay que programarlo, que aún teniéndolo claro no es algo que se haga rápido. Por tanto no es un problema para hacer a modo de entretenimiento, sino más bien algo indicado para quien esté estudiando matemáticas.
//Programa de ejemplo para calcular la inversa de una matriz
import java.util.Scanner;
public class Inverse
{
public static void main(String argv[])
{
Scanner input = new Scanner(System.in);
System.out.println("Enter the dimension of square matrix: ");
int n = input.nextInt();
double a[][]= new double[n][n];
System.out.println("Enter the elements of matrix: ");
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
a[i][j] = input.nextDouble();
double d[][] = invert(a);
System.out.println("The inverse is: ");
for (int i=0; i<n; ++i) {
for (int j=0; j<n; ++j)
{System.out.print(d[i][j]+" ");}
System.out.println();
}
input.close();
}
public static double[][] invert(double a[][]) {
int n = a.length;
double x[][] = new double[n][n];
double b[][] = new double[n][n];
int index[] = new int[n];
for (int i=0; i<n; ++i)
b[i][i] = 1;
// Transform the matrix into an upper triangle
gaussian(a, index);
// Update the matrix b[i][j] with the ratios stored
for (int i=0; i<n-1; ++i)
for (int j=i+1; j<n; ++j)
for (int k=0; k<n; ++k)
b[index[j]][k]
-= a[index[j]][i]*b[index[i]][k];
// Perform backward substitutions
for (int i=0; i<n; ++i) {
x[n-1][i] = b[index[n-1]][i]/a[index[n-1]][n-1];
for (int j=n-2; j>=0; --j) {
x[j][i] = b[index[j]][i];
for (int k=j+1; k<n; ++k)
{
x[j][i] -= a[index[j]][k]*x[k][i];
}
x[j][i] /= a[index[j]][j];
}
}
return x;
}
// Method to carry out the partial-pivoting Gaussian
// elimination. Here index[] stores pivoting order.
public static void gaussian(double a[][], int index[]) {
int n = index.length;
double c[] = new double[n];
// Initialize the index
for (int i=0; i<n; ++i)
index[i] = i;
// Find the rescaling factors, one from each row
for (int i=0; i<n; ++i) {
double c1 = 0;
for (int j=0; j<n; ++j) {
double c0 = Math.abs(a[i][j]);
if (c0 > c1) c1 = c0;
}
c[i] = c1;
}
// Search the pivoting element from each column
int k = 0;
for (int j=0; j<n-1; ++j) {
double pi1 = 0;
for (int i=j; i<n; ++i) {
double pi0 = Math.abs(a[index[i]][j]);
pi0 /= c[index[i]];
if (pi0 > pi1) {
pi1 = pi0;
k = i;
}
}
// Interchange rows according to the pivoting order
int itmp = index[j];
index[j] = index[k];
index[k] = itmp;
for (int i=j+1; i<n; ++i) {
double pj = a[index[i]][j]/a[index[j]][j];
// Record pivoting ratios below the diagonal
a[index[i]][j] = pj;
// Modify other elements accordingly
for (int l=j+1; l<n; ++l)
a[index[i]][l] -= pj*a[index[j]][l];
}
}
}
}
Ejemplo de ejecución
$ javac Inverse.java
$ java Inverse
Enter the dimension of square matrix:
2
Enter the elements of matrix:
1 2
3 4
The Inverse is:
-1.9999999999999998 1.0
1.4999999999999998 -0.49999999999999994
Parece que hay un problema con los redondeos decimales. Quien esté interesado aquí hay una explicación sobre redondeo: https://aprenderaprogramar.com/index.php?option=com_content&view=article&id=960:java-redondear-a-2-o-mas-decimales-errores-precision-bigdecimal-roundingmode-biginteger-cu00907c&catid=58&Itemid=180
Saludos